1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2016 Free Software Foundation, Inc.
3 Written by DJ Delorie <dj@cygnus.com>
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
25 #include "libiberty.h"
26 #include "filenames.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") },
238 { STRING_COMMA_LEN ("__dso_handle") },
242 #define PE_ARCH_i386 1
244 #define PE_ARCH_mips 3
245 #define PE_ARCH_arm 4
246 #define PE_ARCH_arm_epoc 5
247 #define PE_ARCH_arm_wince 6
249 /* Don't make it constant as underscore mode gets possibly overriden
250 by target or -(no-)leading-underscore option. */
251 static pe_details_type pe_detail_list[] =
270 autofilter_symbollist_i386
275 16 /* R_SH_IMAGEBASE */,
279 autofilter_symbollist_generic
288 autofilter_symbollist_generic
297 autofilter_symbollist_generic
300 "epoc-pei-arm-little",
301 "epoc-pe-arm-little",
306 autofilter_symbollist_generic
309 "pei-arm-wince-little",
310 "pe-arm-wince-little",
311 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
315 autofilter_symbollist_generic
317 { NULL, NULL, 0, 0, 0, FALSE, NULL }
320 static const pe_details_type *pe_details;
322 /* Do not specify library suffix explicitly, to allow for dllized versions. */
323 static const autofilter_entry_type autofilter_liblist[] =
325 { STRING_COMMA_LEN ("libcegcc") },
326 { STRING_COMMA_LEN ("libcygwin") },
327 { STRING_COMMA_LEN ("libgcc") },
328 { STRING_COMMA_LEN ("libgcc_s") },
329 { STRING_COMMA_LEN ("libstdc++") },
330 { STRING_COMMA_LEN ("libmingw32") },
331 { STRING_COMMA_LEN ("libmingwex") },
332 { STRING_COMMA_LEN ("libg2c") },
333 { STRING_COMMA_LEN ("libsupc++") },
334 { STRING_COMMA_LEN ("libobjc") },
335 { STRING_COMMA_LEN ("libgcj") },
339 /* Regardless of the suffix issue mentioned above, we must ensure that
340 we do not falsely match on a leading substring, such as when libtool
341 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
342 This routine ensures that the leading part of the name matches and that
343 it is followed by only an optional version suffix and a file extension,
344 returning zero if so or -1 if not. */
345 static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
347 if (filename_ncmp (libname, afptr->name, afptr->len))
350 libname += afptr->len;
352 /* Be liberal in interpreting what counts as a version suffix; we
353 accept anything that has a dash to separate it from the name and
354 begins with a digit. */
355 if (libname[0] == '-')
357 if (!ISDIGIT (*++libname))
359 /* Ensure the filename has an extension. */
360 while (*++libname != '.')
364 else if (libname[0] != '.')
370 static const autofilter_entry_type autofilter_objlist[] =
372 { STRING_COMMA_LEN ("crt0.o") },
373 { STRING_COMMA_LEN ("crt1.o") },
374 { STRING_COMMA_LEN ("crt2.o") },
375 { STRING_COMMA_LEN ("dllcrt1.o") },
376 { STRING_COMMA_LEN ("dllcrt2.o") },
377 { STRING_COMMA_LEN ("gcrt0.o") },
378 { STRING_COMMA_LEN ("gcrt1.o") },
379 { STRING_COMMA_LEN ("gcrt2.o") },
380 { STRING_COMMA_LEN ("crtbegin.o") },
381 { STRING_COMMA_LEN ("crtend.o") },
385 static const autofilter_entry_type autofilter_symbolprefixlist[] =
387 /* _imp_ is treated specially, as it is always underscored. */
388 /* { STRING_COMMA_LEN ("_imp_") }, */
389 /* Don't export some c++ symbols. */
390 { STRING_COMMA_LEN ("__rtti_") },
391 { STRING_COMMA_LEN ("__builtin_") },
392 /* Don't re-export auto-imported symbols. */
393 { STRING_COMMA_LEN ("__nm_") },
394 /* Don't export symbols specifying internal DLL layout. */
395 { STRING_COMMA_LEN ("_head_") },
396 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
397 /* Don't export section labels or artificial symbols
399 { STRING_COMMA_LEN (".") },
403 static const autofilter_entry_type autofilter_symbolsuffixlist[] =
405 { STRING_COMMA_LEN ("_iname") },
406 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
410 #define U(str) (pe_details->underscored ? "_" str : str)
413 pe_dll_id_target (const char *target)
417 for (i = 0; pe_detail_list[i].target_name; i++)
418 if (strcmp (pe_detail_list[i].target_name, target) == 0
419 || strcmp (pe_detail_list[i].object_target, target) == 0)
421 int u = pe_leading_underscore; /* Underscoring mode. -1 for use default. */
423 bfd_get_target_info (target, NULL, NULL, &u, NULL);
426 pe_detail_list[i].underscored = (u != 0 ? TRUE : FALSE);
427 pe_details = pe_detail_list + i;
428 pe_leading_underscore = (u != 0 ? 1 : 0);
431 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
435 /* Helper functions for qsort. Relocs must be sorted so that we can write
436 them out by pages. */
447 reloc_sort (const void *va, const void *vb)
449 bfd_vma a = ((const reloc_data_type *) va)->vma;
450 bfd_vma b = ((const reloc_data_type *) vb)->vma;
452 return (a > b) ? 1 : ((a < b) ? -1 : 0);
456 pe_export_sort (const void *va, const void *vb)
458 const def_file_export *a = va;
459 const def_file_export *b = vb;
467 return strcmp (an, bn);
470 /* Read and process the .DEF file. */
472 /* These correspond to the entries in pe_def_file->exports[]. I use
473 exported_symbol_sections[i] to tag whether or not the symbol was
474 defined, since we can't export symbols we don't have. */
476 static bfd_vma *exported_symbol_offsets;
477 static struct bfd_section **exported_symbol_sections;
478 static int export_table_size;
479 static int count_exported;
480 static int count_exported_byname;
481 static int count_with_ordinals;
482 static const char *dll_name;
483 static int min_ordinal, max_ordinal;
484 static int *exported_symbols;
486 typedef struct exclude_list_struct
489 struct exclude_list_struct *next;
494 static struct exclude_list_struct *excludes = 0;
497 pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
500 char *exclude_string;
502 local_copy = xstrdup (new_excludes);
504 exclude_string = strtok (local_copy, ",:");
505 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
507 struct exclude_list_struct *new_exclude;
509 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
510 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
511 strcpy (new_exclude->string, exclude_string);
512 new_exclude->type = type;
513 new_exclude->next = excludes;
514 excludes = new_exclude;
521 is_import (const char* n)
523 return (CONST_STRNEQ (n, "__imp_"));
526 /* abfd is a bfd containing n (or NULL)
527 It can be used for contextual checks. */
530 auto_export (bfd *abfd, def_file *d, const char *n)
533 struct exclude_list_struct *ex;
534 const autofilter_entry_type *afptr;
535 const char * libname = NULL;
537 if (abfd && abfd->my_archive)
538 libname = lbasename (abfd->my_archive->filename);
540 key.name = key.its_name = (char *) n;
542 /* Return false if n is in the d->exports table. */
543 if (bsearch (&key, d->exports, d->num_exports,
544 sizeof (pe_def_file->exports[0]), pe_export_sort))
547 if (pe_dll_do_default_excludes)
552 if (pe_dll_extra_pe_debug)
553 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
554 n, abfd, abfd->my_archive);
556 /* First of all, make context checks:
557 Don't export anything from standard libs. */
560 afptr = autofilter_liblist;
564 if (libnamencmp (libname, afptr) == 0 )
570 /* Next, exclude symbols from certain startup objects. */
572 if (abfd && (p = lbasename (abfd->filename)))
574 afptr = autofilter_objlist;
577 if (strcmp (p, afptr->name) == 0)
583 /* Don't try to blindly exclude all symbols
584 that begin with '__'; this was tried and
585 it is too restrictive. Instead we have
586 a target specific list to use: */
587 afptr = pe_details->autofilter_symbollist;
591 if (strcmp (n, afptr->name) == 0)
597 /* Next, exclude symbols starting with ... */
598 afptr = autofilter_symbolprefixlist;
601 if (strncmp (n, afptr->name, afptr->len) == 0)
607 /* Finally, exclude symbols ending with ... */
609 afptr = autofilter_symbolsuffixlist;
612 if ((len >= afptr->len)
613 /* Add 1 to insure match with trailing '\0'. */
614 && strncmp (n + len - afptr->len, afptr->name,
615 afptr->len + 1) == 0)
622 for (ex = excludes; ex; ex = ex->next)
624 if (ex->type == EXCLUDELIBS)
627 && ((filename_cmp (libname, ex->string) == 0)
628 || (strcasecmp ("ALL", ex->string) == 0)))
631 else if (ex->type == EXCLUDEFORIMPLIB)
633 if (filename_cmp (abfd->filename, ex->string) == 0)
636 else if (strcmp (n, ex->string) == 0)
644 process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
647 struct bfd_link_hash_entry *blhe;
649 struct bfd_section *s;
650 def_file_export *e = 0;
651 bfd_boolean resort_needed;
654 pe_def_file = def_file_empty ();
656 /* First, run around to all the objects looking for the .drectve
657 sections, and push those into the def file too. */
658 for (b = info->input_bfds; b; b = b->link.next)
660 s = bfd_get_section_by_name (b, ".drectve");
664 char *buf = xmalloc (size);
666 bfd_get_section_contents (b, s, buf, 0, size);
667 def_file_add_directive (pe_def_file, buf, size);
672 /* Process aligned common symbol information from the
673 .drectve sections now; common symbol allocation is
674 done before final link, so it will be too late to
675 process them in process_embedded_commands() called
676 from _bfd_coff_link_input_bfd(). */
677 if (pe_def_file->aligncomms)
679 def_file_aligncomm *ac = pe_def_file->aligncomms;
682 struct coff_link_hash_entry *sym_hash;
683 sym_hash = coff_link_hash_lookup (coff_hash_table (info),
684 ac->symbol_name, FALSE, FALSE, FALSE);
685 if (sym_hash && sym_hash->root.type == bfd_link_hash_common
686 && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
688 sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
694 /* If we are building an executable and there is nothing
695 to export, we do not build an export table at all. */
696 if (bfd_link_executable (info) && pe_def_file->num_exports == 0
697 && (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
700 /* Now, maybe export everything else the default way. */
701 if ((pe_dll_export_everything || pe_def_file->num_exports == 0)
702 && !pe_dll_exclude_all_symbols)
704 for (b = info->input_bfds; b; b = b->link.next)
709 if (!bfd_generic_link_read_symbols (b))
711 einfo (_("%B%F: could not read symbols: %E\n"), b);
715 symbols = bfd_get_outsymbols (b);
716 nsyms = bfd_get_symcount (b);
718 for (j = 0; j < nsyms; j++)
720 /* We should export symbols which are either global or not
721 anything at all. (.bss data is the latter)
722 We should not export undefined symbols. */
723 bfd_boolean would_export
724 = (symbols[j]->section != bfd_und_section_ptr
725 && ((symbols[j]->flags & BSF_GLOBAL)
726 || (symbols[j]->flags == 0)));
727 if (link_info.version_info && would_export)
729 = !bfd_hide_sym_by_version (link_info.version_info,
733 const char *sn = symbols[j]->name;
735 /* We should not re-export imported stuff. */
741 name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
742 sprintf (name, "%s%s", "__imp_", sn);
744 blhe = bfd_link_hash_lookup (info->hash, name,
745 FALSE, FALSE, FALSE);
748 if (blhe && blhe->type == bfd_link_hash_defined)
752 if (pe_details->underscored && *sn == '_')
755 if (auto_export (b, pe_def_file, sn))
760 p = def_file_add_export (pe_def_file, sn, 0, -1,
762 /* Fill data flag properly, from dlltool.c. */
764 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
772 #define NE pe_def_file->num_exports
774 /* Don't create an empty export table. */
778 resort_needed = FALSE;
780 /* Canonicalize the export list. */
783 for (i = 0; i < NE; i++)
785 /* Check for fastcall/stdcall-decoration, but ignore
786 C++ mangled names. */
787 if (pe_def_file->exports[i].name[0] != '?'
788 && strchr (pe_def_file->exports[i].name, '@'))
790 /* This will preserve internal_name, which may have been
791 pointing to the same memory as name, or might not
793 int lead_at = (*pe_def_file->exports[i].name == '@');
794 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
795 char *tmp_at = strrchr (tmp, '@');
800 einfo (_("%XCannot export %s: invalid export name\n"),
801 pe_def_file->exports[i].name);
802 pe_def_file->exports[i].name = tmp;
803 resort_needed = TRUE;
808 /* Re-sort the exports table as we have possibly changed the order
809 by removing leading @. */
811 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
814 if (pe_dll_stdcall_aliases)
816 for (i = 0; i < NE; i++)
818 if (is_import (pe_def_file->exports[i].name))
821 if (strchr (pe_def_file->exports[i].name, '@'))
824 int lead_at = (*pe_def_file->exports[i].name == '@');
825 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
827 *(strchr (tmp, '@')) = 0;
828 if (auto_export (NULL, pe_def_file, tmp))
829 def_file_add_export (pe_def_file, tmp,
830 pe_def_file->exports[i].internal_name,
838 /* Convenience, but watch out for it changing. */
839 e = pe_def_file->exports;
841 for (i = 0, j = 0; i < NE; i++)
843 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
845 /* This is a duplicate. */
846 if (e[j - 1].ordinal != -1
847 && e[i].ordinal != -1
848 && e[j - 1].ordinal != e[i].ordinal)
850 if (pe_dll_warn_dup_exports)
851 /* xgettext:c-format */
852 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
853 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
857 if (pe_dll_warn_dup_exports)
858 /* xgettext:c-format */
859 einfo (_("Warning, duplicate EXPORT: %s\n"),
863 if (e[i].ordinal != -1)
864 e[j - 1].ordinal = e[i].ordinal;
865 e[j - 1].flag_private |= e[i].flag_private;
866 e[j - 1].flag_constant |= e[i].flag_constant;
867 e[j - 1].flag_noname |= e[i].flag_noname;
868 e[j - 1].flag_data |= e[i].flag_data;
871 if (e[i].internal_name)
872 free (e[i].internal_name);
874 free (e[i].its_name);
883 pe_def_file->num_exports = j; /* == NE */
885 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
886 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
888 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
892 count_exported_byname = 0;
893 count_with_ordinals = 0;
895 for (i = 0; i < NE; i++)
897 char *int_name = pe_def_file->exports[i].internal_name;
900 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
901 lang_add_gc_name (int_name);
903 name = xmalloc (strlen (int_name) + 2);
904 if (pe_details->underscored && int_name[0] != '@')
907 strcpy (name + 1, int_name);
910 strcpy (name, int_name);
912 blhe = bfd_link_hash_lookup (info->hash,
917 && (blhe->type == bfd_link_hash_defined
918 || (blhe->type == bfd_link_hash_common)))
921 if (!pe_def_file->exports[i].flag_noname)
922 count_exported_byname++;
924 /* Only fill in the sections. The actual offsets are computed
925 in fill_exported_offsets() after common symbols are laid
927 if (blhe->type == bfd_link_hash_defined)
928 exported_symbol_sections[i] = blhe->u.def.section;
930 exported_symbol_sections[i] = blhe->u.c.p->section;
932 if (pe_def_file->exports[i].ordinal != -1)
934 if (max_ordinal < pe_def_file->exports[i].ordinal)
935 max_ordinal = pe_def_file->exports[i].ordinal;
936 if (min_ordinal > pe_def_file->exports[i].ordinal)
937 min_ordinal = pe_def_file->exports[i].ordinal;
938 count_with_ordinals++;
941 /* Check for forward exports. These are indicated in DEF files by an
942 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
943 but we must take care not to be fooled when the user wants to export
944 a symbol that actually really has a dot in it, so we only check
945 for them here, after real defined symbols have already been matched. */
946 else if (strchr (int_name, '.'))
949 if (!pe_def_file->exports[i].flag_noname)
950 count_exported_byname++;
952 pe_def_file->exports[i].flag_forward = 1;
954 if (pe_def_file->exports[i].ordinal != -1)
956 if (max_ordinal < pe_def_file->exports[i].ordinal)
957 max_ordinal = pe_def_file->exports[i].ordinal;
958 if (min_ordinal > pe_def_file->exports[i].ordinal)
959 min_ordinal = pe_def_file->exports[i].ordinal;
960 count_with_ordinals++;
963 else if (blhe && blhe->type == bfd_link_hash_undefined)
965 /* xgettext:c-format */
966 einfo (_("%XCannot export %s: symbol not defined\n"),
971 /* xgettext:c-format */
972 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
974 blhe->type, bfd_link_hash_defined);
978 /* xgettext:c-format */
979 einfo (_("%XCannot export %s: symbol not found\n"),
986 /* Build the bfd that will contain .edata and .reloc sections. */
989 build_filler_bfd (int include_edata)
991 lang_input_statement_type *filler_file;
992 filler_file = lang_add_input_file ("dll stuff",
993 lang_input_file_is_fake_enum,
995 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff",
996 link_info.output_bfd);
997 if (filler_bfd == NULL
998 || !bfd_set_arch_mach (filler_bfd,
999 bfd_get_arch (link_info.output_bfd),
1000 bfd_get_mach (link_info.output_bfd)))
1002 einfo ("%X%P: can not create BFD: %E\n");
1008 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
1010 || !bfd_set_section_flags (filler_bfd, edata_s,
1017 einfo ("%X%P: can not create .edata section: %E\n");
1020 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
1023 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
1025 || !bfd_set_section_flags (filler_bfd, reloc_s,
1032 einfo ("%X%P: can not create .reloc section: %E\n");
1036 bfd_set_section_size (filler_bfd, reloc_s, 0);
1038 ldlang_add_file (filler_file);
1041 /* Gather all the exported symbols and build the .edata section. */
1044 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1046 int i, next_ordinal;
1047 int name_table_size = 0;
1050 /* First, we need to know how many exported symbols there are,
1051 and what the range of ordinals is. */
1052 if (pe_def_file->name)
1053 dll_name = pe_def_file->name;
1056 dll_name = abfd->filename;
1058 for (dlnp = dll_name; *dlnp; dlnp++)
1059 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
1060 dll_name = dlnp + 1;
1063 if (count_with_ordinals && max_ordinal > count_exported)
1065 if (min_ordinal > max_ordinal - count_exported + 1)
1066 min_ordinal = max_ordinal - count_exported + 1;
1071 max_ordinal = count_exported;
1074 export_table_size = max_ordinal - min_ordinal + 1;
1075 exported_symbols = xmalloc (export_table_size * sizeof (int));
1076 for (i = 0; i < export_table_size; i++)
1077 exported_symbols[i] = -1;
1079 /* Now we need to assign ordinals to those that don't have them. */
1080 for (i = 0; i < NE; i++)
1082 if (exported_symbol_sections[i] ||
1083 pe_def_file->exports[i].flag_forward)
1085 if (pe_def_file->exports[i].ordinal != -1)
1087 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
1088 int pi = exported_symbols[ei];
1092 /* xgettext:c-format */
1093 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1094 pe_def_file->exports[i].ordinal,
1095 pe_def_file->exports[i].name,
1096 pe_def_file->exports[pi].name);
1098 exported_symbols[ei] = i;
1100 if (pe_def_file->exports[i].its_name)
1101 name_table_size += strlen (pe_def_file->exports[i].its_name) + 1;
1103 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
1106 /* Reserve space for the forward name. */
1107 if (pe_def_file->exports[i].flag_forward)
1109 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
1113 next_ordinal = min_ordinal;
1114 for (i = 0; i < NE; i++)
1115 if ((exported_symbol_sections[i] ||
1116 pe_def_file->exports[i].flag_forward) &&
1117 pe_def_file->exports[i].ordinal == -1)
1119 while (exported_symbols[next_ordinal - min_ordinal] != -1)
1122 exported_symbols[next_ordinal - min_ordinal] = i;
1123 pe_def_file->exports[i].ordinal = next_ordinal;
1126 /* OK, now we can allocate some memory. */
1127 edata_sz = (40 /* directory */
1128 + 4 * export_table_size /* addresses */
1129 + 4 * count_exported_byname /* name ptrs */
1130 + 2 * count_exported_byname /* ordinals */
1131 + name_table_size + strlen (dll_name) + 1);
1134 /* Fill the exported symbol offsets. The preliminary work has already
1135 been done in process_def_file_and_drectve(). */
1138 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
1141 struct bfd_link_hash_entry *blhe;
1143 for (i = 0; i < pe_def_file->num_exports; i++)
1147 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
1148 if (pe_details->underscored
1149 && *pe_def_file->exports[i].internal_name != '@')
1152 strcpy (name + 1, pe_def_file->exports[i].internal_name);
1155 strcpy (name, pe_def_file->exports[i].internal_name);
1157 blhe = bfd_link_hash_lookup (info->hash,
1159 FALSE, FALSE, TRUE);
1161 if (blhe && blhe->type == bfd_link_hash_defined)
1162 exported_symbol_offsets[i] = blhe->u.def.value;
1169 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1172 unsigned char *edirectory;
1173 unsigned char *eaddresses;
1174 unsigned char *enameptrs;
1175 unsigned char *eordinals;
1178 edata_d = xmalloc (edata_sz);
1180 /* Note use of array pointer math here. */
1181 edirectory = edata_d;
1182 eaddresses = edirectory + 40;
1183 enameptrs = eaddresses + 4 * export_table_size;
1184 eordinals = enameptrs + 4 * count_exported_byname;
1185 enamestr = (char *) eordinals + 2 * count_exported_byname;
1187 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1188 + edata_s->output_section->vma - image_base)
1190 memset (edata_d, 0, edata_sz);
1192 if (pe_data (abfd)->insert_timestamp)
1193 H_PUT_32 (abfd, time (0), edata_d + 4);
1195 if (pe_def_file->version_major != -1)
1197 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1198 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1201 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1202 strcpy (enamestr, dll_name);
1203 enamestr += strlen (enamestr) + 1;
1204 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1205 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1206 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1207 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1208 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1209 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1211 fill_exported_offsets (abfd, info);
1213 /* Ok, now for the filling in part.
1214 Scan alphabetically - ie the ordering in the exports[] table,
1215 rather than by ordinal - the ordering in the exported_symbol[]
1216 table. See dlltool.c and:
1217 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1218 for more information. */
1220 for (s = 0; s < NE; s++)
1222 struct bfd_section *ssec = exported_symbol_sections[s];
1223 if (pe_def_file->exports[s].ordinal != -1 &&
1224 (pe_def_file->exports[s].flag_forward || ssec != NULL))
1226 int ord = pe_def_file->exports[s].ordinal;
1228 if (pe_def_file->exports[s].flag_forward)
1230 bfd_put_32 (abfd, ERVA (enamestr),
1231 eaddresses + 4 * (ord - min_ordinal));
1233 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1234 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1238 bfd_vma srva = (exported_symbol_offsets[s]
1239 + ssec->output_section->vma
1240 + ssec->output_offset);
1242 bfd_put_32 (abfd, srva - image_base,
1243 eaddresses + 4 * (ord - min_ordinal));
1246 if (!pe_def_file->exports[s].flag_noname)
1248 char *ename = pe_def_file->exports[s].name;
1249 if (pe_def_file->exports[s].its_name)
1250 ename = pe_def_file->exports[s].its_name;
1252 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1254 strcpy (enamestr, ename);
1255 enamestr += strlen (enamestr) + 1;
1256 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1258 pe_def_file->exports[s].hint = hint++;
1265 static struct bfd_section *current_sec;
1268 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1270 int (*cb) (arelent *, asection *))
1275 for (b = info->input_bfds; b; b = b->link.next)
1279 if (!bfd_generic_link_read_symbols (b))
1281 einfo (_("%B%F: could not read symbols: %E\n"), b);
1285 symbols = bfd_get_outsymbols (b);
1287 for (s = b->sections; s; s = s->next)
1290 int relsize, nrelocs, i;
1291 int flags = bfd_get_section_flags (b, s);
1293 /* Skip discarded linkonce sections. */
1294 if (flags & SEC_LINK_ONCE
1295 && s->output_section == bfd_abs_section_ptr)
1300 relsize = bfd_get_reloc_upper_bound (b, s);
1301 relocs = xmalloc (relsize);
1302 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1304 for (i = 0; i < nrelocs; i++)
1306 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1308 if (!strcmp (name, sym->name))
1314 /* Warning: the allocated symbols are remembered in BFD and reused
1315 later, so don't free them! */
1316 /* free (symbols); */
1321 /* Gather all the relocations and build the .reloc section. */
1324 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1327 /* For .reloc stuff. */
1328 reloc_data_type *reloc_data;
1329 int total_relocs = 0;
1331 bfd_vma sec_page = (bfd_vma) -1;
1332 bfd_vma page_ptr, page_count;
1335 struct bfd_section *s;
1338 for (b = info->input_bfds; b; b = b->link.next)
1339 for (s = b->sections; s; s = s->next)
1340 total_relocs += s->reloc_count;
1342 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1346 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link.next)
1349 int relsize, nrelocs;
1351 for (s = b->sections; s; s = s->next)
1353 bfd_vma sec_vma = s->output_section->vma + s->output_offset;
1356 /* If it's not loaded, we don't need to relocate it this way. */
1357 if (!(s->output_section->flags & SEC_LOAD))
1360 /* I don't know why there would be a reloc for these, but I've
1361 seen it happen - DJ */
1362 if (s->output_section == bfd_abs_section_ptr)
1365 if (s->output_section->vma == 0)
1367 /* Huh? Shouldn't happen, but punt if it does. */
1368 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1369 s->output_section->name, s->output_section->index,
1370 s->output_section->flags);
1374 if (!bfd_generic_link_read_symbols (b))
1376 einfo (_("%B%F: could not read symbols: %E\n"), b);
1380 symbols = bfd_get_outsymbols (b);
1381 relsize = bfd_get_reloc_upper_bound (b, s);
1382 relocs = xmalloc (relsize);
1383 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1385 for (i = 0; i < nrelocs; i++)
1387 if (pe_dll_extra_pe_debug)
1389 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1390 printf ("rel: %s\n", sym->name);
1392 if (!relocs[i]->howto->pc_relative
1393 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1395 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1397 /* Don't create relocs for undefined weak symbols. */
1398 if (sym->flags == BSF_WEAK)
1400 struct bfd_link_hash_entry *blhe
1401 = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
1402 FALSE, FALSE, FALSE);
1403 if (blhe && blhe->type == bfd_link_hash_undefweak)
1405 /* Check aux sym and see if it is defined or not. */
1406 struct coff_link_hash_entry *h, *h2;
1407 h = (struct coff_link_hash_entry *)blhe;
1408 if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
1410 h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
1411 [h->aux->x_sym.x_tagndx.l];
1412 /* We don't want a base reloc if the aux sym is not
1413 found, undefined, or if it is the constant ABS
1414 zero default value. (We broaden that slightly by
1415 not testing the value, just the section; there's
1416 no reason we'd want a reference to any absolute
1417 address to get relocated during rebasing). */
1418 if (!h2 || h2->root.type == bfd_link_hash_undefined
1419 || h2->root.u.def.section == bfd_abs_section_ptr)
1422 else if (!blhe || blhe->type != bfd_link_hash_defined)
1425 /* Nor for Dwarf FDE references to discarded sections. */
1426 else if (bfd_is_abs_section (sym->section->output_section))
1428 /* We only ignore relocs from .eh_frame sections, as
1429 they are discarded by the final link rather than
1430 resolved against the kept section. */
1431 if (!strcmp (s->name, ".eh_frame"))
1435 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1437 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1439 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1440 relocs[i]->howto->rightshift)
1442 #ifdef pe_use_x86_64
1443 case BITS_AND_SHIFT (64, 0):
1444 reloc_data[total_relocs].type = 10;
1448 case BITS_AND_SHIFT (32, 0):
1449 reloc_data[total_relocs].type = 3;
1452 case BITS_AND_SHIFT (16, 0):
1453 reloc_data[total_relocs].type = 2;
1456 case BITS_AND_SHIFT (16, 16):
1457 reloc_data[total_relocs].type = 4;
1458 /* FIXME: we can't know the symbol's right value
1459 yet, but we probably can safely assume that
1460 CE will relocate us in 64k blocks, so leaving
1462 reloc_data[total_relocs].extra = 0;
1465 case BITS_AND_SHIFT (26, 2):
1466 reloc_data[total_relocs].type = 5;
1469 case BITS_AND_SHIFT (24, 2):
1470 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1471 Those ARM_xxx definitions should go in proper
1473 if (relocs[i]->howto->type == 0
1474 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1475 || relocs[i]->howto->type == 5)
1476 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1477 that has already been fully processed during a
1478 previous link stage, so ignore it here. */
1482 /* xgettext:c-format */
1483 einfo (_("%XError: %d-bit reloc in dll\n"),
1484 relocs[i]->howto->bitsize);
1490 /* Warning: the allocated symbols are remembered in BFD and
1491 reused later, so don't free them! */
1495 /* At this point, we have total_relocs relocation addresses in
1496 reloc_addresses, which are all suitable for the .reloc section.
1497 We must now create the new sections. */
1498 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1500 for (i = 0; i < total_relocs; i++)
1502 bfd_vma this_page = (reloc_data[i].vma >> 12);
1504 if (this_page != sec_page)
1506 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1508 sec_page = this_page;
1513 if (reloc_data[i].type == 4)
1517 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1518 reloc_d = xmalloc (reloc_sz);
1519 sec_page = (bfd_vma) -1;
1521 page_ptr = (bfd_vma) -1;
1524 for (i = 0; i < total_relocs; i++)
1526 bfd_vma rva = reloc_data[i].vma - image_base;
1527 bfd_vma this_page = (rva & ~0xfff);
1529 if (this_page != sec_page)
1531 while (reloc_sz & 3)
1532 reloc_d[reloc_sz++] = 0;
1534 if (page_ptr != (bfd_vma) -1)
1535 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1537 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1538 page_ptr = reloc_sz;
1540 sec_page = this_page;
1544 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1545 reloc_d + reloc_sz);
1548 if (reloc_data[i].type == 4)
1550 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1557 while (reloc_sz & 3)
1558 reloc_d[reloc_sz++] = 0;
1560 if (page_ptr != (bfd_vma) -1)
1561 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1563 while (reloc_sz < reloc_s->size)
1564 reloc_d[reloc_sz++] = 0;
1567 /* Given the exiting def_file structure, print out a .DEF file that
1568 corresponds to it. */
1571 quoteput (char *s, FILE *f, int needs_quotes)
1575 for (cp = s; *cp; cp++)
1590 if (*s == '"' || *s == '\\')
1604 pe_dll_generate_def_file (const char *pe_out_def_filename)
1607 FILE *out = fopen (pe_out_def_filename, "w");
1610 /* xgettext:c-format */
1611 einfo (_("%s: Can't open output def file %s\n"),
1612 program_name, pe_out_def_filename);
1616 if (pe_def_file->name)
1618 if (pe_def_file->is_dll)
1619 fprintf (out, "LIBRARY ");
1621 fprintf (out, "NAME ");
1623 quoteput (pe_def_file->name, out, 1);
1625 if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
1627 fprintf (out, " BASE=0x");
1628 fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
1630 fprintf (out, "\n");
1633 if (pe_def_file->description)
1635 fprintf (out, "DESCRIPTION ");
1636 quoteput (pe_def_file->description, out, 1);
1637 fprintf (out, "\n");
1640 if (pe_def_file->version_minor != -1)
1641 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1642 pe_def_file->version_minor);
1643 else if (pe_def_file->version_major != -1)
1644 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1646 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1647 fprintf (out, "\n");
1649 if (pe_def_file->stack_commit != -1)
1650 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1651 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1652 else if (pe_def_file->stack_reserve != -1)
1653 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1655 if (pe_def_file->heap_commit != -1)
1656 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1657 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1658 else if (pe_def_file->heap_reserve != -1)
1659 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1661 if (pe_def_file->num_section_defs > 0)
1663 fprintf (out, "\nSECTIONS\n\n");
1665 for (i = 0; i < pe_def_file->num_section_defs; i++)
1668 quoteput (pe_def_file->section_defs[i].name, out, 0);
1670 if (pe_def_file->section_defs[i].class)
1672 fprintf (out, " CLASS ");
1673 quoteput (pe_def_file->section_defs[i].class, out, 0);
1676 if (pe_def_file->section_defs[i].flag_read)
1677 fprintf (out, " READ");
1679 if (pe_def_file->section_defs[i].flag_write)
1680 fprintf (out, " WRITE");
1682 if (pe_def_file->section_defs[i].flag_execute)
1683 fprintf (out, " EXECUTE");
1685 if (pe_def_file->section_defs[i].flag_shared)
1686 fprintf (out, " SHARED");
1688 fprintf (out, "\n");
1692 if (pe_def_file->num_exports > 0)
1694 fprintf (out, "EXPORTS\n");
1696 for (i = 0; i < pe_def_file->num_exports; i++)
1698 def_file_export *e = pe_def_file->exports + i;
1700 quoteput (e->name, out, 0);
1702 if (e->internal_name && strcmp (e->internal_name, e->name))
1704 fprintf (out, " = ");
1705 quoteput (e->internal_name, out, 0);
1708 if (e->ordinal != -1)
1709 fprintf (out, " @%d", e->ordinal);
1711 if (e->flag_private)
1712 fprintf (out, " PRIVATE");
1714 if (e->flag_constant)
1715 fprintf (out, " CONSTANT");
1718 fprintf (out, " NONAME");
1721 fprintf (out, " DATA");
1723 fprintf (out, "\n");
1727 if (pe_def_file->num_imports > 0)
1729 fprintf (out, "\nIMPORTS\n\n");
1731 for (i = 0; i < pe_def_file->num_imports; i++)
1733 def_file_import *im = pe_def_file->imports + i;
1736 if (im->internal_name
1737 && (!im->name || strcmp (im->internal_name, im->name)))
1739 quoteput (im->internal_name, out, 0);
1740 fprintf (out, " = ");
1743 quoteput (im->module->name, out, 0);
1747 quoteput (im->name, out, 0);
1749 fprintf (out, "%d", im->ordinal);
1753 fprintf (out, " == ");
1754 quoteput (im->its_name, out, 0);
1757 fprintf (out, "\n");
1762 fprintf (out, _("; no contents available\n"));
1764 if (fclose (out) == EOF)
1765 /* xgettext:c-format */
1766 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1769 /* Generate the import library. */
1771 static asymbol **symtab;
1774 static int tmp_seq2;
1775 static const char *dll_filename;
1776 static char *dll_symname;
1778 #define UNDSEC bfd_und_section_ptr
1781 quick_section (bfd *abfd, const char *name, int flags, int align)
1786 sec = bfd_make_section_old_way (abfd, name);
1787 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1788 bfd_set_section_alignment (abfd, sec, align);
1789 /* Remember to undo this before trying to link internally! */
1790 sec->output_section = sec;
1792 sym = bfd_make_empty_symbol (abfd);
1793 symtab[symptr++] = sym;
1794 sym->name = sec->name;
1796 sym->flags = BSF_LOCAL;
1803 quick_symbol (bfd *abfd,
1812 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1817 sym = bfd_make_empty_symbol (abfd);
1822 symtab[symptr++] = sym;
1825 static arelent *reltab = 0;
1826 static int relcount = 0, relsize = 0;
1829 quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
1831 if (relcount >= relsize - 1)
1835 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1837 reltab = xmalloc (relsize * sizeof (arelent));
1839 reltab[relcount].address = address;
1840 reltab[relcount].addend = 0;
1841 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1842 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1847 save_relocs (asection *sec)
1851 sec->relocation = reltab;
1852 sec->reloc_count = relcount;
1853 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1854 for (i = 0; i < relcount; i++)
1855 sec->orelocation[i] = sec->relocation + i;
1856 sec->orelocation[relcount] = 0;
1857 sec->flags |= SEC_RELOC;
1859 relcount = relsize = 0;
1862 /* .section .idata$2
1863 .global __head_my_dll
1880 make_head (bfd *parent)
1882 asection *id2, *id5, *id4;
1883 unsigned char *d2, *d5, *d4;
1887 oname = xmalloc (20);
1888 sprintf (oname, "d%06d.o", tmp_seq);
1891 abfd = bfd_create (oname, parent);
1892 bfd_find_target (pe_details->object_target, abfd);
1893 bfd_make_writable (abfd);
1895 bfd_set_format (abfd, bfd_object);
1896 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1899 symtab = xmalloc (6 * sizeof (asymbol *));
1900 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1901 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1902 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1903 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1904 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1906 /* OK, pay attention here. I got confused myself looking back at
1907 it. We create a four-byte section to mark the beginning of the
1908 list, and we include an offset of 4 in the section, so that the
1909 pointer to the list points to the *end* of this section, which is
1910 the start of the list of sections from other objects. */
1912 bfd_set_section_size (abfd, id2, 20);
1916 if (pe_use_nul_prefixed_import_tables)
1917 d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
1918 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1919 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1920 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1923 if (pe_use_nul_prefixed_import_tables)
1924 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1926 bfd_set_section_size (abfd, id5, 0);
1927 d5 = xmalloc (PE_IDATA5_SIZE);
1929 memset (d5, 0, PE_IDATA5_SIZE);
1930 if (pe_use_nul_prefixed_import_tables)
1931 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1933 bfd_set_section_size (abfd, id4, 0);
1934 d4 = xmalloc (PE_IDATA4_SIZE);
1936 memset (d4, 0, PE_IDATA4_SIZE);
1938 bfd_set_symtab (abfd, symtab, symptr);
1940 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1941 if (pe_use_nul_prefixed_import_tables)
1943 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1944 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1948 bfd_set_section_contents (abfd, id5, d5, 0, 0);
1949 bfd_set_section_contents (abfd, id4, d4, 0, 0);
1952 bfd_make_readable (abfd);
1956 /* .section .idata$4
1963 .global __my_dll_iname
1968 make_tail (bfd *parent)
1970 asection *id4, *id5, *id7;
1971 unsigned char *d4, *d5, *d7;
1976 oname = xmalloc (20);
1977 sprintf (oname, "d%06d.o", tmp_seq);
1980 abfd = bfd_create (oname, parent);
1981 bfd_find_target (pe_details->object_target, abfd);
1982 bfd_make_writable (abfd);
1984 bfd_set_format (abfd, bfd_object);
1985 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1988 symtab = xmalloc (5 * sizeof (asymbol *));
1989 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1990 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1991 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1992 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1994 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1995 d4 = xmalloc (PE_IDATA4_SIZE);
1997 memset (d4, 0, PE_IDATA4_SIZE);
1999 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2000 d5 = xmalloc (PE_IDATA5_SIZE);
2002 memset (d5, 0, PE_IDATA5_SIZE);
2004 len = strlen (dll_filename) + 1;
2007 bfd_set_section_size (abfd, id7, len);
2010 strcpy ((char *) d7, dll_filename);
2011 /* If len was odd, the above
2012 strcpy leaves behind an undefined byte. That is harmless,
2013 but we set it to 0 just so the binary dumps are pretty. */
2016 bfd_set_symtab (abfd, symtab, symptr);
2018 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2019 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2020 bfd_set_section_contents (abfd, id7, d7, 0, len);
2022 bfd_make_readable (abfd);
2028 .global ___imp_function
2029 .global __imp__function
2031 jmp *__imp__function:
2045 .asciz "function" xlate? (add underscore, kill at) */
2047 static const unsigned char jmp_ix86_bytes[] =
2049 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2057 .dw __imp_function */
2059 static const unsigned char jmp_sh_bytes[] =
2061 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2065 lui $t0,<high:__imp_function>
2066 lw $t0,<low:__imp_function>
2070 static const unsigned char jmp_mips_bytes[] =
2072 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2073 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2076 static const unsigned char jmp_arm_bytes[] =
2078 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2079 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2085 make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
2087 asection *tx, *id7, *id5, *id4, *id6;
2088 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
2092 const unsigned char *jmp_bytes = NULL;
2093 int jmp_byte_count = 0;
2095 /* Include the jump stub section only if it is needed. A jump
2096 stub is needed if the symbol being imported <sym> is a function
2097 symbol and there is at least one undefined reference to that
2098 symbol. In other words, if all the import references to <sym> are
2099 explicitly through _declspec(dllimport) then the jump stub is not
2101 if (include_jmp_stub)
2103 switch (pe_details->pe_arch)
2106 jmp_bytes = jmp_ix86_bytes;
2107 jmp_byte_count = sizeof (jmp_ix86_bytes);
2110 jmp_bytes = jmp_sh_bytes;
2111 jmp_byte_count = sizeof (jmp_sh_bytes);
2114 jmp_bytes = jmp_mips_bytes;
2115 jmp_byte_count = sizeof (jmp_mips_bytes);
2118 case PE_ARCH_arm_epoc:
2119 case PE_ARCH_arm_wince:
2120 jmp_bytes = jmp_arm_bytes;
2121 jmp_byte_count = sizeof (jmp_arm_bytes);
2128 oname = xmalloc (20);
2129 sprintf (oname, "d%06d.o", tmp_seq);
2132 abfd = bfd_create (oname, parent);
2133 bfd_find_target (pe_details->object_target, abfd);
2134 bfd_make_writable (abfd);
2136 bfd_set_format (abfd, bfd_object);
2137 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2140 symtab = xmalloc (12 * sizeof (asymbol *));
2142 tx = quick_section (abfd, ".text", SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY, 2);
2143 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2144 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2145 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2146 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
2148 if (*exp->internal_name == '@')
2150 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2152 if (include_jmp_stub)
2153 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
2154 quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
2156 /* Fastcall applies only to functions,
2157 so no need for auto-import symbol. */
2161 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2163 if (include_jmp_stub)
2164 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
2166 quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
2168 /* Symbol to reference ord/name of imported
2169 data symbol, used to implement auto-import. */
2171 quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
2174 if (pe_dll_compat_implib)
2175 quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
2178 if (include_jmp_stub)
2180 bfd_set_section_size (abfd, tx, jmp_byte_count);
2181 td = xmalloc (jmp_byte_count);
2183 memcpy (td, jmp_bytes, jmp_byte_count);
2185 switch (pe_details->pe_arch)
2188 #ifdef pe_use_x86_64
2189 quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
2191 /* Mark this object as SAFESEH compatible. */
2192 quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
2194 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
2198 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2201 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
2202 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
2203 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2206 case PE_ARCH_arm_epoc:
2207 case PE_ARCH_arm_wince:
2208 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2216 bfd_set_section_size (abfd, tx, 0);
2218 bfd_set_section_size (abfd, id7, 4);
2222 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2225 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2226 d5 = xmalloc (PE_IDATA5_SIZE);
2228 memset (d5, 0, PE_IDATA5_SIZE);
2230 if (exp->flag_noname)
2232 d5[0] = exp->ordinal;
2233 d5[1] = exp->ordinal >> 8;
2234 d5[PE_IDATA5_SIZE - 1] = 0x80;
2238 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2242 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2243 d4 = xmalloc (PE_IDATA4_SIZE);
2245 memset (d4, 0, PE_IDATA4_SIZE);
2247 if (exp->flag_noname)
2249 d4[0] = exp->ordinal;
2250 d4[1] = exp->ordinal >> 8;
2251 d4[PE_IDATA4_SIZE - 1] = 0x80;
2255 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2259 if (exp->flag_noname)
2262 bfd_set_section_size (abfd, id6, 0);
2266 /* { short, asciz } */
2268 len = 2 + strlen (exp->its_name) + 1;
2270 len = 2 + strlen (exp->name) + 1;
2273 bfd_set_section_size (abfd, id6, len);
2276 memset (d6, 0, len);
2277 d6[0] = exp->hint & 0xff;
2278 d6[1] = exp->hint >> 8;
2280 strcpy ((char*) d6 + 2, exp->its_name);
2282 strcpy ((char *) d6 + 2, exp->name);
2285 bfd_set_symtab (abfd, symtab, symptr);
2287 if (include_jmp_stub)
2288 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2289 bfd_set_section_contents (abfd, id7, d7, 0, 4);
2290 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2291 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2292 if (!exp->flag_noname)
2293 bfd_set_section_contents (abfd, id6, d6, 0, len);
2295 bfd_make_readable (abfd);
2300 make_singleton_name_imp (const char *import, bfd *parent)
2302 /* Name thunks go to idata$4. */
2308 oname = xmalloc (20);
2309 sprintf (oname, "nmimp%06d.o", tmp_seq2);
2312 abfd = bfd_create (oname, parent);
2313 bfd_find_target (pe_details->object_target, abfd);
2314 bfd_make_writable (abfd);
2316 bfd_set_format (abfd, bfd_object);
2317 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2320 symtab = xmalloc (3 * sizeof (asymbol *));
2321 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2322 quick_symbol (abfd, "__imp_", import, "", id5, BSF_GLOBAL, 0);
2324 /* We need space for the real thunk and for the null terminator. */
2325 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
2326 d5 = xmalloc (PE_IDATA5_SIZE * 2);
2328 memset (d5, 0, PE_IDATA5_SIZE * 2);
2329 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2332 bfd_set_symtab (abfd, symtab, symptr);
2334 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
2336 bfd_make_readable (abfd);
2341 make_singleton_name_thunk (const char *import, bfd *parent)
2343 /* Name thunks go to idata$4. */
2349 oname = xmalloc (20);
2350 sprintf (oname, "nmth%06d.o", tmp_seq);
2353 abfd = bfd_create (oname, parent);
2354 bfd_find_target (pe_details->object_target, abfd);
2355 bfd_make_writable (abfd);
2357 bfd_set_format (abfd, bfd_object);
2358 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2361 symtab = xmalloc (3 * sizeof (asymbol *));
2362 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2363 quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
2364 quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
2366 /* We need space for the real thunk and for the null terminator. */
2367 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2368 d4 = xmalloc (PE_IDATA4_SIZE * 2);
2370 memset (d4, 0, PE_IDATA4_SIZE * 2);
2371 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2374 bfd_set_symtab (abfd, symtab, symptr);
2376 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2378 bfd_make_readable (abfd);
2383 make_import_fixup_mark (arelent *rel)
2385 /* We convert reloc to symbol, for later reference. */
2387 static char *fixup_name = NULL;
2388 static size_t buffer_len = 0;
2390 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2392 bfd *abfd = bfd_asymbol_bfd (sym);
2393 struct bfd_link_hash_entry *bh;
2397 fixup_name = xmalloc (384);
2401 if (strlen (sym->name) + 25 > buffer_len)
2402 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2403 bigger than 20 digits long, we've got worse problems than
2404 overflowing this buffer... */
2407 /* New buffer size is length of symbol, plus 25, but
2408 then rounded up to the nearest multiple of 128. */
2409 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2410 fixup_name = xmalloc (buffer_len);
2413 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2416 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2417 current_sec, /* sym->section, */
2418 rel->address, NULL, TRUE, FALSE, &bh);
2423 /* .section .idata$2
2424 .rva __nm_thnk_SYM (singleton thunk with name of func)
2427 .rva __my_dll_iname (name of dll)
2428 .rva __fuNN_SYM (pointer to reference (address) in text) */
2431 make_import_fixup_entry (const char *name,
2432 const char *fixup_name,
2433 const char *symname,
2441 oname = xmalloc (20);
2442 sprintf (oname, "fu%06d.o", tmp_seq);
2445 abfd = bfd_create (oname, parent);
2446 bfd_find_target (pe_details->object_target, abfd);
2447 bfd_make_writable (abfd);
2449 bfd_set_format (abfd, bfd_object);
2450 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2453 symtab = xmalloc (6 * sizeof (asymbol *));
2454 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2456 quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
2457 quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2458 /* For relocator v2 we have to use the .idata$5 element and not
2460 if (link_info.pei386_runtime_pseudo_reloc == 2)
2461 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2463 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2465 bfd_set_section_size (abfd, id2, 20);
2470 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2471 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2472 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2475 bfd_set_symtab (abfd, symtab, symptr);
2477 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2479 bfd_make_readable (abfd);
2483 /* .section .rdata_runtime_pseudo_reloc
2485 .rva __fuNN_SYM (pointer to reference (address) in text) */
2488 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2489 const char *fixup_name,
2490 bfd_vma addend ATTRIBUTE_UNUSED,
2495 unsigned char *rt_rel_d;
2498 oname = xmalloc (20);
2499 sprintf (oname, "rtr%06d.o", tmp_seq);
2502 abfd = bfd_create (oname, parent);
2503 bfd_find_target (pe_details->object_target, abfd);
2504 bfd_make_writable (abfd);
2506 bfd_set_format (abfd, bfd_object);
2507 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2510 if (link_info.pei386_runtime_pseudo_reloc == 2)
2512 symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
2516 symtab = xmalloc (2 * sizeof (asymbol *));
2518 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2519 SEC_HAS_CONTENTS, 2);
2521 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2523 if (link_info.pei386_runtime_pseudo_reloc == 2)
2526 if (! runtime_pseudp_reloc_v2_init)
2529 runtime_pseudp_reloc_v2_init = 1;
2531 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2533 bfd_set_section_size (abfd, rt_rel, size);
2534 rt_rel_d = xmalloc (size);
2535 rt_rel->contents = rt_rel_d;
2536 memset (rt_rel_d, 0, size);
2537 quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
2538 quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
2539 bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
2541 bfd_put_32 (abfd, 1, rt_rel_d + 8);
2542 save_relocs (rt_rel);
2544 bfd_set_symtab (abfd, symtab, symptr);
2546 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
2550 bfd_set_section_size (abfd, rt_rel, 8);
2551 rt_rel_d = xmalloc (8);
2552 rt_rel->contents = rt_rel_d;
2553 memset (rt_rel_d, 0, 8);
2555 bfd_put_32 (abfd, addend, rt_rel_d);
2556 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2558 save_relocs (rt_rel);
2560 bfd_set_symtab (abfd, symtab, symptr);
2562 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2564 bfd_make_readable (abfd);
2569 .rva __pei386_runtime_relocator */
2572 pe_create_runtime_relocator_reference (bfd *parent)
2574 asection *extern_rt_rel;
2575 unsigned char *extern_rt_rel_d;
2579 oname = xmalloc (20);
2580 sprintf (oname, "ertr%06d.o", tmp_seq);
2583 abfd = bfd_create (oname, parent);
2584 bfd_find_target (pe_details->object_target, abfd);
2585 bfd_make_writable (abfd);
2587 bfd_set_format (abfd, bfd_object);
2588 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2591 symtab = xmalloc (2 * sizeof (asymbol *));
2592 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2594 quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2597 bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
2598 extern_rt_rel_d = xcalloc (1, PE_IDATA5_SIZE);
2599 extern_rt_rel->contents = extern_rt_rel_d;
2601 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2602 save_relocs (extern_rt_rel);
2604 bfd_set_symtab (abfd, symtab, symptr);
2606 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
2608 bfd_make_readable (abfd);
2613 pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend)
2616 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2617 struct bfd_link_hash_entry *name_thunk_sym;
2618 struct bfd_link_hash_entry *name_imp_sym;
2619 const char *name = sym->name;
2620 char *fixup_name = make_import_fixup_mark (rel);
2622 int need_import_table = 1;
2624 sprintf (buf, "__imp_%s", name);
2625 name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2627 sprintf (buf, "__nm_thnk_%s", name);
2629 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2631 /* For version 2 pseudo relocation we don't need to add an import
2632 if the import symbol is already present. */
2633 if (link_info.pei386_runtime_pseudo_reloc == 2
2635 && name_imp_sym->type == bfd_link_hash_defined)
2636 need_import_table = 0;
2638 if (need_import_table == 1
2639 && (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined))
2641 b = make_singleton_name_thunk (name, link_info.output_bfd);
2642 add_bfd_to_link (b, b->filename, &link_info);
2644 /* If we ever use autoimport, we have to cast text section writable.
2645 But not for version 2. */
2646 if (link_info.pei386_runtime_pseudo_reloc != 2)
2648 config.text_read_only = FALSE;
2649 link_info.output_bfd->flags &= ~WP_TEXT;
2651 if (link_info.pei386_runtime_pseudo_reloc == 2)
2653 b = make_singleton_name_imp (name, link_info.output_bfd);
2654 add_bfd_to_link (b, b->filename, &link_info);
2658 if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2659 && need_import_table == 1)
2661 extern char * pe_data_import_dll;
2662 char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2664 b = make_import_fixup_entry (name, fixup_name, symname,
2665 link_info.output_bfd);
2666 add_bfd_to_link (b, b->filename, &link_info);
2669 if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
2670 || link_info.pei386_runtime_pseudo_reloc == 2)
2672 if (pe_dll_extra_pe_debug)
2673 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2674 fixup_name, (int) addend);
2676 b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
2677 link_info.output_bfd);
2678 add_bfd_to_link (b, b->filename, &link_info);
2680 if (runtime_pseudo_relocs_created == 0)
2682 b = pe_create_runtime_relocator_reference (link_info.output_bfd);
2683 add_bfd_to_link (b, b->filename, &link_info);
2685 runtime_pseudo_relocs_created++;
2687 else if (addend != 0)
2689 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2690 s->owner, s, rel->address, sym->name);
2697 pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
2706 dll_filename = (def->name) ? def->name : dll_name;
2707 dll_symname = xstrdup (dll_filename);
2708 for (i = 0; dll_symname[i]; i++)
2709 if (!ISALNUM (dll_symname[i]))
2710 dll_symname[i] = '_';
2712 unlink_if_ordinary (impfilename);
2714 outarch = bfd_openw (impfilename, 0);
2718 /* xgettext:c-format */
2719 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2724 /* xgettext:c-format */
2725 info_msg (_("Creating library file: %s\n"), impfilename);
2727 bfd_set_format (outarch, bfd_archive);
2728 outarch->has_armap = 1;
2730 /* Work out a reasonable size of things to put onto one line. */
2731 ar_head = make_head (outarch);
2733 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2734 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
2736 /* Iterate the exclude list. */
2737 struct exclude_list_struct *ex;
2739 for (ex = excludes, found = 0; ex && !found; ex = ex->next)
2741 if (ex->type != EXCLUDEFORIMPLIB)
2743 found = (filename_cmp (ex->string, ibfd->filename) == 0);
2745 /* If it matched, we must open a fresh BFD for it (the original
2746 input BFD is still needed for the DLL's final link) and add
2747 it into the archive member chain. */
2750 bfd *newbfd = bfd_openr (ibfd->my_archive
2751 ? ibfd->my_archive->filename : ibfd->filename, NULL);
2754 einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
2757 if (ibfd->my_archive)
2759 /* Must now iterate through archive until we find the
2760 required member. A minor shame that we'll open the
2761 archive once per member that we require from it, and
2762 leak those archive bfds rather than reuse them. */
2763 bfd *arbfd = newbfd;
2764 if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
2766 einfo (_("%X%s(%s): can't find member in non-archive file"),
2767 ibfd->my_archive->filename, ibfd->filename);
2771 while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
2773 if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
2778 einfo (_("%X%s(%s): can't find member in archive"),
2779 ibfd->my_archive->filename, ibfd->filename);
2783 newbfd->archive_next = head;
2788 for (i = 0; i < def->num_exports; i++)
2790 /* The import library doesn't know about the internal name. */
2791 char *internal = def->exports[i].internal_name;
2794 /* Don't add PRIVATE entries to import lib. */
2795 if (pe_def_file->exports[i].flag_private)
2798 def->exports[i].internal_name = def->exports[i].name;
2800 /* PR 19803: If a symbol has been discard due to garbage
2801 collection then do not create any exports for it. */
2803 struct coff_link_hash_entry *h;
2805 h = coff_link_hash_lookup (coff_hash_table (info), internal,
2806 FALSE, FALSE, FALSE);
2808 /* If the symbol is hidden and undefined then it
2809 has been swept up by garbage collection. */
2810 && h->symbol_class == C_HIDDEN
2811 && h->root.u.def.section == bfd_und_section_ptr)
2814 /* If necessary, check with an underscore prefix as well. */
2815 if (pe_details->underscored && internal[0] != '@')
2819 name = xmalloc (strlen (internal) + 2);
2820 sprintf (name, "_%s", internal);
2822 h = coff_link_hash_lookup (coff_hash_table (info), name,
2823 FALSE, FALSE, FALSE);
2827 /* If the symbol is hidden and undefined then it
2828 has been swept up by garbage collection. */
2829 && h->symbol_class == C_HIDDEN
2830 && h->root.u.def.section == bfd_und_section_ptr)
2835 n = make_one (def->exports + i, outarch,
2836 ! (def->exports + i)->flag_data);
2837 n->archive_next = head;
2839 def->exports[i].internal_name = internal;
2842 ar_tail = make_tail (outarch);
2844 if (ar_head == NULL || ar_tail == NULL)
2847 /* Now stick them all into the archive. */
2848 ar_head->archive_next = head;
2849 ar_tail->archive_next = ar_head;
2852 if (! bfd_set_archive_head (outarch, head))
2853 einfo ("%Xbfd_set_archive_head: %E\n");
2855 if (! bfd_close (outarch))
2856 einfo ("%Xbfd_close %s: %E\n", impfilename);
2858 while (head != NULL)
2860 bfd *n = head->archive_next;
2866 static int undef_count = 0;
2874 static struct key_value *udef_table;
2876 static int undef_sort_cmp (const void *l1, const void *r1)
2878 const struct key_value *l = l1;
2879 const struct key_value *r = r1;
2881 return strcmp (l->key, r->key);
2884 static struct bfd_link_hash_entry *
2885 pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
2887 struct bfd_link_hash_entry *h = NULL;
2888 struct key_value *kv;
2889 struct key_value key;
2890 char *at, *lname = xmalloc (strlen (name) + 3);
2892 strcpy (lname, name);
2894 at = strchr (lname + (lname[0] == '@'), '@');
2899 kv = bsearch (&key, udef_table, undef_count, sizeof (struct key_value),
2904 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2905 if (h->type == bfd_link_hash_undefined)
2909 if (lname[0] == '?')
2912 if (at || lname[0] == '@')
2914 if (lname[0] == '@')
2916 if (pe_details->underscored)
2919 strcpy (lname, lname + 1);
2921 kv = bsearch (&key, udef_table, undef_count,
2922 sizeof (struct key_value), undef_sort_cmp);
2925 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2926 if (h->type == bfd_link_hash_undefined)
2931 *strchr (lname, '@') = 0;
2933 kv = bsearch (&key, udef_table, undef_count,
2934 sizeof (struct key_value), undef_sort_cmp);
2937 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2938 if (h->type == bfd_link_hash_undefined)
2944 strcat (lname, "@");
2946 kv = bsearch (&key, udef_table, undef_count,
2947 sizeof (struct key_value), undef_sort_cmp);
2951 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2952 if (h->type == bfd_link_hash_undefined)
2956 if (lname[0] == '_' && pe_details->underscored)
2960 memmove (lname + 1, lname, strlen (lname) + 1);
2965 kv = bsearch (&key, udef_table, undef_count,
2966 sizeof (struct key_value), undef_sort_cmp);
2970 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2971 if (h->type == bfd_link_hash_undefined)
2983 pe_undef_count (struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
2984 void *inf ATTRIBUTE_UNUSED)
2986 if (h->type == bfd_link_hash_undefined)
2992 pe_undef_fill (struct bfd_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
2994 if (h->type == bfd_link_hash_undefined)
2998 udef_table[undef_count].key = xstrdup (h->root.string);
2999 at = strchr (udef_table[undef_count].key
3000 + (udef_table[undef_count].key[0] == '@'), '@');
3003 udef_table[undef_count].oname = h->root.string;
3010 pe_create_undef_table (void)
3014 /* count undefined symbols */
3016 bfd_link_hash_traverse (link_info.hash, pe_undef_count, "");
3018 /* create and fill the corresponding table */
3019 udef_table = xmalloc (undef_count * sizeof (struct key_value));
3022 bfd_link_hash_traverse (link_info.hash, pe_undef_fill, "");
3025 qsort (udef_table, undef_count, sizeof (struct key_value), undef_sort_cmp);
3029 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
3031 lang_input_statement_type *fake_file;
3033 fake_file = lang_add_input_file (name,
3034 lang_input_file_is_fake_enum,
3036 fake_file->the_bfd = abfd;
3037 ldlang_add_file (fake_file);
3039 if (!bfd_link_add_symbols (abfd, linfo))
3040 einfo ("%Xaddsym %s: %E\n", name);
3044 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
3047 def_file_module *module;
3048 def_file_import *imp;
3050 pe_dll_id_target (bfd_get_target (output_bfd));
3055 imp = pe_def_file->imports;
3057 pe_create_undef_table ();
3059 for (module = pe_def_file->modules; module; module = module->next)
3061 int do_this_dll = 0;
3063 for (i = 0; i < pe_def_file->num_imports && imp[i].module != module; i++)
3065 if (i >= pe_def_file->num_imports)
3068 dll_filename = module->name;
3069 dll_symname = xstrdup (module->name);
3070 for (j = 0; dll_symname[j]; j++)
3071 if (!ISALNUM (dll_symname[j]))
3072 dll_symname[j] = '_';
3074 for (; i < pe_def_file->num_imports && imp[i].module == module; i++)
3076 def_file_export exp;
3077 struct bfd_link_hash_entry *blhe;
3078 int lead_at = (*imp[i].internal_name == '@');
3079 /* See if we need this import. */
3080 size_t len = strlen (imp[i].internal_name);
3081 char *name = xmalloc (len + 2 + 6);
3082 bfd_boolean include_jmp_stub = FALSE;
3083 bfd_boolean is_cdecl = FALSE;
3084 bfd_boolean is_undef = FALSE;
3086 if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
3090 sprintf (name, "%s", imp[i].internal_name);
3092 sprintf (name, "%s%s",U (""), imp[i].internal_name);
3094 blhe = bfd_link_hash_lookup (linfo->hash, name,
3095 FALSE, FALSE, FALSE);
3097 /* Include the jump stub for <sym> only if the <sym>
3099 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
3102 sprintf (name, "%s%s", "__imp_", imp[i].internal_name);
3104 sprintf (name, "%s%s%s", "__imp_", U (""),
3105 imp[i].internal_name);
3107 blhe = bfd_link_hash_lookup (linfo->hash, name,
3108 FALSE, FALSE, FALSE);
3110 is_undef = (blhe->type == bfd_link_hash_undefined);
3114 include_jmp_stub = TRUE;
3115 is_undef = (blhe->type == bfd_link_hash_undefined);
3118 if (is_cdecl && (!blhe || (blhe && blhe->type != bfd_link_hash_undefined)))
3120 sprintf (name, "%s%s",U (""), imp[i].internal_name);
3121 blhe = pe_find_cdecl_alias_match (linfo, name);
3122 include_jmp_stub = TRUE;
3124 is_undef = (blhe->type == bfd_link_hash_undefined);
3135 bfd *ar_head = make_head (output_bfd);
3136 add_bfd_to_link (ar_head, ar_head->filename, linfo);
3139 exp.internal_name = imp[i].internal_name;
3140 exp.name = imp[i].name;
3141 exp.its_name = imp[i].its_name;
3142 exp.ordinal = imp[i].ordinal;
3143 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
3144 exp.flag_private = 0;
3145 exp.flag_constant = 0;
3146 exp.flag_data = imp[i].data;
3147 exp.flag_noname = exp.name ? 0 : 1;
3148 one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
3149 add_bfd_to_link (one, one->filename, linfo);
3154 bfd *ar_tail = make_tail (output_bfd);
3155 add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
3164 free (udef_table[undef_count].key);
3169 /* We were handed a *.DLL file. Parse it and turn it into a set of
3170 IMPORTS directives in the def file. Return TRUE if the file was
3171 handled, FALSE if not. */
3174 pe_get16 (bfd *abfd, int where)
3178 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
3179 bfd_bread (b, (bfd_size_type) 2, abfd);
3180 return b[0] + (b[1] << 8);
3184 pe_get32 (bfd *abfd, int where)
3188 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
3189 bfd_bread (b, (bfd_size_type) 4, abfd);
3190 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
3196 unsigned char *b = ptr;
3198 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
3202 pe_implied_import_dll (const char *filename)
3205 bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
3206 bfd_vma export_rva, export_size, nsections, secptr, expptr;
3207 bfd_vma exp_funcbase;
3208 unsigned char *expdata;
3210 bfd_vma name_rvas, nexp;
3211 const char *dllname;
3212 /* Initialization with start > end guarantees that is_data
3213 will not be set by mistake, and avoids compiler warning. */
3214 bfd_vma data_start = 1;
3215 bfd_vma data_end = 0;
3216 bfd_vma rdata_start = 1;
3217 bfd_vma rdata_end = 0;
3218 bfd_vma bss_start = 1;
3219 bfd_vma bss_end = 0;
3221 /* No, I can't use bfd here. kernel32.dll puts its export table in
3222 the middle of the .rdata section. */
3223 dll = bfd_openr (filename, pe_details->target_name);
3226 einfo ("%Xopen %s: %E\n", filename);
3230 /* PEI dlls seem to be bfd_objects. */
3231 if (!bfd_check_format (dll, bfd_object))
3233 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
3237 /* Get pe_header, optional header and numbers of directory entries. */
3238 pe_header_offset = pe_get32 (dll, 0x3c);
3239 opthdr_ofs = pe_header_offset + 4 + 20;
3240 #ifdef pe_use_x86_64
3241 num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3243 num_entries = pe_get32 (dll, opthdr_ofs + 92);
3246 /* No import or export directory entry. */
3247 if (num_entries < 1)
3250 #ifdef pe_use_x86_64
3251 export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
3252 export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
3254 export_rva = pe_get32 (dll, opthdr_ofs + 96);
3255 export_size = pe_get32 (dll, opthdr_ofs + 100);
3258 /* No export table - nothing to export. */
3259 if (export_size == 0)
3262 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
3263 secptr = (pe_header_offset + 4 + 20 +
3264 pe_get16 (dll, pe_header_offset + 4 + 16));
3267 /* Get the rva and size of the export section. */
3268 for (i = 0; i < nsections; i++)
3271 bfd_vma secptr1 = secptr + 40 * i;
3272 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3273 bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
3274 bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
3276 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
3277 bfd_bread (sname, (bfd_size_type) 8, dll);
3279 if (vaddr <= export_rva && vaddr + vsize > export_rva)
3281 expptr = fptr + (export_rva - vaddr);
3282 if (export_rva + export_size > vaddr + vsize)
3283 export_size = vsize - (export_rva - vaddr);
3288 /* Scan sections and store the base and size of the
3289 data and bss segments in data/base_start/end. */
3290 for (i = 0; i < nsections; i++)
3292 bfd_vma secptr1 = secptr + 40 * i;
3293 bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
3294 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3295 bfd_vma flags = pe_get32 (dll, secptr1 + 36);
3299 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
3300 bfd_bread (sec_name, (bfd_size_type) 8, dll);
3302 if (strcmp(sec_name,".data") == 0)
3305 data_end = vaddr + vsize;
3307 if (pe_dll_extra_pe_debug)
3308 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3309 __FUNCTION__, sec_name, (unsigned long) vaddr,
3310 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3312 else if (strcmp(sec_name,".rdata") == 0)
3314 rdata_start = vaddr;
3315 rdata_end = vaddr + vsize;
3317 if (pe_dll_extra_pe_debug)
3318 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3319 __FUNCTION__, sec_name, (unsigned long) vaddr,
3320 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3322 else if (strcmp (sec_name,".bss") == 0)
3325 bss_end = vaddr + vsize;
3327 if (pe_dll_extra_pe_debug)
3328 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3329 __FUNCTION__, sec_name, (unsigned long) vaddr,
3330 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3334 expdata = xmalloc (export_size);
3335 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
3336 bfd_bread (expdata, (bfd_size_type) export_size, dll);
3337 erva = (char *) expdata - export_rva;
3339 if (pe_def_file == 0)
3340 pe_def_file = def_file_empty ();
3342 nexp = pe_as32 (expdata + 24);
3343 name_rvas = pe_as32 (expdata + 32);
3344 exp_funcbase = pe_as32 (expdata + 28);
3346 /* Use internal dll name instead of filename
3347 to enable symbolic dll linking. */
3348 dllname = erva + pe_as32 (expdata + 12);
3350 /* Check to see if the dll has already been added to
3351 the definition list and if so return without error.
3352 This avoids multiple symbol definitions. */
3353 if (def_get_module (pe_def_file, dllname))
3355 if (pe_dll_extra_pe_debug)
3356 printf ("%s is already loaded\n", dllname);
3360 /* Iterate through the list of symbols. */
3361 for (i = 0; i < nexp; i++)
3363 /* Pointer to the names vector. */
3364 bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3365 def_file_import *imp;
3366 /* Pointer to the function address vector. */
3367 bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3370 /* Skip unwanted symbols, which are
3371 exported in buggy auto-import releases. */
3372 if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
3375 /* is_data is true if the address is in the data, rdata or bss
3378 (func_rva >= data_start && func_rva < data_end)
3379 || (func_rva >= rdata_start && func_rva < rdata_end)
3380 || (func_rva >= bss_start && func_rva < bss_end);
3382 imp = def_file_add_import (pe_def_file, erva + name_rva,
3383 dllname, i, NULL, NULL, &is_dup);
3384 /* Mark symbol type. */
3386 imp->data = is_data;
3388 if (pe_dll_extra_pe_debug)
3389 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3390 __FUNCTION__, dllname, erva + name_rva,
3391 (unsigned long) func_rva, is_data ? "(data)" : "");
3399 pe_output_file_set_long_section_names (bfd *abfd)
3401 if (pe_use_coff_long_section_names < 0)
3403 if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
3404 einfo (_("%XError: can't use long section names on this arch\n"));
3407 /* These are the main functions, called from the emulation. The first
3408 is called after the bfds are read, so we can guess at how much space
3409 we need. The second is called after everything is placed, so we
3410 can put the right values in place. */
3413 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
3415 pe_dll_id_target (bfd_get_target (abfd));
3416 pe_output_file_set_long_section_names (abfd);
3417 process_def_file_and_drectve (abfd, info);
3419 if (pe_def_file->num_exports == 0 && !bfd_link_pic (info))
3422 generate_edata (abfd, info);
3423 build_filler_bfd (1);
3424 pe_output_file_set_long_section_names (filler_bfd);
3428 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3430 pe_dll_id_target (bfd_get_target (abfd));
3431 pe_output_file_set_long_section_names (abfd);
3432 build_filler_bfd (0);
3433 pe_output_file_set_long_section_names (filler_bfd);
3437 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
3439 pe_dll_id_target (bfd_get_target (abfd));
3440 pe_output_file_set_long_section_names (abfd);
3441 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3443 generate_reloc (abfd, info);
3446 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3448 /* Resize the sections. */
3449 lang_reset_memory_regions ();
3450 lang_size_sections (NULL, TRUE);
3452 /* Redo special stuff. */
3453 ldemul_after_allocation ();
3455 /* Do the assignments again. */
3456 lang_do_assignments (lang_final_phase_enum);
3459 fill_edata (abfd, info);
3461 if (bfd_link_dll (info))
3462 pe_data (abfd)->dll = 1;
3464 edata_s->contents = edata_d;
3465 reloc_s->contents = reloc_d;
3469 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
3471 pe_dll_id_target (bfd_get_target (abfd));
3472 pe_output_file_set_long_section_names (abfd);
3473 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3475 generate_reloc (abfd, info);
3478 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3480 /* Resize the sections. */
3481 lang_reset_memory_regions ();
3482 lang_size_sections (NULL, TRUE);
3484 /* Redo special stuff. */
3485 ldemul_after_allocation ();
3487 /* Do the assignments again. */
3488 lang_do_assignments (lang_final_phase_enum);
3490 reloc_s->contents = reloc_d;
3494 pe_bfd_is_dll (bfd *abfd)
3496 return (bfd_get_format (abfd) == bfd_object
3498 && pe_data (abfd)->dll);