1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2018 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 through 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
280 autofilter_symbollist_i386
286 16 /* R_SH_IMAGEBASE */,
290 autofilter_symbollist_generic
299 autofilter_symbollist_generic
308 autofilter_symbollist_generic
311 "epoc-pei-arm-little",
312 "epoc-pe-arm-little",
317 autofilter_symbollist_generic
320 "pei-arm-wince-little",
321 "pe-arm-wince-little",
322 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
326 autofilter_symbollist_generic
328 { NULL, NULL, 0, 0, 0, FALSE, NULL }
331 static const pe_details_type *pe_details;
333 /* Do not specify library suffix explicitly, to allow for dllized versions. */
334 static const autofilter_entry_type autofilter_liblist[] =
336 { STRING_COMMA_LEN ("libcegcc") },
337 { STRING_COMMA_LEN ("libcygwin") },
338 { STRING_COMMA_LEN ("libgcc") },
339 { STRING_COMMA_LEN ("libgcc_s") },
340 { STRING_COMMA_LEN ("libstdc++") },
341 { STRING_COMMA_LEN ("libmingw32") },
342 { STRING_COMMA_LEN ("libmingwex") },
343 { STRING_COMMA_LEN ("libg2c") },
344 { STRING_COMMA_LEN ("libsupc++") },
345 { STRING_COMMA_LEN ("libobjc") },
346 { STRING_COMMA_LEN ("libgcj") },
347 { STRING_COMMA_LEN ("libmsvcrt") },
348 { STRING_COMMA_LEN ("libmsvcrt-os") },
349 { STRING_COMMA_LEN ("libucrtbase") },
353 /* Regardless of the suffix issue mentioned above, we must ensure that
354 we do not falsely match on a leading substring, such as when libtool
355 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
356 This routine ensures that the leading part of the name matches and that
357 it is followed by only an optional version suffix and a file extension,
358 returning zero if so or -1 if not. */
359 static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
361 if (filename_ncmp (libname, afptr->name, afptr->len))
364 libname += afptr->len;
366 /* Be liberal in interpreting what counts as a version suffix; we
367 accept anything that has a dash to separate it from the name and
368 begins with a digit. */
369 if (libname[0] == '-')
371 if (!ISDIGIT (*++libname))
373 /* Ensure the filename has an extension. */
374 while (*++libname != '.')
378 else if (libname[0] != '.')
384 static const autofilter_entry_type autofilter_objlist[] =
386 { STRING_COMMA_LEN ("crt0.o") },
387 { STRING_COMMA_LEN ("crt1.o") },
388 { STRING_COMMA_LEN ("crt2.o") },
389 { STRING_COMMA_LEN ("dllcrt1.o") },
390 { STRING_COMMA_LEN ("dllcrt2.o") },
391 { STRING_COMMA_LEN ("gcrt0.o") },
392 { STRING_COMMA_LEN ("gcrt1.o") },
393 { STRING_COMMA_LEN ("gcrt2.o") },
394 { STRING_COMMA_LEN ("crtbegin.o") },
395 { STRING_COMMA_LEN ("crtend.o") },
399 static const autofilter_entry_type autofilter_symbolprefixlist[] =
401 /* _imp_ is treated specially, as it is always underscored. */
402 /* { STRING_COMMA_LEN ("_imp_") }, */
403 /* Don't export some c++ symbols. */
404 { STRING_COMMA_LEN ("__rtti_") },
405 { STRING_COMMA_LEN ("__builtin_") },
406 /* Don't re-export auto-imported symbols. */
407 { STRING_COMMA_LEN ("__nm_") },
408 /* Don't export symbols specifying internal DLL layout. */
409 { STRING_COMMA_LEN ("_head_") },
410 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
411 /* Don't export section labels or artificial symbols
413 { STRING_COMMA_LEN (".") },
417 static const autofilter_entry_type autofilter_symbolsuffixlist[] =
419 { STRING_COMMA_LEN ("_iname") },
420 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
424 #define U(str) (pe_details->underscored ? "_" str : str)
427 pe_dll_id_target (const char *target)
431 for (i = 0; pe_detail_list[i].target_name; i++)
432 if (strcmp (pe_detail_list[i].target_name, target) == 0
433 || strcmp (pe_detail_list[i].object_target, target) == 0)
435 int u = pe_leading_underscore; /* Underscoring mode. -1 for use default. */
437 bfd_get_target_info (target, NULL, NULL, &u, NULL);
440 pe_detail_list[i].underscored = (u != 0 ? TRUE : FALSE);
441 pe_details = pe_detail_list + i;
442 pe_leading_underscore = (u != 0 ? 1 : 0);
445 einfo (_("%P%X: Unsupported PEI architecture: %s\n"), target);
449 /* Helper functions for qsort. Relocs must be sorted so that we can write
450 them out by pages. */
461 reloc_sort (const void *va, const void *vb)
463 bfd_vma a = ((const reloc_data_type *) va)->vma;
464 bfd_vma b = ((const reloc_data_type *) vb)->vma;
466 return (a > b) ? 1 : ((a < b) ? -1 : 0);
470 pe_export_sort (const void *va, const void *vb)
472 const def_file_export *a = va;
473 const def_file_export *b = vb;
481 return strcmp (an, bn);
484 /* Read and process the .DEF file. */
486 /* These correspond to the entries in pe_def_file->exports[]. I use
487 exported_symbol_sections[i] to tag whether or not the symbol was
488 defined, since we can't export symbols we don't have. */
490 static bfd_vma *exported_symbol_offsets;
491 static struct bfd_section **exported_symbol_sections;
492 static int export_table_size;
493 static int count_exported;
494 static int count_exported_byname;
495 static int count_with_ordinals;
496 static const char *dll_name;
497 static int min_ordinal, max_ordinal;
498 static int *exported_symbols;
500 typedef struct exclude_list_struct
503 struct exclude_list_struct *next;
508 static struct exclude_list_struct *excludes = 0;
511 pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
514 char *exclude_string;
516 local_copy = xstrdup (new_excludes);
518 exclude_string = strtok (local_copy, ",:");
519 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
521 struct exclude_list_struct *new_exclude;
523 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
524 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
525 strcpy (new_exclude->string, exclude_string);
526 new_exclude->type = type;
527 new_exclude->next = excludes;
528 excludes = new_exclude;
535 is_import (const char* n)
537 return (CONST_STRNEQ (n, "__imp_"));
540 /* abfd is a bfd containing n (or NULL)
541 It can be used for contextual checks. */
544 auto_export (bfd *abfd, def_file *d, const char *n)
547 struct exclude_list_struct *ex;
548 const autofilter_entry_type *afptr;
549 const char * libname = NULL;
551 if (abfd && abfd->my_archive)
552 libname = lbasename (abfd->my_archive->filename);
554 key.name = key.its_name = (char *) n;
556 /* Return false if n is in the d->exports table. */
557 if (bsearch (&key, d->exports, d->num_exports,
558 sizeof (pe_def_file->exports[0]), pe_export_sort))
561 if (pe_dll_do_default_excludes)
566 if (pe_dll_extra_pe_debug)
567 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
568 n, abfd, abfd->my_archive);
570 /* First of all, make context checks:
571 Don't export anything from standard libs. */
574 afptr = autofilter_liblist;
578 if (libnamencmp (libname, afptr) == 0 )
584 /* Next, exclude symbols from certain startup objects. */
586 if (abfd && (p = lbasename (abfd->filename)))
588 afptr = autofilter_objlist;
591 if (strcmp (p, afptr->name) == 0)
597 /* Don't try to blindly exclude all symbols
598 that begin with '__'; this was tried and
599 it is too restrictive. Instead we have
600 a target specific list to use: */
601 afptr = pe_details->autofilter_symbollist;
605 if (strcmp (n, afptr->name) == 0)
611 /* Next, exclude symbols starting with ... */
612 afptr = autofilter_symbolprefixlist;
615 if (strncmp (n, afptr->name, afptr->len) == 0)
621 /* Finally, exclude symbols ending with ... */
623 afptr = autofilter_symbolsuffixlist;
626 if ((len >= afptr->len)
627 /* Add 1 to insure match with trailing '\0'. */
628 && strncmp (n + len - afptr->len, afptr->name,
629 afptr->len + 1) == 0)
636 for (ex = excludes; ex; ex = ex->next)
638 if (ex->type == EXCLUDELIBS)
641 && ((filename_cmp (libname, ex->string) == 0)
642 || (strcasecmp ("ALL", ex->string) == 0)))
645 else if (ex->type == EXCLUDEFORIMPLIB)
647 if (filename_cmp (abfd->filename, ex->string) == 0)
650 else if (strcmp (n, ex->string) == 0)
658 process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
661 struct bfd_link_hash_entry *blhe;
663 struct bfd_section *s;
664 def_file_export *e = 0;
665 bfd_boolean resort_needed;
668 pe_def_file = def_file_empty ();
670 /* First, run around to all the objects looking for the .drectve
671 sections, and push those into the def file too. */
672 for (b = info->input_bfds; b; b = b->link.next)
674 s = bfd_get_section_by_name (b, ".drectve");
678 char *buf = xmalloc (size);
680 bfd_get_section_contents (b, s, buf, 0, size);
681 def_file_add_directive (pe_def_file, buf, size);
686 /* Process aligned common symbol information from the
687 .drectve sections now; common symbol allocation is
688 done before final link, so it will be too late to
689 process them in process_embedded_commands() called
690 from _bfd_coff_link_input_bfd(). */
691 if (pe_def_file->aligncomms)
693 def_file_aligncomm *ac = pe_def_file->aligncomms;
696 struct coff_link_hash_entry *sym_hash;
697 sym_hash = coff_link_hash_lookup (coff_hash_table (info),
698 ac->symbol_name, FALSE, FALSE, FALSE);
699 if (sym_hash && sym_hash->root.type == bfd_link_hash_common
700 && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
702 sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
708 /* If we are building an executable and there is nothing
709 to export, we do not build an export table at all. */
710 if (bfd_link_executable (info) && pe_def_file->num_exports == 0
711 && (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
714 /* Now, maybe export everything else the default way. */
715 if ((pe_dll_export_everything || pe_def_file->num_exports == 0)
716 && !pe_dll_exclude_all_symbols)
718 for (b = info->input_bfds; b; b = b->link.next)
723 if (!bfd_generic_link_read_symbols (b))
725 einfo (_("%B%F: could not read symbols: %E\n"), b);
729 symbols = bfd_get_outsymbols (b);
730 nsyms = bfd_get_symcount (b);
732 for (j = 0; j < nsyms; j++)
734 /* We should export symbols which are either global or not
735 anything at all. (.bss data is the latter)
736 We should not export undefined symbols. */
737 bfd_boolean would_export
738 = (symbols[j]->section != bfd_und_section_ptr
739 && ((symbols[j]->flags & BSF_GLOBAL)
740 || (symbols[j]->flags == 0)));
741 if (link_info.version_info && would_export)
743 = !bfd_hide_sym_by_version (link_info.version_info,
747 const char *sn = symbols[j]->name;
749 /* We should not re-export imported stuff. */
755 name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
756 sprintf (name, "%s%s", "__imp_", sn);
758 blhe = bfd_link_hash_lookup (info->hash, name,
759 FALSE, FALSE, FALSE);
762 if (blhe && blhe->type == bfd_link_hash_defined)
766 if (pe_details->underscored && *sn == '_')
769 if (auto_export (b, pe_def_file, sn))
774 p = def_file_add_export (pe_def_file, sn, 0, -1,
776 /* Fill data flag properly, from dlltool.c. */
778 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
786 #define NE pe_def_file->num_exports
788 /* Don't create an empty export table. */
792 resort_needed = FALSE;
794 /* Canonicalize the export list. */
797 for (i = 0; i < NE; i++)
799 /* Check for fastcall/stdcall-decoration, but ignore
800 C++ mangled names. */
801 if (pe_def_file->exports[i].name[0] != '?'
802 && strchr (pe_def_file->exports[i].name, '@'))
804 /* This will preserve internal_name, which may have been
805 pointing to the same memory as name, or might not
807 int lead_at = (*pe_def_file->exports[i].name == '@');
808 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
809 char *tmp_at = strrchr (tmp, '@');
814 einfo (_("%P%X: Cannot export %s: invalid export name\n"),
815 pe_def_file->exports[i].name);
816 pe_def_file->exports[i].name = tmp;
817 resort_needed = TRUE;
822 /* Re-sort the exports table as we have possibly changed the order
823 by removing leading @. */
825 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
828 if (pe_dll_stdcall_aliases)
830 for (i = 0; i < NE; i++)
832 if (is_import (pe_def_file->exports[i].name))
835 if (strchr (pe_def_file->exports[i].name, '@'))
838 int lead_at = (*pe_def_file->exports[i].name == '@');
839 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
841 *(strchr (tmp, '@')) = 0;
842 if (auto_export (NULL, pe_def_file, tmp))
843 def_file_add_export (pe_def_file, tmp,
844 pe_def_file->exports[i].internal_name,
852 /* Convenience, but watch out for it changing. */
853 e = pe_def_file->exports;
855 for (i = 0, j = 0; i < NE; i++)
857 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
859 /* This is a duplicate. */
860 if (e[j - 1].ordinal != -1
861 && e[i].ordinal != -1
862 && e[j - 1].ordinal != e[i].ordinal)
864 if (pe_dll_warn_dup_exports)
865 /* xgettext:c-format */
866 einfo (_("%P%X: Error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
867 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
871 if (pe_dll_warn_dup_exports)
872 /* xgettext:c-format */
873 einfo (_("%P: Warning, duplicate EXPORT: %s\n"),
877 if (e[i].ordinal != -1)
878 e[j - 1].ordinal = e[i].ordinal;
879 e[j - 1].flag_private |= e[i].flag_private;
880 e[j - 1].flag_constant |= e[i].flag_constant;
881 e[j - 1].flag_noname |= e[i].flag_noname;
882 e[j - 1].flag_data |= e[i].flag_data;
885 if (e[i].internal_name)
886 free (e[i].internal_name);
888 free (e[i].its_name);
897 pe_def_file->num_exports = j; /* == NE */
899 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
900 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
902 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
906 count_exported_byname = 0;
907 count_with_ordinals = 0;
909 for (i = 0; i < NE; i++)
911 char *int_name = pe_def_file->exports[i].internal_name;
914 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
915 lang_add_gc_name (int_name);
917 name = xmalloc (strlen (int_name) + 2);
918 if (pe_details->underscored && int_name[0] != '@')
921 strcpy (name + 1, int_name);
923 /* PR 19803: The alias must be preserved as well. */
924 lang_add_gc_name (xstrdup (name));
927 strcpy (name, int_name);
929 blhe = bfd_link_hash_lookup (info->hash,
934 && (blhe->type == bfd_link_hash_defined
935 || (blhe->type == bfd_link_hash_common)))
938 if (!pe_def_file->exports[i].flag_noname)
939 count_exported_byname++;
941 /* Only fill in the sections. The actual offsets are computed
942 in fill_exported_offsets() after common symbols are laid
944 if (blhe->type == bfd_link_hash_defined)
945 exported_symbol_sections[i] = blhe->u.def.section;
947 exported_symbol_sections[i] = blhe->u.c.p->section;
949 if (pe_def_file->exports[i].ordinal != -1)
951 if (max_ordinal < pe_def_file->exports[i].ordinal)
952 max_ordinal = pe_def_file->exports[i].ordinal;
953 if (min_ordinal > pe_def_file->exports[i].ordinal)
954 min_ordinal = pe_def_file->exports[i].ordinal;
955 count_with_ordinals++;
958 /* Check for forward exports. These are indicated in DEF files by an
959 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
960 but we must take care not to be fooled when the user wants to export
961 a symbol that actually really has a dot in it, so we only check
962 for them here, after real defined symbols have already been matched. */
963 else if (strchr (int_name, '.'))
966 if (!pe_def_file->exports[i].flag_noname)
967 count_exported_byname++;
969 pe_def_file->exports[i].flag_forward = 1;
971 if (pe_def_file->exports[i].ordinal != -1)
973 if (max_ordinal < pe_def_file->exports[i].ordinal)
974 max_ordinal = pe_def_file->exports[i].ordinal;
975 if (min_ordinal > pe_def_file->exports[i].ordinal)
976 min_ordinal = pe_def_file->exports[i].ordinal;
977 count_with_ordinals++;
980 else if (blhe && blhe->type == bfd_link_hash_undefined)
982 /* xgettext:c-format */
983 einfo (_("%P%X: Cannot export %s: symbol not defined\n"),
988 /* xgettext:c-format */
989 einfo (_("%P%X: Cannot export %s: symbol wrong type (%d vs %d)\n"),
991 blhe->type, bfd_link_hash_defined);
995 /* xgettext:c-format */
996 einfo (_("%P%X: Cannot export %s: symbol not found\n"),
1003 /* Build the bfd that will contain .edata and .reloc sections. */
1006 build_filler_bfd (int include_edata)
1008 lang_input_statement_type *filler_file;
1009 filler_file = lang_add_input_file ("dll stuff",
1010 lang_input_file_is_fake_enum,
1012 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff",
1013 link_info.output_bfd);
1014 if (filler_bfd == NULL
1015 || !bfd_set_arch_mach (filler_bfd,
1016 bfd_get_arch (link_info.output_bfd),
1017 bfd_get_mach (link_info.output_bfd)))
1019 einfo (_("%X%P: can not create BFD: %E\n"));
1025 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
1027 || !bfd_set_section_flags (filler_bfd, edata_s,
1034 einfo (_("%X%P: can not create .edata section: %E\n"));
1037 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
1040 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
1042 || !bfd_set_section_flags (filler_bfd, reloc_s,
1049 einfo (_("%X%P: can not create .reloc section: %E\n"));
1053 bfd_set_section_size (filler_bfd, reloc_s, 0);
1055 ldlang_add_file (filler_file);
1058 /* Gather all the exported symbols and build the .edata section. */
1061 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1063 int i, next_ordinal;
1064 int name_table_size = 0;
1067 /* First, we need to know how many exported symbols there are,
1068 and what the range of ordinals is. */
1069 if (pe_def_file->name)
1070 dll_name = pe_def_file->name;
1073 dll_name = abfd->filename;
1075 for (dlnp = dll_name; *dlnp; dlnp++)
1076 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
1077 dll_name = dlnp + 1;
1080 if (count_with_ordinals && max_ordinal > count_exported)
1082 if (min_ordinal > max_ordinal - count_exported + 1)
1083 min_ordinal = max_ordinal - count_exported + 1;
1088 max_ordinal = count_exported;
1091 export_table_size = max_ordinal - min_ordinal + 1;
1092 exported_symbols = xmalloc (export_table_size * sizeof (int));
1093 for (i = 0; i < export_table_size; i++)
1094 exported_symbols[i] = -1;
1096 /* Now we need to assign ordinals to those that don't have them. */
1097 for (i = 0; i < NE; i++)
1099 if (exported_symbol_sections[i]
1100 || pe_def_file->exports[i].flag_forward)
1102 if (pe_def_file->exports[i].ordinal != -1)
1104 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
1105 int pi = exported_symbols[ei];
1109 /* xgettext:c-format */
1110 einfo (_("%P%X: Error: ordinal used twice: %d (%s vs %s)\n"),
1111 pe_def_file->exports[i].ordinal,
1112 pe_def_file->exports[i].name,
1113 pe_def_file->exports[pi].name);
1115 exported_symbols[ei] = i;
1117 if (pe_def_file->exports[i].its_name)
1118 name_table_size += strlen (pe_def_file->exports[i].its_name) + 1;
1120 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
1123 /* Reserve space for the forward name. */
1124 if (pe_def_file->exports[i].flag_forward)
1126 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
1130 next_ordinal = min_ordinal;
1131 for (i = 0; i < NE; i++)
1132 if ((exported_symbol_sections[i]
1133 || pe_def_file->exports[i].flag_forward)
1134 && pe_def_file->exports[i].ordinal == -1)
1136 while (exported_symbols[next_ordinal - min_ordinal] != -1)
1139 exported_symbols[next_ordinal - min_ordinal] = i;
1140 pe_def_file->exports[i].ordinal = next_ordinal;
1143 /* PR 12969: Check for more than 1^16 ordinals. */
1144 if (max_ordinal > 65535 || next_ordinal > 65535)
1145 /* xgettext:c-format */
1146 einfo(_("%P%X: Error: export ordinal too large: %d\n"),
1147 max_ordinal > next_ordinal ? max_ordinal : next_ordinal);
1149 /* OK, now we can allocate some memory. */
1150 edata_sz = (40 /* directory */
1151 + 4 * export_table_size /* addresses */
1152 + 4 * count_exported_byname /* name ptrs */
1153 + 2 * count_exported_byname /* ordinals */
1154 + name_table_size + strlen (dll_name) + 1);
1157 /* Fill the exported symbol offsets. The preliminary work has already
1158 been done in process_def_file_and_drectve(). */
1161 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
1164 struct bfd_link_hash_entry *blhe;
1166 for (i = 0; i < pe_def_file->num_exports; i++)
1170 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
1171 if (pe_details->underscored
1172 && *pe_def_file->exports[i].internal_name != '@')
1175 strcpy (name + 1, pe_def_file->exports[i].internal_name);
1178 strcpy (name, pe_def_file->exports[i].internal_name);
1180 blhe = bfd_link_hash_lookup (info->hash,
1182 FALSE, FALSE, TRUE);
1184 if (blhe && blhe->type == bfd_link_hash_defined)
1185 exported_symbol_offsets[i] = blhe->u.def.value;
1192 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1195 unsigned char *edirectory;
1196 unsigned char *eaddresses;
1197 unsigned char *enameptrs;
1198 unsigned char *eordinals;
1201 edata_d = xmalloc (edata_sz);
1203 /* Note use of array pointer math here. */
1204 edirectory = edata_d;
1205 eaddresses = edirectory + 40;
1206 enameptrs = eaddresses + 4 * export_table_size;
1207 eordinals = enameptrs + 4 * count_exported_byname;
1208 enamestr = (char *) eordinals + 2 * count_exported_byname;
1210 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1211 + edata_s->output_section->vma - image_base)
1213 memset (edata_d, 0, edata_sz);
1215 if (pe_data (abfd)->insert_timestamp)
1216 H_PUT_32 (abfd, time (0), edata_d + 4);
1218 if (pe_def_file->version_major != -1)
1220 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1221 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1224 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1225 strcpy (enamestr, dll_name);
1226 enamestr += strlen (enamestr) + 1;
1227 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1228 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1229 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1230 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1231 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1232 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1234 fill_exported_offsets (abfd, info);
1236 /* Ok, now for the filling in part.
1237 Scan alphabetically - ie the ordering in the exports[] table,
1238 rather than by ordinal - the ordering in the exported_symbol[]
1239 table. See dlltool.c and:
1240 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1241 for more information. */
1243 for (s = 0; s < NE; s++)
1245 struct bfd_section *ssec = exported_symbol_sections[s];
1246 if (pe_def_file->exports[s].ordinal != -1
1247 && (pe_def_file->exports[s].flag_forward || ssec != NULL))
1249 int ord = pe_def_file->exports[s].ordinal;
1251 if (pe_def_file->exports[s].flag_forward)
1253 bfd_put_32 (abfd, ERVA (enamestr),
1254 eaddresses + 4 * (ord - min_ordinal));
1256 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1257 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1261 bfd_vma srva = (exported_symbol_offsets[s]
1262 + ssec->output_section->vma
1263 + ssec->output_offset);
1265 bfd_put_32 (abfd, srva - image_base,
1266 eaddresses + 4 * (ord - min_ordinal));
1269 if (!pe_def_file->exports[s].flag_noname)
1271 char *ename = pe_def_file->exports[s].name;
1272 if (pe_def_file->exports[s].its_name)
1273 ename = pe_def_file->exports[s].its_name;
1275 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1277 strcpy (enamestr, ename);
1278 enamestr += strlen (enamestr) + 1;
1279 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1281 pe_def_file->exports[s].hint = hint++;
1288 static struct bfd_section *current_sec;
1291 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1293 int (*cb) (arelent *, asection *, char *))
1298 for (b = info->input_bfds; b; b = b->link.next)
1302 if (!bfd_generic_link_read_symbols (b))
1304 einfo (_("%B%F: could not read symbols: %E\n"), b);
1308 symbols = bfd_get_outsymbols (b);
1310 for (s = b->sections; s; s = s->next)
1313 int relsize, nrelocs, i;
1314 int flags = bfd_get_section_flags (b, s);
1316 /* Skip discarded linkonce sections. */
1317 if (flags & SEC_LINK_ONCE
1318 && s->output_section == bfd_abs_section_ptr)
1323 relsize = bfd_get_reloc_upper_bound (b, s);
1324 relocs = xmalloc (relsize);
1325 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1327 for (i = 0; i < nrelocs; i++)
1329 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1331 if (!strcmp (name, sym->name))
1332 cb (relocs[i], s, name);
1337 /* Warning: the allocated symbols are remembered in BFD and reused
1338 later, so don't free them! */
1339 /* free (symbols); */
1344 /* Gather all the relocations and build the .reloc section. */
1347 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1350 /* For .reloc stuff. */
1351 reloc_data_type *reloc_data;
1352 int total_relocs = 0;
1354 bfd_vma sec_page = (bfd_vma) -1;
1355 bfd_vma page_ptr, page_count;
1358 struct bfd_section *s;
1361 for (b = info->input_bfds; b; b = b->link.next)
1362 for (s = b->sections; s; s = s->next)
1363 total_relocs += s->reloc_count;
1365 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1369 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link.next)
1372 int relsize, nrelocs;
1374 for (s = b->sections; s; s = s->next)
1376 bfd_vma sec_vma = s->output_section->vma + s->output_offset;
1379 /* If it's not loaded, we don't need to relocate it this way. */
1380 if (!(s->output_section->flags & SEC_LOAD))
1383 /* I don't know why there would be a reloc for these, but I've
1384 seen it happen - DJ */
1385 if (s->output_section == bfd_abs_section_ptr)
1388 if (s->output_section->vma == 0)
1390 /* Huh? Shouldn't happen, but punt if it does. */
1391 einfo (_("zero vma section reloc detected: `%s' #%d f=%d\n"),
1392 s->output_section->name, s->output_section->index,
1393 s->output_section->flags);
1397 if (!bfd_generic_link_read_symbols (b))
1399 einfo (_("%B%F: could not read symbols: %E\n"), b);
1403 symbols = bfd_get_outsymbols (b);
1404 relsize = bfd_get_reloc_upper_bound (b, s);
1405 relocs = xmalloc (relsize);
1406 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1408 for (i = 0; i < nrelocs; i++)
1410 if (pe_dll_extra_pe_debug)
1412 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1413 printf ("rel: %s\n", sym->name);
1415 if (!relocs[i]->howto->pc_relative
1416 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1418 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1420 /* Don't create relocs for undefined weak symbols. */
1421 if (sym->flags == BSF_WEAK)
1423 struct bfd_link_hash_entry *blhe
1424 = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
1425 FALSE, FALSE, FALSE);
1426 if (blhe && blhe->type == bfd_link_hash_undefweak)
1428 /* Check aux sym and see if it is defined or not. */
1429 struct coff_link_hash_entry *h, *h2;
1430 h = (struct coff_link_hash_entry *)blhe;
1431 if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
1433 h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
1434 [h->aux->x_sym.x_tagndx.l];
1435 /* We don't want a base reloc if the aux sym is not
1436 found, undefined, or if it is the constant ABS
1437 zero default value. (We broaden that slightly by
1438 not testing the value, just the section; there's
1439 no reason we'd want a reference to any absolute
1440 address to get relocated during rebasing). */
1441 if (!h2 || h2->root.type == bfd_link_hash_undefined
1442 || h2->root.u.def.section == bfd_abs_section_ptr)
1445 else if (!blhe || blhe->type != bfd_link_hash_defined)
1448 /* Nor for Dwarf FDE references to discarded sections. */
1449 else if (bfd_is_abs_section (sym->section->output_section))
1451 /* We only ignore relocs from .eh_frame sections, as
1452 they are discarded by the final link rather than
1453 resolved against the kept section. */
1454 if (!strcmp (s->name, ".eh_frame"))
1458 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1460 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1462 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1463 relocs[i]->howto->rightshift)
1465 #ifdef pe_use_x86_64
1466 case BITS_AND_SHIFT (64, 0):
1467 reloc_data[total_relocs].type = 10;
1471 case BITS_AND_SHIFT (32, 0):
1472 reloc_data[total_relocs].type = 3;
1475 case BITS_AND_SHIFT (16, 0):
1476 reloc_data[total_relocs].type = 2;
1479 case BITS_AND_SHIFT (16, 16):
1480 reloc_data[total_relocs].type = 4;
1481 /* FIXME: we can't know the symbol's right value
1482 yet, but we probably can safely assume that
1483 CE will relocate us in 64k blocks, so leaving
1485 reloc_data[total_relocs].extra = 0;
1488 case BITS_AND_SHIFT (26, 2):
1489 reloc_data[total_relocs].type = 5;
1492 case BITS_AND_SHIFT (24, 2):
1493 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1494 Those ARM_xxx definitions should go in proper
1496 if (relocs[i]->howto->type == 0
1497 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1498 || relocs[i]->howto->type == 5)
1499 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1500 that has already been fully processed during a
1501 previous link stage, so ignore it here. */
1505 /* xgettext:c-format */
1506 einfo (_("%P%X: Error: %d-bit reloc in dll\n"),
1507 relocs[i]->howto->bitsize);
1513 /* Warning: the allocated symbols are remembered in BFD and
1514 reused later, so don't free them! */
1518 /* At this point, we have total_relocs relocation addresses in
1519 reloc_addresses, which are all suitable for the .reloc section.
1520 We must now create the new sections. */
1521 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1523 for (i = 0; i < total_relocs; i++)
1525 bfd_vma this_page = (reloc_data[i].vma >> 12);
1527 if (this_page != sec_page)
1529 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1531 sec_page = this_page;
1536 if (reloc_data[i].type == 4)
1540 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1541 reloc_d = xmalloc (reloc_sz);
1542 sec_page = (bfd_vma) -1;
1544 page_ptr = (bfd_vma) -1;
1547 for (i = 0; i < total_relocs; i++)
1549 bfd_vma rva = reloc_data[i].vma - image_base;
1550 bfd_vma this_page = (rva & ~0xfff);
1552 if (this_page != sec_page)
1554 while (reloc_sz & 3)
1555 reloc_d[reloc_sz++] = 0;
1557 if (page_ptr != (bfd_vma) -1)
1558 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1560 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1561 page_ptr = reloc_sz;
1563 sec_page = this_page;
1567 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1568 reloc_d + reloc_sz);
1571 if (reloc_data[i].type == 4)
1573 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1580 while (reloc_sz & 3)
1581 reloc_d[reloc_sz++] = 0;
1583 if (page_ptr != (bfd_vma) -1)
1584 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1586 while (reloc_sz < reloc_s->size)
1587 reloc_d[reloc_sz++] = 0;
1590 /* Given the exiting def_file structure, print out a .DEF file that
1591 corresponds to it. */
1594 quoteput (char *s, FILE *f, int needs_quotes)
1598 for (cp = s; *cp; cp++)
1613 if (*s == '"' || *s == '\\')
1627 pe_dll_generate_def_file (const char *pe_out_def_filename)
1630 FILE *out = fopen (pe_out_def_filename, "w");
1633 /* xgettext:c-format */
1634 einfo (_("%P: Can't open output def file %s\n"),
1635 pe_out_def_filename);
1639 if (pe_def_file->name)
1641 if (pe_def_file->is_dll)
1642 fprintf (out, "LIBRARY ");
1644 fprintf (out, "NAME ");
1646 quoteput (pe_def_file->name, out, 1);
1648 if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
1650 fprintf (out, " BASE=0x");
1651 fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
1653 fprintf (out, "\n");
1656 if (pe_def_file->description)
1658 fprintf (out, "DESCRIPTION ");
1659 quoteput (pe_def_file->description, out, 1);
1660 fprintf (out, "\n");
1663 if (pe_def_file->version_minor != -1)
1664 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1665 pe_def_file->version_minor);
1666 else if (pe_def_file->version_major != -1)
1667 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1669 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1670 fprintf (out, "\n");
1672 if (pe_def_file->stack_commit != -1)
1673 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1674 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1675 else if (pe_def_file->stack_reserve != -1)
1676 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1678 if (pe_def_file->heap_commit != -1)
1679 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1680 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1681 else if (pe_def_file->heap_reserve != -1)
1682 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1684 if (pe_def_file->num_section_defs > 0)
1686 fprintf (out, "\nSECTIONS\n\n");
1688 for (i = 0; i < pe_def_file->num_section_defs; i++)
1691 quoteput (pe_def_file->section_defs[i].name, out, 0);
1693 if (pe_def_file->section_defs[i].class)
1695 fprintf (out, " CLASS ");
1696 quoteput (pe_def_file->section_defs[i].class, out, 0);
1699 if (pe_def_file->section_defs[i].flag_read)
1700 fprintf (out, " READ");
1702 if (pe_def_file->section_defs[i].flag_write)
1703 fprintf (out, " WRITE");
1705 if (pe_def_file->section_defs[i].flag_execute)
1706 fprintf (out, " EXECUTE");
1708 if (pe_def_file->section_defs[i].flag_shared)
1709 fprintf (out, " SHARED");
1711 fprintf (out, "\n");
1715 if (pe_def_file->num_exports > 0)
1717 fprintf (out, "EXPORTS\n");
1719 for (i = 0; i < pe_def_file->num_exports; i++)
1721 def_file_export *e = pe_def_file->exports + i;
1723 quoteput (e->name, out, 0);
1725 if (e->internal_name && strcmp (e->internal_name, e->name))
1727 fprintf (out, " = ");
1728 quoteput (e->internal_name, out, 0);
1731 if (e->ordinal != -1)
1732 fprintf (out, " @%d", e->ordinal);
1734 if (e->flag_private)
1735 fprintf (out, " PRIVATE");
1737 if (e->flag_constant)
1738 fprintf (out, " CONSTANT");
1741 fprintf (out, " NONAME");
1744 fprintf (out, " DATA");
1746 fprintf (out, "\n");
1750 if (pe_def_file->num_imports > 0)
1752 fprintf (out, "\nIMPORTS\n\n");
1754 for (i = 0; i < pe_def_file->num_imports; i++)
1756 def_file_import *im = pe_def_file->imports + i;
1759 if (im->internal_name
1760 && (!im->name || strcmp (im->internal_name, im->name)))
1762 quoteput (im->internal_name, out, 0);
1763 fprintf (out, " = ");
1766 quoteput (im->module->name, out, 0);
1770 quoteput (im->name, out, 0);
1772 fprintf (out, "%d", im->ordinal);
1776 fprintf (out, " == ");
1777 quoteput (im->its_name, out, 0);
1780 fprintf (out, "\n");
1785 fprintf (out, _("; no contents available\n"));
1787 if (fclose (out) == EOF)
1788 /* xgettext:c-format */
1789 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1792 /* Generate the import library. */
1794 static asymbol **symtab;
1797 static int tmp_seq2;
1798 static const char *dll_filename;
1799 static char *dll_symname;
1801 #define UNDSEC bfd_und_section_ptr
1804 quick_section (bfd *abfd, const char *name, int flags, int align)
1809 sec = bfd_make_section_old_way (abfd, name);
1810 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1811 bfd_set_section_alignment (abfd, sec, align);
1812 /* Remember to undo this before trying to link internally! */
1813 sec->output_section = sec;
1815 sym = bfd_make_empty_symbol (abfd);
1816 symtab[symptr++] = sym;
1817 sym->name = sec->name;
1819 sym->flags = BSF_LOCAL;
1826 quick_symbol (bfd *abfd,
1835 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1840 sym = bfd_make_empty_symbol (abfd);
1845 symtab[symptr++] = sym;
1848 static arelent *reltab = 0;
1849 static int relcount = 0, relsize = 0;
1852 quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
1854 if (relcount >= relsize - 1)
1858 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1860 reltab = xmalloc (relsize * sizeof (arelent));
1862 reltab[relcount].address = address;
1863 reltab[relcount].addend = 0;
1864 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1865 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1870 save_relocs (asection *sec)
1874 sec->relocation = reltab;
1875 sec->reloc_count = relcount;
1876 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1877 for (i = 0; i < relcount; i++)
1878 sec->orelocation[i] = sec->relocation + i;
1879 sec->orelocation[relcount] = 0;
1880 sec->flags |= SEC_RELOC;
1882 relcount = relsize = 0;
1885 /* .section .idata$2
1886 .global __head_my_dll
1903 make_head (bfd *parent)
1905 asection *id2, *id5, *id4;
1906 unsigned char *d2, *d5, *d4;
1910 oname = xmalloc (20);
1911 sprintf (oname, "d%06d.o", tmp_seq);
1914 abfd = bfd_create (oname, parent);
1915 bfd_find_target (pe_details->object_target, abfd);
1916 bfd_make_writable (abfd);
1918 bfd_set_format (abfd, bfd_object);
1919 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1922 symtab = xmalloc (6 * sizeof (asymbol *));
1923 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1924 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1925 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1926 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1927 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1929 /* OK, pay attention here. I got confused myself looking back at
1930 it. We create a four-byte section to mark the beginning of the
1931 list, and we include an offset of 4 in the section, so that the
1932 pointer to the list points to the *end* of this section, which is
1933 the start of the list of sections from other objects. */
1935 bfd_set_section_size (abfd, id2, 20);
1939 if (pe_use_nul_prefixed_import_tables)
1940 d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
1941 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1942 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1943 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1946 if (pe_use_nul_prefixed_import_tables)
1947 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1949 bfd_set_section_size (abfd, id5, 0);
1950 d5 = xmalloc (PE_IDATA5_SIZE);
1952 memset (d5, 0, PE_IDATA5_SIZE);
1953 if (pe_use_nul_prefixed_import_tables)
1954 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1956 bfd_set_section_size (abfd, id4, 0);
1957 d4 = xmalloc (PE_IDATA4_SIZE);
1959 memset (d4, 0, PE_IDATA4_SIZE);
1961 bfd_set_symtab (abfd, symtab, symptr);
1963 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1964 if (pe_use_nul_prefixed_import_tables)
1966 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1967 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1971 bfd_set_section_contents (abfd, id5, d5, 0, 0);
1972 bfd_set_section_contents (abfd, id4, d4, 0, 0);
1975 bfd_make_readable (abfd);
1979 /* .section .idata$4
1986 .global __my_dll_iname
1991 make_tail (bfd *parent)
1993 asection *id4, *id5, *id7;
1994 unsigned char *d4, *d5, *d7;
1999 oname = xmalloc (20);
2000 sprintf (oname, "d%06d.o", tmp_seq);
2003 abfd = bfd_create (oname, parent);
2004 bfd_find_target (pe_details->object_target, abfd);
2005 bfd_make_writable (abfd);
2007 bfd_set_format (abfd, bfd_object);
2008 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2011 symtab = xmalloc (5 * sizeof (asymbol *));
2012 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2013 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2014 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2015 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
2017 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2018 d4 = xmalloc (PE_IDATA4_SIZE);
2020 memset (d4, 0, PE_IDATA4_SIZE);
2022 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2023 d5 = xmalloc (PE_IDATA5_SIZE);
2025 memset (d5, 0, PE_IDATA5_SIZE);
2027 len = strlen (dll_filename) + 1;
2030 bfd_set_section_size (abfd, id7, len);
2033 strcpy ((char *) d7, dll_filename);
2034 /* If len was odd, the above
2035 strcpy leaves behind an undefined byte. That is harmless,
2036 but we set it to 0 just so the binary dumps are pretty. */
2039 bfd_set_symtab (abfd, symtab, symptr);
2041 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2042 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2043 bfd_set_section_contents (abfd, id7, d7, 0, len);
2045 bfd_make_readable (abfd);
2051 .global ___imp_function
2052 .global __imp__function
2054 jmp *__imp__function:
2068 .asciz "function" xlate? (add underscore, kill at) */
2070 static const unsigned char jmp_ix86_bytes[] =
2072 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2080 .dw __imp_function */
2082 static const unsigned char jmp_sh_bytes[] =
2084 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2088 lui $t0,<high:__imp_function>
2089 lw $t0,<low:__imp_function>
2093 static const unsigned char jmp_mips_bytes[] =
2095 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2096 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2099 static const unsigned char jmp_arm_bytes[] =
2101 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2102 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2108 make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
2110 asection *tx, *id7, *id5, *id4, *id6;
2111 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
2115 const unsigned char *jmp_bytes = NULL;
2116 int jmp_byte_count = 0;
2118 /* Include the jump stub section only if it is needed. A jump
2119 stub is needed if the symbol being imported <sym> is a function
2120 symbol and there is at least one undefined reference to that
2121 symbol. In other words, if all the import references to <sym> are
2122 explicitly through _declspec(dllimport) then the jump stub is not
2124 if (include_jmp_stub)
2126 switch (pe_details->pe_arch)
2129 jmp_bytes = jmp_ix86_bytes;
2130 jmp_byte_count = sizeof (jmp_ix86_bytes);
2133 jmp_bytes = jmp_sh_bytes;
2134 jmp_byte_count = sizeof (jmp_sh_bytes);
2137 jmp_bytes = jmp_mips_bytes;
2138 jmp_byte_count = sizeof (jmp_mips_bytes);
2141 case PE_ARCH_arm_epoc:
2142 case PE_ARCH_arm_wince:
2143 jmp_bytes = jmp_arm_bytes;
2144 jmp_byte_count = sizeof (jmp_arm_bytes);
2151 oname = xmalloc (20);
2152 sprintf (oname, "d%06d.o", tmp_seq);
2155 abfd = bfd_create (oname, parent);
2156 bfd_find_target (pe_details->object_target, abfd);
2157 bfd_make_writable (abfd);
2159 bfd_set_format (abfd, bfd_object);
2160 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2163 symtab = xmalloc (12 * sizeof (asymbol *));
2165 tx = quick_section (abfd, ".text", SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY, 2);
2166 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2167 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2168 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2169 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
2171 if (*exp->internal_name == '@')
2173 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2175 if (include_jmp_stub)
2176 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
2177 quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
2179 /* Fastcall applies only to functions,
2180 so no need for auto-import symbol. */
2184 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2186 if (include_jmp_stub)
2187 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
2189 quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
2191 /* Symbol to reference ord/name of imported
2192 data symbol, used to implement auto-import. */
2194 quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
2197 if (pe_dll_compat_implib)
2198 quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
2201 if (include_jmp_stub)
2203 bfd_set_section_size (abfd, tx, jmp_byte_count);
2204 td = xmalloc (jmp_byte_count);
2206 memcpy (td, jmp_bytes, jmp_byte_count);
2208 switch (pe_details->pe_arch)
2211 #ifdef pe_use_x86_64
2212 quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
2214 /* Mark this object as SAFESEH compatible. */
2215 quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
2217 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
2221 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2224 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
2225 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
2226 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2229 case PE_ARCH_arm_epoc:
2230 case PE_ARCH_arm_wince:
2231 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2239 bfd_set_section_size (abfd, tx, 0);
2241 bfd_set_section_size (abfd, id7, 4);
2245 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2248 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2249 d5 = xmalloc (PE_IDATA5_SIZE);
2251 memset (d5, 0, PE_IDATA5_SIZE);
2253 if (exp->flag_noname)
2255 d5[0] = exp->ordinal;
2256 d5[1] = exp->ordinal >> 8;
2257 d5[PE_IDATA5_SIZE - 1] = 0x80;
2261 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2265 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2266 d4 = xmalloc (PE_IDATA4_SIZE);
2268 memset (d4, 0, PE_IDATA4_SIZE);
2270 if (exp->flag_noname)
2272 d4[0] = exp->ordinal;
2273 d4[1] = exp->ordinal >> 8;
2274 d4[PE_IDATA4_SIZE - 1] = 0x80;
2278 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2282 if (exp->flag_noname)
2285 bfd_set_section_size (abfd, id6, 0);
2291 /* { short, asciz } */
2293 len = 2 + strlen (exp->its_name) + 1;
2295 len = 2 + strlen (exp->name) + 1;
2298 bfd_set_section_size (abfd, id6, len);
2301 memset (d6, 0, len);
2303 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2304 contains an invalid value (-1). */
2305 ord = (exp->ordinal >= 0) ? exp->ordinal : exp->hint;
2310 strcpy ((char*) d6 + 2, exp->its_name);
2312 strcpy ((char *) d6 + 2, exp->name);
2315 bfd_set_symtab (abfd, symtab, symptr);
2317 if (include_jmp_stub)
2318 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2319 bfd_set_section_contents (abfd, id7, d7, 0, 4);
2320 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2321 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2322 if (!exp->flag_noname)
2323 bfd_set_section_contents (abfd, id6, d6, 0, len);
2325 bfd_make_readable (abfd);
2330 make_singleton_name_imp (const char *import, bfd *parent)
2332 /* Name thunks go to idata$4. */
2338 oname = xmalloc (20);
2339 sprintf (oname, "nmimp%06d.o", tmp_seq2);
2342 abfd = bfd_create (oname, parent);
2343 bfd_find_target (pe_details->object_target, abfd);
2344 bfd_make_writable (abfd);
2346 bfd_set_format (abfd, bfd_object);
2347 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2350 symtab = xmalloc (3 * sizeof (asymbol *));
2351 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2352 quick_symbol (abfd, "__imp_", import, "", id5, BSF_GLOBAL, 0);
2354 /* We need space for the real thunk and for the null terminator. */
2355 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
2356 d5 = xmalloc (PE_IDATA5_SIZE * 2);
2358 memset (d5, 0, PE_IDATA5_SIZE * 2);
2359 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2362 bfd_set_symtab (abfd, symtab, symptr);
2364 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
2366 bfd_make_readable (abfd);
2371 make_singleton_name_thunk (const char *import, bfd *parent)
2373 /* Name thunks go to idata$4. */
2379 oname = xmalloc (20);
2380 sprintf (oname, "nmth%06d.o", tmp_seq);
2383 abfd = bfd_create (oname, parent);
2384 bfd_find_target (pe_details->object_target, abfd);
2385 bfd_make_writable (abfd);
2387 bfd_set_format (abfd, bfd_object);
2388 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2391 symtab = xmalloc (3 * sizeof (asymbol *));
2392 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2393 quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
2394 quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
2396 /* We need space for the real thunk and for the null terminator. */
2397 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2398 d4 = xmalloc (PE_IDATA4_SIZE * 2);
2400 memset (d4, 0, PE_IDATA4_SIZE * 2);
2401 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2404 bfd_set_symtab (abfd, symtab, symptr);
2406 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2408 bfd_make_readable (abfd);
2413 make_import_fixup_mark (arelent *rel, char *name)
2415 /* We convert reloc to symbol, for later reference. */
2416 static unsigned int counter;
2417 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2418 bfd *abfd = bfd_asymbol_bfd (sym);
2419 struct bfd_link_hash_entry *bh;
2420 char *fixup_name, buf[26];
2423 /* "name" buffer has space before the symbol name for prefixes. */
2424 sprintf (buf, "__fu%d_", counter++);
2425 prefix_len = strlen (buf);
2426 fixup_name = name - prefix_len;
2427 memcpy (fixup_name, buf, prefix_len);
2430 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2431 current_sec, /* sym->section, */
2432 rel->address, NULL, TRUE, FALSE, &bh);
2437 /* .section .idata$2
2438 .rva __nm_thnk_SYM (singleton thunk with name of func)
2441 .rva __my_dll_iname (name of dll)
2442 .rva __fuNN_SYM (pointer to reference (address) in text) */
2445 make_import_fixup_entry (const char *name,
2446 const char *fixup_name,
2447 const char *symname,
2455 oname = xmalloc (20);
2456 sprintf (oname, "fu%06d.o", tmp_seq);
2459 abfd = bfd_create (oname, parent);
2460 bfd_find_target (pe_details->object_target, abfd);
2461 bfd_make_writable (abfd);
2463 bfd_set_format (abfd, bfd_object);
2464 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2467 symtab = xmalloc (6 * sizeof (asymbol *));
2468 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2470 quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
2471 quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2472 /* For relocator v2 we have to use the .idata$5 element and not
2474 if (link_info.pei386_runtime_pseudo_reloc == 2)
2475 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2477 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2479 bfd_set_section_size (abfd, id2, 20);
2484 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2485 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2486 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2489 bfd_set_symtab (abfd, symtab, symptr);
2491 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2493 bfd_make_readable (abfd);
2497 /* .section .rdata_runtime_pseudo_reloc
2499 .rva __fuNN_SYM (pointer to reference (address) in text) */
2502 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2503 const char *fixup_name,
2504 bfd_vma addend ATTRIBUTE_UNUSED,
2509 unsigned char *rt_rel_d;
2512 oname = xmalloc (20);
2513 sprintf (oname, "rtr%06d.o", tmp_seq);
2516 abfd = bfd_create (oname, parent);
2517 bfd_find_target (pe_details->object_target, abfd);
2518 bfd_make_writable (abfd);
2520 bfd_set_format (abfd, bfd_object);
2521 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2524 if (link_info.pei386_runtime_pseudo_reloc == 2)
2526 symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
2530 symtab = xmalloc (2 * sizeof (asymbol *));
2532 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2533 SEC_HAS_CONTENTS, 2);
2535 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2537 if (link_info.pei386_runtime_pseudo_reloc == 2)
2540 if (! runtime_pseudp_reloc_v2_init)
2543 runtime_pseudp_reloc_v2_init = 1;
2545 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2547 bfd_set_section_size (abfd, rt_rel, size);
2548 rt_rel_d = xmalloc (size);
2549 rt_rel->contents = rt_rel_d;
2550 memset (rt_rel_d, 0, size);
2551 quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
2552 quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
2553 bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
2555 bfd_put_32 (abfd, 1, rt_rel_d + 8);
2556 save_relocs (rt_rel);
2558 bfd_set_symtab (abfd, symtab, symptr);
2560 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
2564 bfd_set_section_size (abfd, rt_rel, 8);
2565 rt_rel_d = xmalloc (8);
2566 rt_rel->contents = rt_rel_d;
2567 memset (rt_rel_d, 0, 8);
2569 bfd_put_32 (abfd, addend, rt_rel_d);
2570 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2572 save_relocs (rt_rel);
2574 bfd_set_symtab (abfd, symtab, symptr);
2576 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2578 bfd_make_readable (abfd);
2583 .rva __pei386_runtime_relocator */
2586 pe_create_runtime_relocator_reference (bfd *parent)
2588 asection *extern_rt_rel;
2589 unsigned char *extern_rt_rel_d;
2593 oname = xmalloc (20);
2594 sprintf (oname, "ertr%06d.o", tmp_seq);
2597 abfd = bfd_create (oname, parent);
2598 bfd_find_target (pe_details->object_target, abfd);
2599 bfd_make_writable (abfd);
2601 bfd_set_format (abfd, bfd_object);
2602 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2605 symtab = xmalloc (2 * sizeof (asymbol *));
2606 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2608 quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2611 bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
2612 extern_rt_rel_d = xcalloc (1, PE_IDATA5_SIZE);
2613 extern_rt_rel->contents = extern_rt_rel_d;
2615 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2616 save_relocs (extern_rt_rel);
2618 bfd_set_symtab (abfd, symtab, symptr);
2620 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
2622 bfd_make_readable (abfd);
2627 pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend, char *name)
2629 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2630 struct bfd_link_hash_entry *name_thunk_sym;
2631 struct bfd_link_hash_entry *name_imp_sym;
2632 char *fixup_name, *impname;
2634 int need_import_table = 1;
2636 /* name buffer is allocated with space at beginning for prefixes. */
2637 impname = name - (sizeof "__imp_" - 1);
2638 memcpy (impname, "__imp_", sizeof "__imp_" - 1);
2639 name_imp_sym = bfd_link_hash_lookup (link_info.hash, impname, 0, 0, 1);
2641 impname = name - (sizeof "__nm_thnk_" - 1);
2642 memcpy (impname, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2643 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, impname, 0, 0, 1);
2645 fixup_name = make_import_fixup_mark (rel, name);
2647 /* For version 2 pseudo relocation we don't need to add an import
2648 if the import symbol is already present. */
2649 if (link_info.pei386_runtime_pseudo_reloc == 2
2651 && name_imp_sym->type == bfd_link_hash_defined)
2652 need_import_table = 0;
2654 if (need_import_table == 1
2655 && (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined))
2657 b = make_singleton_name_thunk (name, link_info.output_bfd);
2658 add_bfd_to_link (b, b->filename, &link_info);
2660 /* If we ever use autoimport, we have to cast text section writable.
2661 But not for version 2. */
2662 if (link_info.pei386_runtime_pseudo_reloc != 2)
2664 config.text_read_only = FALSE;
2665 link_info.output_bfd->flags &= ~WP_TEXT;
2667 if (link_info.pei386_runtime_pseudo_reloc == 2)
2669 b = make_singleton_name_imp (name, link_info.output_bfd);
2670 add_bfd_to_link (b, b->filename, &link_info);
2674 if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2675 && need_import_table == 1)
2677 extern char * pe_data_import_dll;
2678 char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2680 b = make_import_fixup_entry (name, fixup_name, symname,
2681 link_info.output_bfd);
2682 add_bfd_to_link (b, b->filename, &link_info);
2685 if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
2686 || link_info.pei386_runtime_pseudo_reloc == 2)
2688 if (pe_dll_extra_pe_debug)
2689 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2690 fixup_name, (int) addend);
2692 b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
2693 link_info.output_bfd);
2694 add_bfd_to_link (b, b->filename, &link_info);
2696 if (runtime_pseudo_relocs_created == 0)
2698 b = pe_create_runtime_relocator_reference (link_info.output_bfd);
2699 add_bfd_to_link (b, b->filename, &link_info);
2701 runtime_pseudo_relocs_created++;
2703 else if (addend != 0)
2704 einfo (_("%P%X%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2705 s->owner, s, rel->address, sym->name);
2710 pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
2719 dll_filename = (def->name) ? def->name : dll_name;
2720 dll_symname = xstrdup (dll_filename);
2721 for (i = 0; dll_symname[i]; i++)
2722 if (!ISALNUM (dll_symname[i]))
2723 dll_symname[i] = '_';
2725 unlink_if_ordinary (impfilename);
2727 outarch = bfd_openw (impfilename, 0);
2731 /* xgettext:c-format */
2732 einfo (_("%P%X: Can't open .lib file: %s\n"), impfilename);
2737 /* xgettext:c-format */
2738 info_msg (_("Creating library file: %s\n"), impfilename);
2740 bfd_set_format (outarch, bfd_archive);
2741 outarch->has_armap = 1;
2743 /* Work out a reasonable size of things to put onto one line. */
2744 ar_head = make_head (outarch);
2746 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2747 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
2749 /* Iterate the exclude list. */
2750 struct exclude_list_struct *ex;
2752 for (ex = excludes, found = 0; ex && !found; ex = ex->next)
2754 if (ex->type != EXCLUDEFORIMPLIB)
2756 found = (filename_cmp (ex->string, ibfd->filename) == 0);
2758 /* If it matched, we must open a fresh BFD for it (the original
2759 input BFD is still needed for the DLL's final link) and add
2760 it into the archive member chain. */
2763 bfd *newbfd = bfd_openr (ibfd->my_archive
2764 ? ibfd->my_archive->filename : ibfd->filename, NULL);
2767 einfo (_("%P%X: bfd_openr %s: %E\n"), ibfd->filename);
2770 if (ibfd->my_archive)
2772 /* Must now iterate through archive until we find the
2773 required member. A minor shame that we'll open the
2774 archive once per member that we require from it, and
2775 leak those archive bfds rather than reuse them. */
2776 bfd *arbfd = newbfd;
2777 if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
2779 einfo (_("%P%X: %s(%s): can't find member in non-archive file"),
2780 ibfd->my_archive->filename, ibfd->filename);
2784 while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
2786 if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
2791 einfo (_("%P%X: %s(%s): can't find member in archive"),
2792 ibfd->my_archive->filename, ibfd->filename);
2796 newbfd->archive_next = head;
2801 for (i = 0; i < def->num_exports; i++)
2803 /* The import library doesn't know about the internal name. */
2804 char *internal = def->exports[i].internal_name;
2807 /* Don't add PRIVATE entries to import lib. */
2808 if (pe_def_file->exports[i].flag_private)
2811 def->exports[i].internal_name = def->exports[i].name;
2813 /* PR 19803: If a symbol has been discard due to garbage
2814 collection then do not create any exports for it. */
2816 struct coff_link_hash_entry *h;
2818 h = coff_link_hash_lookup (coff_hash_table (info), internal,
2819 FALSE, FALSE, FALSE);
2821 /* If the symbol is hidden and undefined then it
2822 has been swept up by garbage collection. */
2823 && h->symbol_class == C_HIDDEN
2824 && h->root.u.def.section == bfd_und_section_ptr)
2827 /* If necessary, check with an underscore prefix as well. */
2828 if (pe_details->underscored && internal[0] != '@')
2832 name = xmalloc (strlen (internal) + 2);
2833 sprintf (name, "_%s", internal);
2835 h = coff_link_hash_lookup (coff_hash_table (info), name,
2836 FALSE, FALSE, FALSE);
2840 /* If the symbol is hidden and undefined then it
2841 has been swept up by garbage collection. */
2842 && h->symbol_class == C_HIDDEN
2843 && h->root.u.def.section == bfd_und_section_ptr)
2848 n = make_one (def->exports + i, outarch,
2849 ! (def->exports + i)->flag_data);
2850 n->archive_next = head;
2852 def->exports[i].internal_name = internal;
2855 ar_tail = make_tail (outarch);
2857 if (ar_head == NULL || ar_tail == NULL)
2860 /* Now stick them all into the archive. */
2861 ar_head->archive_next = head;
2862 ar_tail->archive_next = ar_head;
2865 if (! bfd_set_archive_head (outarch, head))
2866 einfo ("%P%X: bfd_set_archive_head: %E\n");
2868 if (! bfd_close (outarch))
2869 einfo ("%P%X: bfd_close %s: %E\n", impfilename);
2871 while (head != NULL)
2873 bfd *n = head->archive_next;
2879 static int undef_count = 0;
2887 static struct key_value *udef_table;
2889 static int undef_sort_cmp (const void *l1, const void *r1)
2891 const struct key_value *l = l1;
2892 const struct key_value *r = r1;
2894 return strcmp (l->key, r->key);
2897 static struct bfd_link_hash_entry *
2898 pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
2900 struct bfd_link_hash_entry *h = NULL;
2901 struct key_value *kv;
2902 struct key_value key;
2903 char *at, *lname = xmalloc (strlen (name) + 3);
2905 strcpy (lname, name);
2907 at = strchr (lname + (lname[0] == '@'), '@');
2912 kv = bsearch (&key, udef_table, undef_count, sizeof (struct key_value),
2917 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2918 if (h->type == bfd_link_hash_undefined)
2922 if (lname[0] == '?')
2925 if (at || lname[0] == '@')
2927 if (lname[0] == '@')
2929 if (pe_details->underscored)
2932 strcpy (lname, lname + 1);
2934 kv = bsearch (&key, udef_table, undef_count,
2935 sizeof (struct key_value), undef_sort_cmp);
2938 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2939 if (h->type == bfd_link_hash_undefined)
2944 *strchr (lname, '@') = 0;
2946 kv = bsearch (&key, udef_table, undef_count,
2947 sizeof (struct key_value), undef_sort_cmp);
2950 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2951 if (h->type == bfd_link_hash_undefined)
2957 strcat (lname, "@");
2959 kv = bsearch (&key, udef_table, undef_count,
2960 sizeof (struct key_value), undef_sort_cmp);
2964 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2965 if (h->type == bfd_link_hash_undefined)
2969 if (lname[0] == '_' && pe_details->underscored)
2973 memmove (lname + 1, lname, strlen (lname) + 1);
2978 kv = bsearch (&key, udef_table, undef_count,
2979 sizeof (struct key_value), undef_sort_cmp);
2983 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2984 if (h->type == bfd_link_hash_undefined)
2996 pe_undef_count (struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
2997 void *inf ATTRIBUTE_UNUSED)
2999 if (h->type == bfd_link_hash_undefined)
3005 pe_undef_fill (struct bfd_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
3007 if (h->type == bfd_link_hash_undefined)
3011 udef_table[undef_count].key = xstrdup (h->root.string);
3012 at = strchr (udef_table[undef_count].key
3013 + (udef_table[undef_count].key[0] == '@'), '@');
3016 udef_table[undef_count].oname = h->root.string;
3023 pe_create_undef_table (void)
3027 /* count undefined symbols */
3029 bfd_link_hash_traverse (link_info.hash, pe_undef_count, "");
3031 /* create and fill the corresponding table */
3032 udef_table = xmalloc (undef_count * sizeof (struct key_value));
3035 bfd_link_hash_traverse (link_info.hash, pe_undef_fill, "");
3038 qsort (udef_table, undef_count, sizeof (struct key_value), undef_sort_cmp);
3042 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
3044 lang_input_statement_type *fake_file;
3046 fake_file = lang_add_input_file (name,
3047 lang_input_file_is_fake_enum,
3049 fake_file->the_bfd = abfd;
3050 ldlang_add_file (fake_file);
3052 if (!bfd_link_add_symbols (abfd, linfo))
3053 einfo (_("%P%X: add symbols %s: %E\n"), name);
3057 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
3060 def_file_module *module;
3061 def_file_import *imp;
3063 pe_dll_id_target (bfd_get_target (output_bfd));
3068 imp = pe_def_file->imports;
3070 pe_create_undef_table ();
3072 for (module = pe_def_file->modules; module; module = module->next)
3074 int do_this_dll = 0;
3076 for (i = 0; i < pe_def_file->num_imports && imp[i].module != module; i++)
3078 if (i >= pe_def_file->num_imports)
3081 dll_filename = module->name;
3082 dll_symname = xstrdup (module->name);
3083 for (j = 0; dll_symname[j]; j++)
3084 if (!ISALNUM (dll_symname[j]))
3085 dll_symname[j] = '_';
3087 for (; i < pe_def_file->num_imports && imp[i].module == module; i++)
3089 def_file_export exp;
3090 struct bfd_link_hash_entry *blhe;
3091 int lead_at = (*imp[i].internal_name == '@');
3092 /* See if we need this import. */
3093 size_t len = strlen (imp[i].internal_name);
3094 char *name = xmalloc (len + 2 + 6);
3095 bfd_boolean include_jmp_stub = FALSE;
3096 bfd_boolean is_cdecl = FALSE;
3097 bfd_boolean is_undef = FALSE;
3099 if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
3103 sprintf (name, "%s", imp[i].internal_name);
3105 sprintf (name, "%s%s",U (""), imp[i].internal_name);
3107 blhe = bfd_link_hash_lookup (linfo->hash, name,
3108 FALSE, FALSE, FALSE);
3110 /* Include the jump stub for <sym> only if the <sym>
3112 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
3115 sprintf (name, "%s%s", "__imp_", imp[i].internal_name);
3117 sprintf (name, "%s%s%s", "__imp_", U (""),
3118 imp[i].internal_name);
3120 blhe = bfd_link_hash_lookup (linfo->hash, name,
3121 FALSE, FALSE, FALSE);
3123 is_undef = (blhe->type == bfd_link_hash_undefined);
3127 include_jmp_stub = TRUE;
3128 is_undef = (blhe->type == bfd_link_hash_undefined);
3131 if (is_cdecl && (!blhe || (blhe && blhe->type != bfd_link_hash_undefined)))
3133 sprintf (name, "%s%s",U (""), imp[i].internal_name);
3134 blhe = pe_find_cdecl_alias_match (linfo, name);
3135 include_jmp_stub = TRUE;
3137 is_undef = (blhe->type == bfd_link_hash_undefined);
3148 bfd *ar_head = make_head (output_bfd);
3149 add_bfd_to_link (ar_head, ar_head->filename, linfo);
3152 exp.internal_name = imp[i].internal_name;
3153 exp.name = imp[i].name;
3154 exp.its_name = imp[i].its_name;
3155 exp.ordinal = imp[i].ordinal;
3156 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
3157 exp.flag_private = 0;
3158 exp.flag_constant = 0;
3159 exp.flag_data = imp[i].data;
3160 exp.flag_noname = exp.name ? 0 : 1;
3161 one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
3162 add_bfd_to_link (one, one->filename, linfo);
3167 bfd *ar_tail = make_tail (output_bfd);
3168 add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
3177 free (udef_table[undef_count].key);
3182 /* We were handed a *.DLL file. Parse it and turn it into a set of
3183 IMPORTS directives in the def file. Return TRUE if the file was
3184 handled, FALSE if not. */
3187 pe_get16 (bfd *abfd, int where)
3191 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
3192 bfd_bread (b, (bfd_size_type) 2, abfd);
3193 return b[0] + (b[1] << 8);
3197 pe_get32 (bfd *abfd, int where)
3201 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
3202 bfd_bread (b, (bfd_size_type) 4, abfd);
3203 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
3209 unsigned char *b = ptr;
3211 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
3215 pe_implied_import_dll (const char *filename)
3218 bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
3219 bfd_vma export_rva, export_size, nsections, secptr, expptr;
3220 bfd_vma exp_funcbase;
3221 unsigned char *expdata;
3223 bfd_vma name_rvas, nexp;
3224 const char *dllname;
3225 /* Initialization with start > end guarantees that is_data
3226 will not be set by mistake, and avoids compiler warning. */
3227 bfd_vma data_start = 1;
3228 bfd_vma data_end = 0;
3229 bfd_vma rdata_start = 1;
3230 bfd_vma rdata_end = 0;
3231 bfd_vma bss_start = 1;
3232 bfd_vma bss_end = 0;
3234 /* No, I can't use bfd here. kernel32.dll puts its export table in
3235 the middle of the .rdata section. */
3236 dll = bfd_openr (filename, pe_details->target_name);
3239 einfo (_("%P%X: open %s: %E\n"), filename);
3243 /* PEI dlls seem to be bfd_objects. */
3244 if (!bfd_check_format (dll, bfd_object))
3246 einfo (_("%P%X: %s: this doesn't appear to be a DLL\n"), filename);
3250 /* Get pe_header, optional header and numbers of directory entries. */
3251 pe_header_offset = pe_get32 (dll, 0x3c);
3252 opthdr_ofs = pe_header_offset + 4 + 20;
3253 #ifdef pe_use_x86_64
3254 num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3256 num_entries = pe_get32 (dll, opthdr_ofs + 92);
3259 /* No import or export directory entry. */
3260 if (num_entries < 1)
3263 #ifdef pe_use_x86_64
3264 export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
3265 export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
3267 export_rva = pe_get32 (dll, opthdr_ofs + 96);
3268 export_size = pe_get32 (dll, opthdr_ofs + 100);
3271 /* No export table - nothing to export. */
3272 if (export_size == 0)
3275 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
3276 secptr = (pe_header_offset + 4 + 20 +
3277 pe_get16 (dll, pe_header_offset + 4 + 16));
3280 /* Get the rva and size of the export section. */
3281 for (i = 0; i < nsections; i++)
3284 bfd_vma secptr1 = secptr + 40 * i;
3285 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3286 bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
3287 bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
3289 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
3290 bfd_bread (sname, (bfd_size_type) 8, dll);
3292 if (vaddr <= export_rva && vaddr + vsize > export_rva)
3294 expptr = fptr + (export_rva - vaddr);
3295 if (export_rva + export_size > vaddr + vsize)
3296 export_size = vsize - (export_rva - vaddr);
3301 /* Scan sections and store the base and size of the
3302 data and bss segments in data/base_start/end. */
3303 for (i = 0; i < nsections; i++)
3305 bfd_vma secptr1 = secptr + 40 * i;
3306 bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
3307 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3308 bfd_vma flags = pe_get32 (dll, secptr1 + 36);
3312 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
3313 bfd_bread (sec_name, (bfd_size_type) 8, dll);
3315 if (strcmp(sec_name,".data") == 0)
3318 data_end = vaddr + vsize;
3320 if (pe_dll_extra_pe_debug)
3321 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3322 __FUNCTION__, sec_name, (unsigned long) vaddr,
3323 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3325 else if (strcmp(sec_name,".rdata") == 0)
3327 rdata_start = vaddr;
3328 rdata_end = vaddr + vsize;
3330 if (pe_dll_extra_pe_debug)
3331 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3332 __FUNCTION__, sec_name, (unsigned long) vaddr,
3333 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3335 else if (strcmp (sec_name,".bss") == 0)
3338 bss_end = vaddr + vsize;
3340 if (pe_dll_extra_pe_debug)
3341 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3342 __FUNCTION__, sec_name, (unsigned long) vaddr,
3343 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3347 expdata = xmalloc (export_size);
3348 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
3349 bfd_bread (expdata, (bfd_size_type) export_size, dll);
3350 erva = (char *) expdata - export_rva;
3352 if (pe_def_file == 0)
3353 pe_def_file = def_file_empty ();
3355 nexp = pe_as32 (expdata + 24);
3356 name_rvas = pe_as32 (expdata + 32);
3357 exp_funcbase = pe_as32 (expdata + 28);
3359 /* Use internal dll name instead of filename
3360 to enable symbolic dll linking. */
3361 dllname = erva + pe_as32 (expdata + 12);
3363 /* Check to see if the dll has already been added to
3364 the definition list and if so return without error.
3365 This avoids multiple symbol definitions. */
3366 if (def_get_module (pe_def_file, dllname))
3368 if (pe_dll_extra_pe_debug)
3369 printf ("%s is already loaded\n", dllname);
3373 /* Iterate through the list of symbols. */
3374 for (i = 0; i < nexp; i++)
3376 /* Pointer to the names vector. */
3377 bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3378 def_file_import *imp;
3379 /* Pointer to the function address vector. */
3380 bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3383 /* Skip unwanted symbols, which are
3384 exported in buggy auto-import releases. */
3385 if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
3388 /* is_data is true if the address is in the data, rdata or bss
3391 (func_rva >= data_start && func_rva < data_end)
3392 || (func_rva >= rdata_start && func_rva < rdata_end)
3393 || (func_rva >= bss_start && func_rva < bss_end);
3395 imp = def_file_add_import (pe_def_file, erva + name_rva,
3396 dllname, i, NULL, NULL, &is_dup);
3397 /* Mark symbol type. */
3399 imp->data = is_data;
3401 if (pe_dll_extra_pe_debug)
3402 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3403 __FUNCTION__, dllname, erva + name_rva,
3404 (unsigned long) func_rva, is_data ? "(data)" : "");
3412 pe_output_file_set_long_section_names (bfd *abfd)
3414 if (pe_use_coff_long_section_names < 0)
3416 if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
3417 einfo (_("%P%X: Error: can't use long section names on this arch\n"));
3420 /* These are the main functions, called from the emulation. The first
3421 is called after the bfds are read, so we can guess at how much space
3422 we need. The second is called after everything is placed, so we
3423 can put the right values in place. */
3426 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
3428 pe_dll_id_target (bfd_get_target (abfd));
3429 pe_output_file_set_long_section_names (abfd);
3430 process_def_file_and_drectve (abfd, info);
3432 if (pe_def_file->num_exports == 0 && !bfd_link_pic (info))
3435 generate_edata (abfd, info);
3436 build_filler_bfd (1);
3437 pe_output_file_set_long_section_names (filler_bfd);
3441 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3443 pe_dll_id_target (bfd_get_target (abfd));
3444 pe_output_file_set_long_section_names (abfd);
3445 build_filler_bfd (0);
3446 pe_output_file_set_long_section_names (filler_bfd);
3450 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
3452 pe_dll_id_target (bfd_get_target (abfd));
3453 pe_output_file_set_long_section_names (abfd);
3454 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3456 generate_reloc (abfd, info);
3459 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3461 /* Resize the sections. */
3462 lang_reset_memory_regions ();
3463 lang_size_sections (NULL, TRUE);
3465 /* Redo special stuff. */
3466 ldemul_after_allocation ();
3468 /* Do the assignments again. */
3469 lang_do_assignments (lang_final_phase_enum);
3472 fill_edata (abfd, info);
3474 if (bfd_link_dll (info))
3475 pe_data (abfd)->dll = 1;
3477 edata_s->contents = edata_d;
3478 reloc_s->contents = reloc_d;
3482 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
3484 pe_dll_id_target (bfd_get_target (abfd));
3485 pe_output_file_set_long_section_names (abfd);
3486 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3488 generate_reloc (abfd, info);
3491 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3493 /* Resize the sections. */
3494 lang_reset_memory_regions ();
3495 lang_size_sections (NULL, TRUE);
3497 /* Redo special stuff. */
3498 ldemul_after_allocation ();
3500 /* Do the assignments again. */
3501 lang_do_assignments (lang_final_phase_enum);
3503 reloc_s->contents = reloc_d;
3507 pe_bfd_is_dll (bfd *abfd)
3509 return (bfd_get_format (abfd) == bfd_object
3511 && pe_data (abfd)->dll);