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 bfd_boolean runtime_pseudp_reloc_v2_init = FALSE;
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 (_("%X%P: 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 (_("%F%P: %pB: 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 (_("%X%P: 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 (_("%X%P: 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 (_("%X%P: cannot export %s: symbol not defined\n"),
988 /* xgettext:c-format */
989 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
991 blhe->type, bfd_link_hash_defined);
995 /* xgettext:c-format */
996 einfo (_("%X%P: 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 (_("%F%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 (_("%X%P: 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(_("%X%P: 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 (struct bfd_link_info *info,
1293 const char *symname,
1294 struct bfd_hash_table *import_hash,
1295 void (*cb) (arelent *, asection *, char *, const char *))
1300 for (b = info->input_bfds; b; b = b->link.next)
1304 if (!bfd_generic_link_read_symbols (b))
1306 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
1310 symbols = bfd_get_outsymbols (b);
1312 for (s = b->sections; s; s = s->next)
1315 int relsize, nrelocs, i;
1316 int flags = bfd_get_section_flags (b, s);
1318 /* Skip discarded linkonce sections. */
1319 if (flags & SEC_LINK_ONCE
1320 && s->output_section == bfd_abs_section_ptr)
1325 relsize = bfd_get_reloc_upper_bound (b, s);
1326 relocs = xmalloc (relsize);
1327 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1329 for (i = 0; i < nrelocs; i++)
1331 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1333 /* Warning: the callback needs to be passed NAME directly. */
1336 if (bfd_hash_lookup (import_hash, sym->name, FALSE, FALSE))
1338 strcpy (name, sym->name);
1339 cb (relocs[i], s, name, symname);
1344 if (strcmp (name, sym->name) == 0)
1345 cb (relocs[i], s, name, symname);
1351 /* Warning: the allocated symbols are remembered in BFD and reused
1352 later, so don't free them! */
1353 /* free (symbols); */
1359 pe_find_data_imports (const char *symhead,
1360 void (*cb) (arelent *, asection *, char *, const char *))
1362 struct bfd_link_hash_entry *undef;
1363 const size_t headlen = strlen (symhead);
1366 struct bfd_hash_table *import_hash;
1368 for (undef = link_info.hash->undefs; undef; undef = undef->u.undef.next)
1369 if (undef->type == bfd_link_hash_undefined)
1371 size_t len = strlen (undef->root.string);
1378 /* For the pseudo-relocation support version 2, we can collect the symbols
1379 that are subject to auto-import and adjust the relocations en masse. */
1380 if (link_info.pei386_runtime_pseudo_reloc == 2)
1383 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
1384 if (!bfd_hash_table_init (import_hash,
1386 sizeof (struct bfd_hash_entry)))
1387 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1392 /* We are being a bit cunning here. The buffer will have space for
1393 prefixes at the beginning. The prefix is modified here and in a
1394 number of functions called from this function. */
1395 #define PREFIX_LEN 32
1396 buf = xmalloc (PREFIX_LEN + namelen + 1);
1397 name = buf + PREFIX_LEN;
1399 for (undef = link_info.hash->undefs; undef; undef = undef->u.undef.next)
1400 if (undef->type == bfd_link_hash_undefined)
1402 struct bfd_link_hash_entry *sym;
1405 if (pe_dll_extra_pe_debug)
1406 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
1408 strcpy (name, undef->root.string);
1409 impname = name - (sizeof "__imp_" - 1);
1410 memcpy (impname, "__imp_", sizeof "__imp_" - 1);
1412 sym = bfd_link_hash_lookup (link_info.hash, impname, 0, 0, 1);
1414 if (sym && sym->type == bfd_link_hash_defined)
1417 bfd_hash_lookup (import_hash, undef->root.string, TRUE, FALSE);
1420 bfd *b = sym->u.def.section->owner;
1421 const char *symname = NULL;
1425 if (!bfd_generic_link_read_symbols (b))
1427 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
1431 symbols = bfd_get_outsymbols (b);
1432 nsyms = bfd_get_symcount (b);
1434 for (i = 0; i < nsyms; i++)
1435 if (strncmp (symbols[i]->name, symhead, headlen) == 0)
1437 if (pe_dll_extra_pe_debug)
1438 printf ("->%s\n", symbols[i]->name);
1440 symname = symbols[i]->name + headlen;
1444 /* If the symobl isn't part of an import table, there is no
1445 point in building a fixup, this would give rise to link
1446 errors for mangled symbols instead of the original one. */
1448 pe_walk_relocs (&link_info, name, symname, NULL, cb);
1453 /* Let's differentiate it somehow from defined. */
1454 undef->type = bfd_link_hash_defweak;
1455 undef->u.def.value = sym->u.def.value;
1456 undef->u.def.section = sym->u.def.section;
1458 if (link_info.pei386_auto_import == -1)
1460 static bfd_boolean warned = FALSE;
1462 info_msg (_("Info: resolving %s by linking to %s "
1463 "(auto-import)\n"), name, impname);
1465 /* PR linker/4844. */
1468 einfo (_("%P: warning: auto-importing has been activated "
1469 "without --enable-auto-import specified on the "
1470 "command line; this should work unless it "
1471 "involves constant data structures referencing "
1472 "symbols from auto-imported DLLs\n"));
1479 /* If we have the import hash table, walk the relocations only once. */
1482 pe_walk_relocs (&link_info, name, NULL, import_hash, cb);
1483 bfd_hash_table_free (import_hash);
1490 /* Gather all the relocations and build the .reloc section. */
1493 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1496 /* For .reloc stuff. */
1497 reloc_data_type *reloc_data;
1498 int total_relocs = 0;
1500 bfd_vma sec_page = (bfd_vma) -1;
1501 bfd_vma page_ptr, page_count;
1504 struct bfd_section *s;
1507 for (b = info->input_bfds; b; b = b->link.next)
1508 for (s = b->sections; s; s = s->next)
1509 total_relocs += s->reloc_count;
1511 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1515 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link.next)
1518 int relsize, nrelocs;
1520 for (s = b->sections; s; s = s->next)
1522 bfd_vma sec_vma = s->output_section->vma + s->output_offset;
1525 /* If it's not loaded, we don't need to relocate it this way. */
1526 if (!(s->output_section->flags & SEC_LOAD))
1529 /* I don't know why there would be a reloc for these, but I've
1530 seen it happen - DJ */
1531 if (s->output_section == bfd_abs_section_ptr)
1534 if (s->output_section->vma == 0)
1536 /* Huh? Shouldn't happen, but punt if it does. */
1537 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1538 s->output_section->name, s->output_section->index,
1539 s->output_section->flags);
1543 if (!bfd_generic_link_read_symbols (b))
1545 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
1549 symbols = bfd_get_outsymbols (b);
1550 relsize = bfd_get_reloc_upper_bound (b, s);
1551 relocs = xmalloc (relsize);
1552 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1554 for (i = 0; i < nrelocs; i++)
1556 if (pe_dll_extra_pe_debug)
1558 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1559 printf ("rel: %s\n", sym->name);
1561 if (!relocs[i]->howto->pc_relative
1562 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1564 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1566 /* Don't create relocs for undefined weak symbols. */
1567 if (sym->flags == BSF_WEAK)
1569 struct bfd_link_hash_entry *blhe
1570 = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
1571 FALSE, FALSE, FALSE);
1572 if (blhe && blhe->type == bfd_link_hash_undefweak)
1574 /* Check aux sym and see if it is defined or not. */
1575 struct coff_link_hash_entry *h, *h2;
1576 h = (struct coff_link_hash_entry *)blhe;
1577 if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
1579 h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
1580 [h->aux->x_sym.x_tagndx.l];
1581 /* We don't want a base reloc if the aux sym is not
1582 found, undefined, or if it is the constant ABS
1583 zero default value. (We broaden that slightly by
1584 not testing the value, just the section; there's
1585 no reason we'd want a reference to any absolute
1586 address to get relocated during rebasing). */
1587 if (!h2 || h2->root.type == bfd_link_hash_undefined
1588 || h2->root.u.def.section == bfd_abs_section_ptr)
1591 else if (!blhe || blhe->type != bfd_link_hash_defined)
1594 /* Nor for Dwarf FDE references to discarded sections. */
1595 else if (bfd_is_abs_section (sym->section->output_section))
1597 /* We only ignore relocs from .eh_frame sections, as
1598 they are discarded by the final link rather than
1599 resolved against the kept section. */
1600 if (!strcmp (s->name, ".eh_frame"))
1604 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1606 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1608 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1609 relocs[i]->howto->rightshift)
1611 #ifdef pe_use_x86_64
1612 case BITS_AND_SHIFT (64, 0):
1613 reloc_data[total_relocs].type = 10;
1617 case BITS_AND_SHIFT (32, 0):
1618 reloc_data[total_relocs].type = 3;
1621 case BITS_AND_SHIFT (16, 0):
1622 reloc_data[total_relocs].type = 2;
1625 case BITS_AND_SHIFT (16, 16):
1626 reloc_data[total_relocs].type = 4;
1627 /* FIXME: we can't know the symbol's right value
1628 yet, but we probably can safely assume that
1629 CE will relocate us in 64k blocks, so leaving
1631 reloc_data[total_relocs].extra = 0;
1634 case BITS_AND_SHIFT (26, 2):
1635 reloc_data[total_relocs].type = 5;
1638 case BITS_AND_SHIFT (24, 2):
1639 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1640 Those ARM_xxx definitions should go in proper
1642 if (relocs[i]->howto->type == 0
1643 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1644 || relocs[i]->howto->type == 5)
1645 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1646 that has already been fully processed during a
1647 previous link stage, so ignore it here. */
1651 /* xgettext:c-format */
1652 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1653 relocs[i]->howto->bitsize);
1659 /* Warning: the allocated symbols are remembered in BFD and
1660 reused later, so don't free them! */
1664 /* At this point, we have total_relocs relocation addresses in
1665 reloc_addresses, which are all suitable for the .reloc section.
1666 We must now create the new sections. */
1667 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1669 for (i = 0; i < total_relocs; i++)
1671 bfd_vma this_page = (reloc_data[i].vma >> 12);
1673 if (this_page != sec_page)
1675 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1677 sec_page = this_page;
1682 if (reloc_data[i].type == 4)
1686 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1687 reloc_d = xmalloc (reloc_sz);
1688 sec_page = (bfd_vma) -1;
1690 page_ptr = (bfd_vma) -1;
1693 for (i = 0; i < total_relocs; i++)
1695 bfd_vma rva = reloc_data[i].vma - image_base;
1696 bfd_vma this_page = (rva & ~0xfff);
1698 if (this_page != sec_page)
1700 while (reloc_sz & 3)
1701 reloc_d[reloc_sz++] = 0;
1703 if (page_ptr != (bfd_vma) -1)
1704 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1706 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1707 page_ptr = reloc_sz;
1709 sec_page = this_page;
1713 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1714 reloc_d + reloc_sz);
1717 if (reloc_data[i].type == 4)
1719 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1726 while (reloc_sz & 3)
1727 reloc_d[reloc_sz++] = 0;
1729 if (page_ptr != (bfd_vma) -1)
1730 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1732 while (reloc_sz < reloc_s->size)
1733 reloc_d[reloc_sz++] = 0;
1736 /* Given the exiting def_file structure, print out a .DEF file that
1737 corresponds to it. */
1740 quoteput (char *s, FILE *f, int needs_quotes)
1744 for (cp = s; *cp; cp++)
1759 if (*s == '"' || *s == '\\')
1773 pe_dll_generate_def_file (const char *pe_out_def_filename)
1776 FILE *out = fopen (pe_out_def_filename, "w");
1779 /* xgettext:c-format */
1780 einfo (_("%P: can't open output def file %s\n"),
1781 pe_out_def_filename);
1785 if (pe_def_file->name)
1787 if (pe_def_file->is_dll)
1788 fprintf (out, "LIBRARY ");
1790 fprintf (out, "NAME ");
1792 quoteput (pe_def_file->name, out, 1);
1794 if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
1796 fprintf (out, " BASE=0x");
1797 fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
1799 fprintf (out, "\n");
1802 if (pe_def_file->description)
1804 fprintf (out, "DESCRIPTION ");
1805 quoteput (pe_def_file->description, out, 1);
1806 fprintf (out, "\n");
1809 if (pe_def_file->version_minor != -1)
1810 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1811 pe_def_file->version_minor);
1812 else if (pe_def_file->version_major != -1)
1813 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1815 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1816 fprintf (out, "\n");
1818 if (pe_def_file->stack_commit != -1)
1819 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1820 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1821 else if (pe_def_file->stack_reserve != -1)
1822 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1824 if (pe_def_file->heap_commit != -1)
1825 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1826 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1827 else if (pe_def_file->heap_reserve != -1)
1828 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1830 if (pe_def_file->num_section_defs > 0)
1832 fprintf (out, "\nSECTIONS\n\n");
1834 for (i = 0; i < pe_def_file->num_section_defs; i++)
1837 quoteput (pe_def_file->section_defs[i].name, out, 0);
1839 if (pe_def_file->section_defs[i].class)
1841 fprintf (out, " CLASS ");
1842 quoteput (pe_def_file->section_defs[i].class, out, 0);
1845 if (pe_def_file->section_defs[i].flag_read)
1846 fprintf (out, " READ");
1848 if (pe_def_file->section_defs[i].flag_write)
1849 fprintf (out, " WRITE");
1851 if (pe_def_file->section_defs[i].flag_execute)
1852 fprintf (out, " EXECUTE");
1854 if (pe_def_file->section_defs[i].flag_shared)
1855 fprintf (out, " SHARED");
1857 fprintf (out, "\n");
1861 if (pe_def_file->num_exports > 0)
1863 fprintf (out, "EXPORTS\n");
1865 for (i = 0; i < pe_def_file->num_exports; i++)
1867 def_file_export *e = pe_def_file->exports + i;
1869 quoteput (e->name, out, 0);
1871 if (e->internal_name && strcmp (e->internal_name, e->name))
1873 fprintf (out, " = ");
1874 quoteput (e->internal_name, out, 0);
1877 if (e->ordinal != -1)
1878 fprintf (out, " @%d", e->ordinal);
1880 if (e->flag_private)
1881 fprintf (out, " PRIVATE");
1883 if (e->flag_constant)
1884 fprintf (out, " CONSTANT");
1887 fprintf (out, " NONAME");
1890 fprintf (out, " DATA");
1892 fprintf (out, "\n");
1896 if (pe_def_file->num_imports > 0)
1898 fprintf (out, "\nIMPORTS\n\n");
1900 for (i = 0; i < pe_def_file->num_imports; i++)
1902 def_file_import *im = pe_def_file->imports + i;
1905 if (im->internal_name
1906 && (!im->name || strcmp (im->internal_name, im->name)))
1908 quoteput (im->internal_name, out, 0);
1909 fprintf (out, " = ");
1912 quoteput (im->module->name, out, 0);
1916 quoteput (im->name, out, 0);
1918 fprintf (out, "%d", im->ordinal);
1922 fprintf (out, " == ");
1923 quoteput (im->its_name, out, 0);
1926 fprintf (out, "\n");
1931 fprintf (out, _("; no contents available\n"));
1933 if (fclose (out) == EOF)
1934 /* xgettext:c-format */
1935 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename);
1938 /* Generate the import library. */
1940 static asymbol **symtab;
1943 static const char *dll_filename;
1944 static char *dll_symname;
1946 #define UNDSEC bfd_und_section_ptr
1949 quick_section (bfd *abfd, const char *name, int flags, int align)
1954 sec = bfd_make_section_old_way (abfd, name);
1955 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1956 bfd_set_section_alignment (abfd, sec, align);
1957 /* Remember to undo this before trying to link internally! */
1958 sec->output_section = sec;
1960 sym = bfd_make_empty_symbol (abfd);
1961 symtab[symptr++] = sym;
1962 sym->name = sec->name;
1964 sym->flags = BSF_LOCAL;
1971 quick_symbol (bfd *abfd,
1980 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1985 sym = bfd_make_empty_symbol (abfd);
1990 symtab[symptr++] = sym;
1993 static arelent *reltab = 0;
1994 static int relcount = 0, relsize = 0;
1997 quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
1999 if (relcount >= relsize - 1)
2003 reltab = xrealloc (reltab, relsize * sizeof (arelent));
2005 reltab = xmalloc (relsize * sizeof (arelent));
2007 reltab[relcount].address = address;
2008 reltab[relcount].addend = 0;
2009 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
2010 reltab[relcount].sym_ptr_ptr = symtab + symidx;
2015 save_relocs (asection *sec)
2019 sec->relocation = reltab;
2020 sec->reloc_count = relcount;
2021 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
2022 for (i = 0; i < relcount; i++)
2023 sec->orelocation[i] = sec->relocation + i;
2024 sec->orelocation[relcount] = 0;
2025 sec->flags |= SEC_RELOC;
2027 relcount = relsize = 0;
2030 /* .section .idata$2
2031 .global __head_my_dll
2048 make_head (bfd *parent)
2050 asection *id2, *id5, *id4;
2051 unsigned char *d2, *d5, *d4;
2055 oname = xmalloc (20);
2056 sprintf (oname, "d%06d.o", tmp_seq);
2059 abfd = bfd_create (oname, parent);
2060 bfd_find_target (pe_details->object_target, abfd);
2061 bfd_make_writable (abfd);
2063 bfd_set_format (abfd, bfd_object);
2064 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2067 symtab = xmalloc (6 * sizeof (asymbol *));
2068 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2069 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2070 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2071 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
2072 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2074 /* OK, pay attention here. I got confused myself looking back at
2075 it. We create a four-byte section to mark the beginning of the
2076 list, and we include an offset of 4 in the section, so that the
2077 pointer to the list points to the *end* of this section, which is
2078 the start of the list of sections from other objects. */
2080 bfd_set_section_size (abfd, id2, 20);
2084 if (pe_use_nul_prefixed_import_tables)
2085 d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
2086 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2087 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
2088 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
2091 if (pe_use_nul_prefixed_import_tables)
2092 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2094 bfd_set_section_size (abfd, id5, 0);
2095 d5 = xmalloc (PE_IDATA5_SIZE);
2097 memset (d5, 0, PE_IDATA5_SIZE);
2098 if (pe_use_nul_prefixed_import_tables)
2099 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2101 bfd_set_section_size (abfd, id4, 0);
2102 d4 = xmalloc (PE_IDATA4_SIZE);
2104 memset (d4, 0, PE_IDATA4_SIZE);
2106 bfd_set_symtab (abfd, symtab, symptr);
2108 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2109 if (pe_use_nul_prefixed_import_tables)
2111 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2112 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2116 bfd_set_section_contents (abfd, id5, d5, 0, 0);
2117 bfd_set_section_contents (abfd, id4, d4, 0, 0);
2120 bfd_make_readable (abfd);
2124 /* .section .idata$4
2131 .global __my_dll_iname
2136 make_tail (bfd *parent)
2138 asection *id4, *id5, *id7;
2139 unsigned char *d4, *d5, *d7;
2144 oname = xmalloc (20);
2145 sprintf (oname, "d%06d.o", tmp_seq);
2148 abfd = bfd_create (oname, parent);
2149 bfd_find_target (pe_details->object_target, abfd);
2150 bfd_make_writable (abfd);
2152 bfd_set_format (abfd, bfd_object);
2153 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2156 symtab = xmalloc (5 * sizeof (asymbol *));
2157 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2158 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2159 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2160 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
2162 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2163 d4 = xmalloc (PE_IDATA4_SIZE);
2165 memset (d4, 0, PE_IDATA4_SIZE);
2167 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2168 d5 = xmalloc (PE_IDATA5_SIZE);
2170 memset (d5, 0, PE_IDATA5_SIZE);
2172 len = strlen (dll_filename) + 1;
2175 bfd_set_section_size (abfd, id7, len);
2178 strcpy ((char *) d7, dll_filename);
2179 /* If len was odd, the above
2180 strcpy leaves behind an undefined byte. That is harmless,
2181 but we set it to 0 just so the binary dumps are pretty. */
2184 bfd_set_symtab (abfd, symtab, symptr);
2186 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2187 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2188 bfd_set_section_contents (abfd, id7, d7, 0, len);
2190 bfd_make_readable (abfd);
2196 .global ___imp_function
2197 .global __imp__function
2199 jmp *__imp__function:
2213 .asciz "function" xlate? (add underscore, kill at) */
2215 static const unsigned char jmp_ix86_bytes[] =
2217 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2225 .dw __imp_function */
2227 static const unsigned char jmp_sh_bytes[] =
2229 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2233 lui $t0,<high:__imp_function>
2234 lw $t0,<low:__imp_function>
2238 static const unsigned char jmp_mips_bytes[] =
2240 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2241 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2244 static const unsigned char jmp_arm_bytes[] =
2246 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2247 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2253 make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
2255 asection *tx, *id7, *id5, *id4, *id6;
2256 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
2260 const unsigned char *jmp_bytes = NULL;
2261 int jmp_byte_count = 0;
2263 /* Include the jump stub section only if it is needed. A jump
2264 stub is needed if the symbol being imported <sym> is a function
2265 symbol and there is at least one undefined reference to that
2266 symbol. In other words, if all the import references to <sym> are
2267 explicitly through _declspec(dllimport) then the jump stub is not
2269 if (include_jmp_stub)
2271 switch (pe_details->pe_arch)
2274 jmp_bytes = jmp_ix86_bytes;
2275 jmp_byte_count = sizeof (jmp_ix86_bytes);
2278 jmp_bytes = jmp_sh_bytes;
2279 jmp_byte_count = sizeof (jmp_sh_bytes);
2282 jmp_bytes = jmp_mips_bytes;
2283 jmp_byte_count = sizeof (jmp_mips_bytes);
2286 case PE_ARCH_arm_epoc:
2287 case PE_ARCH_arm_wince:
2288 jmp_bytes = jmp_arm_bytes;
2289 jmp_byte_count = sizeof (jmp_arm_bytes);
2296 oname = xmalloc (20);
2297 sprintf (oname, "d%06d.o", tmp_seq);
2300 abfd = bfd_create (oname, parent);
2301 bfd_find_target (pe_details->object_target, abfd);
2302 bfd_make_writable (abfd);
2304 bfd_set_format (abfd, bfd_object);
2305 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2308 symtab = xmalloc (12 * sizeof (asymbol *));
2310 tx = quick_section (abfd, ".text", SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY, 2);
2311 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2312 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2313 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2314 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
2316 if (*exp->internal_name == '@')
2318 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2320 if (include_jmp_stub)
2321 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
2322 quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
2324 /* Fastcall applies only to functions,
2325 so no need for auto-import symbol. */
2329 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2331 if (include_jmp_stub)
2332 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
2334 quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
2336 /* Symbol to reference ord/name of imported
2337 data symbol, used to implement auto-import. */
2339 quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
2342 if (pe_dll_compat_implib)
2343 quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
2346 if (include_jmp_stub)
2348 bfd_set_section_size (abfd, tx, jmp_byte_count);
2349 td = xmalloc (jmp_byte_count);
2351 memcpy (td, jmp_bytes, jmp_byte_count);
2353 switch (pe_details->pe_arch)
2356 #ifdef pe_use_x86_64
2357 quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
2359 /* Mark this object as SAFESEH compatible. */
2360 quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
2362 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
2366 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2369 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
2370 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
2371 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2374 case PE_ARCH_arm_epoc:
2375 case PE_ARCH_arm_wince:
2376 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2384 bfd_set_section_size (abfd, tx, 0);
2386 bfd_set_section_size (abfd, id7, 4);
2390 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2393 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2394 d5 = xmalloc (PE_IDATA5_SIZE);
2396 memset (d5, 0, PE_IDATA5_SIZE);
2398 if (exp->flag_noname)
2400 d5[0] = exp->ordinal;
2401 d5[1] = exp->ordinal >> 8;
2402 d5[PE_IDATA5_SIZE - 1] = 0x80;
2406 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2410 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2411 d4 = xmalloc (PE_IDATA4_SIZE);
2413 memset (d4, 0, PE_IDATA4_SIZE);
2415 if (exp->flag_noname)
2417 d4[0] = exp->ordinal;
2418 d4[1] = exp->ordinal >> 8;
2419 d4[PE_IDATA4_SIZE - 1] = 0x80;
2423 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2427 if (exp->flag_noname)
2430 bfd_set_section_size (abfd, id6, 0);
2436 /* { short, asciz } */
2438 len = 2 + strlen (exp->its_name) + 1;
2440 len = 2 + strlen (exp->name) + 1;
2443 bfd_set_section_size (abfd, id6, len);
2446 memset (d6, 0, len);
2448 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2449 contains an invalid value (-1). */
2450 ord = (exp->ordinal >= 0) ? exp->ordinal : exp->hint;
2455 strcpy ((char*) d6 + 2, exp->its_name);
2457 strcpy ((char *) d6 + 2, exp->name);
2460 bfd_set_symtab (abfd, symtab, symptr);
2462 if (include_jmp_stub)
2463 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2464 bfd_set_section_contents (abfd, id7, d7, 0, 4);
2465 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2466 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2467 if (!exp->flag_noname)
2468 bfd_set_section_contents (abfd, id6, d6, 0, len);
2470 bfd_make_readable (abfd);
2475 make_singleton_name_thunk (const char *import, bfd *parent)
2477 /* Name thunks go to idata$4. */
2483 oname = xmalloc (20);
2484 sprintf (oname, "nmth%06d.o", tmp_seq);
2487 abfd = bfd_create (oname, parent);
2488 bfd_find_target (pe_details->object_target, abfd);
2489 bfd_make_writable (abfd);
2491 bfd_set_format (abfd, bfd_object);
2492 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2495 symtab = xmalloc (3 * sizeof (asymbol *));
2496 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2497 quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
2498 quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
2500 /* We need space for the real thunk and for the null terminator. */
2501 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2502 d4 = xmalloc (PE_IDATA4_SIZE * 2);
2504 memset (d4, 0, PE_IDATA4_SIZE * 2);
2505 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2508 bfd_set_symtab (abfd, symtab, symptr);
2510 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2512 bfd_make_readable (abfd);
2517 make_import_fixup_mark (arelent *rel, char *name)
2519 /* We convert reloc to symbol, for later reference. */
2520 static unsigned int counter;
2521 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2522 bfd *abfd = bfd_asymbol_bfd (sym);
2523 struct bfd_link_hash_entry *bh;
2524 char *fixup_name, buf[26];
2527 /* "name" buffer has space before the symbol name for prefixes. */
2528 sprintf (buf, "__fu%d_", counter++);
2529 prefix_len = strlen (buf);
2530 fixup_name = name - prefix_len;
2531 memcpy (fixup_name, buf, prefix_len);
2534 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2535 current_sec, /* sym->section, */
2536 rel->address, NULL, TRUE, FALSE, &bh);
2538 return bh->root.string;
2541 /* .section .idata$2
2542 .rva __nm_thnk_SYM (singleton thunk with name of func)
2545 .rva __my_dll_iname (name of dll)
2546 .rva __fuNN_SYM (pointer to reference (address) in text) */
2549 make_import_fixup_entry (const char *name,
2550 const char *fixup_name,
2551 const char *symname,
2559 oname = xmalloc (20);
2560 sprintf (oname, "fu%06d.o", tmp_seq);
2563 abfd = bfd_create (oname, parent);
2564 bfd_find_target (pe_details->object_target, abfd);
2565 bfd_make_writable (abfd);
2567 bfd_set_format (abfd, bfd_object);
2568 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2571 symtab = xmalloc (6 * sizeof (asymbol *));
2572 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2574 quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
2575 quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2576 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2578 bfd_set_section_size (abfd, id2, 20);
2583 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2584 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2585 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2588 bfd_set_symtab (abfd, symtab, symptr);
2590 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2592 bfd_make_readable (abfd);
2596 /* .section .rdata_runtime_pseudo_reloc
2598 .rva __fuNN_SYM (pointer to reference (address) in text) */
2601 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2602 const char *fixup_name,
2603 bfd_vma addend ATTRIBUTE_UNUSED,
2608 unsigned char *rt_rel_d;
2613 oname = xmalloc (20);
2614 sprintf (oname, "rtr%06d.o", tmp_seq);
2617 abfd = bfd_create (oname, parent);
2618 bfd_find_target (pe_details->object_target, abfd);
2619 bfd_make_writable (abfd);
2621 bfd_set_format (abfd, bfd_object);
2622 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2624 if (link_info.pei386_runtime_pseudo_reloc == 2)
2626 if (runtime_pseudp_reloc_v2_init)
2627 size = 3 * sizeof (asymbol *);
2629 size = 6 * sizeof (asymbol *);
2632 size = 2 * sizeof (asymbol *);
2635 symtab = xmalloc (size);
2638 = quick_section (abfd, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS, 2);
2640 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2642 if (link_info.pei386_runtime_pseudo_reloc == 2)
2645 if (!runtime_pseudp_reloc_v2_init)
2648 runtime_pseudp_reloc_v2_init = TRUE;
2651 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2653 bfd_set_section_size (abfd, rt_rel, size);
2654 rt_rel_d = xmalloc (size);
2655 rt_rel->contents = rt_rel_d;
2656 memset (rt_rel_d, 0, size);
2657 quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
2658 quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
2659 bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
2661 bfd_put_32 (abfd, 1, rt_rel_d + 8);
2662 save_relocs (rt_rel);
2664 bfd_set_symtab (abfd, symtab, symptr);
2666 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
2670 bfd_set_section_size (abfd, rt_rel, 8);
2671 rt_rel_d = xmalloc (8);
2672 rt_rel->contents = rt_rel_d;
2673 memset (rt_rel_d, 0, 8);
2675 bfd_put_32 (abfd, addend, rt_rel_d);
2676 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2678 save_relocs (rt_rel);
2680 bfd_set_symtab (abfd, symtab, symptr);
2682 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2685 bfd_make_readable (abfd);
2690 .rva __pei386_runtime_relocator */
2693 pe_create_runtime_relocator_reference (bfd *parent)
2695 asection *extern_rt_rel;
2696 unsigned char *extern_rt_rel_d;
2700 oname = xmalloc (20);
2701 sprintf (oname, "ertr%06d.o", tmp_seq);
2704 abfd = bfd_create (oname, parent);
2705 bfd_find_target (pe_details->object_target, abfd);
2706 bfd_make_writable (abfd);
2708 bfd_set_format (abfd, bfd_object);
2709 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2712 symtab = xmalloc (2 * sizeof (asymbol *));
2713 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2715 quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2718 bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
2719 extern_rt_rel_d = xcalloc (1, PE_IDATA5_SIZE);
2720 extern_rt_rel->contents = extern_rt_rel_d;
2722 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2723 save_relocs (extern_rt_rel);
2725 bfd_set_symtab (abfd, symtab, symptr);
2727 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
2729 bfd_make_readable (abfd);
2734 pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend, char *name,
2735 const char *symname)
2737 const char *fixup_name = make_import_fixup_mark (rel, name);
2740 /* This is the original implementation of the auto-import feature, which
2741 primarily relied on the OS loader to patch things up with some help
2742 from the pseudo-relocator to overcome the main limitation. See the
2743 comment at the beginning of the file for an overview of the feature. */
2744 if (link_info.pei386_runtime_pseudo_reloc != 2)
2746 struct bfd_link_hash_entry *name_thunk_sym;
2747 /* name buffer is allocated with space at beginning for prefixes. */
2748 char *thname = name - (sizeof "__nm_thnk_" - 1);
2749 memcpy (thname, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2750 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, thname, 0, 0, 1);
2752 if (!(name_thunk_sym && name_thunk_sym->type == bfd_link_hash_defined))
2754 b = make_singleton_name_thunk (name, link_info.output_bfd);
2755 add_bfd_to_link (b, b->filename, &link_info);
2757 /* If we ever use autoimport, we have to cast text section writable. */
2758 config.text_read_only = FALSE;
2759 link_info.output_bfd->flags &= ~WP_TEXT;
2762 if (addend == 0 || link_info.pei386_runtime_pseudo_reloc == 1)
2764 b = make_import_fixup_entry (name, fixup_name, symname,
2765 link_info.output_bfd);
2766 add_bfd_to_link (b, b->filename, &link_info);
2770 /* In the original implementation, the pseudo-relocator was only used when
2771 the addend was not null. In the new implementation, the OS loader is
2772 completely bypassed and the pseudo-relocator does the entire work. */
2773 if ((addend != 0 && link_info.pei386_runtime_pseudo_reloc == 1)
2774 || link_info.pei386_runtime_pseudo_reloc == 2)
2776 if (pe_dll_extra_pe_debug)
2777 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2778 fixup_name, (int) addend);
2780 b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
2781 link_info.output_bfd);
2782 add_bfd_to_link (b, b->filename, &link_info);
2784 if (runtime_pseudo_relocs_created++ == 0)
2786 b = pe_create_runtime_relocator_reference (link_info.output_bfd);
2787 add_bfd_to_link (b, b->filename, &link_info);
2791 else if (addend != 0)
2792 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2793 s->owner, s, rel->address, (*rel->sym_ptr_ptr)->name);
2797 pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
2806 dll_filename = (def->name) ? def->name : dll_name;
2807 dll_symname = xstrdup (dll_filename);
2808 for (i = 0; dll_symname[i]; i++)
2809 if (!ISALNUM (dll_symname[i]))
2810 dll_symname[i] = '_';
2812 unlink_if_ordinary (impfilename);
2814 outarch = bfd_openw (impfilename, 0);
2818 /* xgettext:c-format */
2819 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename);
2824 /* xgettext:c-format */
2825 info_msg (_("Creating library file: %s\n"), impfilename);
2827 bfd_set_format (outarch, bfd_archive);
2828 outarch->has_armap = 1;
2830 /* Work out a reasonable size of things to put onto one line. */
2831 ar_head = make_head (outarch);
2833 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2834 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
2836 /* Iterate the exclude list. */
2837 struct exclude_list_struct *ex;
2839 for (ex = excludes, found = 0; ex && !found; ex = ex->next)
2841 if (ex->type != EXCLUDEFORIMPLIB)
2843 found = (filename_cmp (ex->string, ibfd->filename) == 0);
2845 /* If it matched, we must open a fresh BFD for it (the original
2846 input BFD is still needed for the DLL's final link) and add
2847 it into the archive member chain. */
2850 bfd *newbfd = bfd_openr (ibfd->my_archive
2851 ? ibfd->my_archive->filename : ibfd->filename, NULL);
2854 einfo (_("%X%P: bfd_openr %s: %E\n"), ibfd->filename);
2857 if (ibfd->my_archive)
2859 /* Must now iterate through archive until we find the
2860 required member. A minor shame that we'll open the
2861 archive once per member that we require from it, and
2862 leak those archive bfds rather than reuse them. */
2863 bfd *arbfd = newbfd;
2864 if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
2866 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2867 ibfd->my_archive->filename, ibfd->filename);
2871 while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
2873 if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
2878 einfo (_("%X%P: %s(%s): can't find member in archive"),
2879 ibfd->my_archive->filename, ibfd->filename);
2883 newbfd->archive_next = head;
2888 for (i = 0; i < def->num_exports; i++)
2890 /* The import library doesn't know about the internal name. */
2891 char *internal = def->exports[i].internal_name;
2894 /* Don't add PRIVATE entries to import lib. */
2895 if (pe_def_file->exports[i].flag_private)
2898 def->exports[i].internal_name = def->exports[i].name;
2900 /* PR 19803: If a symbol has been discard due to garbage
2901 collection then do not create any exports for it. */
2903 struct coff_link_hash_entry *h;
2905 h = coff_link_hash_lookup (coff_hash_table (info), internal,
2906 FALSE, FALSE, FALSE);
2908 /* If the symbol is hidden and undefined then it
2909 has been swept up by garbage collection. */
2910 && h->symbol_class == C_HIDDEN
2911 && h->root.u.def.section == bfd_und_section_ptr)
2914 /* If necessary, check with an underscore prefix as well. */
2915 if (pe_details->underscored && internal[0] != '@')
2919 name = xmalloc (strlen (internal) + 2);
2920 sprintf (name, "_%s", internal);
2922 h = coff_link_hash_lookup (coff_hash_table (info), name,
2923 FALSE, FALSE, FALSE);
2927 /* If the symbol is hidden and undefined then it
2928 has been swept up by garbage collection. */
2929 && h->symbol_class == C_HIDDEN
2930 && h->root.u.def.section == bfd_und_section_ptr)
2935 n = make_one (def->exports + i, outarch,
2936 ! (def->exports + i)->flag_data);
2937 n->archive_next = head;
2939 def->exports[i].internal_name = internal;
2942 ar_tail = make_tail (outarch);
2944 if (ar_head == NULL || ar_tail == NULL)
2947 /* Now stick them all into the archive. */
2948 ar_head->archive_next = head;
2949 ar_tail->archive_next = ar_head;
2952 if (! bfd_set_archive_head (outarch, head))
2953 einfo ("%X%P: bfd_set_archive_head: %E\n");
2955 if (! bfd_close (outarch))
2956 einfo ("%X%P: bfd_close %s: %E\n", impfilename);
2958 while (head != NULL)
2960 bfd *n = head->archive_next;
2966 static int undef_count = 0;
2974 static struct key_value *udef_table;
2976 static int undef_sort_cmp (const void *l1, const void *r1)
2978 const struct key_value *l = l1;
2979 const struct key_value *r = r1;
2981 return strcmp (l->key, r->key);
2984 static struct bfd_link_hash_entry *
2985 pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
2987 struct bfd_link_hash_entry *h = NULL;
2988 struct key_value *kv;
2989 struct key_value key;
2990 char *at, *lname = xmalloc (strlen (name) + 3);
2992 strcpy (lname, name);
2994 at = strchr (lname + (lname[0] == '@'), '@');
2999 kv = bsearch (&key, udef_table, undef_count, sizeof (struct key_value),
3004 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3005 if (h->type == bfd_link_hash_undefined)
3009 if (lname[0] == '?')
3012 if (at || lname[0] == '@')
3014 if (lname[0] == '@')
3016 if (pe_details->underscored)
3019 strcpy (lname, lname + 1);
3021 kv = bsearch (&key, udef_table, undef_count,
3022 sizeof (struct key_value), undef_sort_cmp);
3025 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3026 if (h->type == bfd_link_hash_undefined)
3031 *strchr (lname, '@') = 0;
3033 kv = bsearch (&key, udef_table, undef_count,
3034 sizeof (struct key_value), undef_sort_cmp);
3037 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3038 if (h->type == bfd_link_hash_undefined)
3044 strcat (lname, "@");
3046 kv = bsearch (&key, udef_table, undef_count,
3047 sizeof (struct key_value), undef_sort_cmp);
3051 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3052 if (h->type == bfd_link_hash_undefined)
3056 if (lname[0] == '_' && pe_details->underscored)
3060 memmove (lname + 1, lname, strlen (lname) + 1);
3065 kv = bsearch (&key, udef_table, undef_count,
3066 sizeof (struct key_value), undef_sort_cmp);
3070 h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3071 if (h->type == bfd_link_hash_undefined)
3083 pe_undef_count (struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
3084 void *inf ATTRIBUTE_UNUSED)
3086 if (h->type == bfd_link_hash_undefined)
3092 pe_undef_fill (struct bfd_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
3094 if (h->type == bfd_link_hash_undefined)
3098 udef_table[undef_count].key = xstrdup (h->root.string);
3099 at = strchr (udef_table[undef_count].key
3100 + (udef_table[undef_count].key[0] == '@'), '@');
3103 udef_table[undef_count].oname = h->root.string;
3110 pe_create_undef_table (void)
3114 /* count undefined symbols */
3116 bfd_link_hash_traverse (link_info.hash, pe_undef_count, "");
3118 /* create and fill the corresponding table */
3119 udef_table = xmalloc (undef_count * sizeof (struct key_value));
3122 bfd_link_hash_traverse (link_info.hash, pe_undef_fill, "");
3125 qsort (udef_table, undef_count, sizeof (struct key_value), undef_sort_cmp);
3129 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
3131 lang_input_statement_type *fake_file;
3133 fake_file = lang_add_input_file (name,
3134 lang_input_file_is_fake_enum,
3136 fake_file->the_bfd = abfd;
3137 ldlang_add_file (fake_file);
3139 if (!bfd_link_add_symbols (abfd, linfo))
3140 einfo (_("%X%P: add symbols %s: %E\n"), name);
3144 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
3147 def_file_module *module;
3148 def_file_import *imp;
3150 pe_dll_id_target (bfd_get_target (output_bfd));
3155 imp = pe_def_file->imports;
3157 pe_create_undef_table ();
3159 for (module = pe_def_file->modules; module; module = module->next)
3161 int do_this_dll = 0;
3163 for (i = 0; i < pe_def_file->num_imports && imp[i].module != module; i++)
3165 if (i >= pe_def_file->num_imports)
3168 dll_filename = module->name;
3169 dll_symname = xstrdup (module->name);
3170 for (j = 0; dll_symname[j]; j++)
3171 if (!ISALNUM (dll_symname[j]))
3172 dll_symname[j] = '_';
3174 for (; i < pe_def_file->num_imports && imp[i].module == module; i++)
3176 def_file_export exp;
3177 struct bfd_link_hash_entry *blhe;
3178 int lead_at = (*imp[i].internal_name == '@');
3179 /* See if we need this import. */
3180 size_t len = strlen (imp[i].internal_name);
3181 char *name = xmalloc (len + 2 + 6);
3182 bfd_boolean include_jmp_stub = FALSE;
3183 bfd_boolean is_cdecl = FALSE;
3184 bfd_boolean is_undef = FALSE;
3186 if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
3190 sprintf (name, "%s", imp[i].internal_name);
3192 sprintf (name, "%s%s",U (""), imp[i].internal_name);
3194 blhe = bfd_link_hash_lookup (linfo->hash, name,
3195 FALSE, FALSE, FALSE);
3197 /* Include the jump stub for <sym> only if the <sym>
3199 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
3202 sprintf (name, "%s%s", "__imp_", imp[i].internal_name);
3204 sprintf (name, "%s%s%s", "__imp_", U (""),
3205 imp[i].internal_name);
3207 blhe = bfd_link_hash_lookup (linfo->hash, name,
3208 FALSE, FALSE, FALSE);
3210 is_undef = (blhe->type == bfd_link_hash_undefined);
3214 include_jmp_stub = TRUE;
3215 is_undef = (blhe->type == bfd_link_hash_undefined);
3218 if (is_cdecl && (!blhe || (blhe && blhe->type != bfd_link_hash_undefined)))
3220 sprintf (name, "%s%s",U (""), imp[i].internal_name);
3221 blhe = pe_find_cdecl_alias_match (linfo, name);
3222 include_jmp_stub = TRUE;
3224 is_undef = (blhe->type == bfd_link_hash_undefined);
3235 bfd *ar_head = make_head (output_bfd);
3236 add_bfd_to_link (ar_head, ar_head->filename, linfo);
3239 exp.internal_name = imp[i].internal_name;
3240 exp.name = imp[i].name;
3241 exp.its_name = imp[i].its_name;
3242 exp.ordinal = imp[i].ordinal;
3243 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
3244 exp.flag_private = 0;
3245 exp.flag_constant = 0;
3246 exp.flag_data = imp[i].data;
3247 exp.flag_noname = exp.name ? 0 : 1;
3248 one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
3249 add_bfd_to_link (one, one->filename, linfo);
3254 bfd *ar_tail = make_tail (output_bfd);
3255 add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
3264 free (udef_table[undef_count].key);
3269 /* We were handed a *.DLL file. Parse it and turn it into a set of
3270 IMPORTS directives in the def file. Return TRUE if the file was
3271 handled, FALSE if not. */
3274 pe_get16 (bfd *abfd, int where)
3278 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
3279 bfd_bread (b, (bfd_size_type) 2, abfd);
3280 return b[0] + (b[1] << 8);
3284 pe_get32 (bfd *abfd, int where)
3288 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
3289 bfd_bread (b, (bfd_size_type) 4, abfd);
3290 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
3296 unsigned char *b = ptr;
3298 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
3302 pe_implied_import_dll (const char *filename)
3305 bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
3306 bfd_vma export_rva, export_size, nsections, secptr, expptr;
3307 bfd_vma exp_funcbase;
3308 unsigned char *expdata;
3310 bfd_vma name_rvas, nexp;
3311 const char *dllname;
3312 /* Initialization with start > end guarantees that is_data
3313 will not be set by mistake, and avoids compiler warning. */
3314 bfd_vma data_start = 1;
3315 bfd_vma data_end = 0;
3316 bfd_vma rdata_start = 1;
3317 bfd_vma rdata_end = 0;
3318 bfd_vma bss_start = 1;
3319 bfd_vma bss_end = 0;
3322 /* No, I can't use bfd here. kernel32.dll puts its export table in
3323 the middle of the .rdata section. */
3324 dll = bfd_openr (filename, pe_details->target_name);
3327 einfo (_("%X%P: open %s: %E\n"), filename);
3331 /* PEI dlls seem to be bfd_objects. */
3332 if (!bfd_check_format (dll, bfd_object))
3334 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename);
3338 /* Get pe_header, optional header and numbers of directory entries. */
3339 pe_header_offset = pe_get32 (dll, 0x3c);
3340 opthdr_ofs = pe_header_offset + 4 + 20;
3341 #ifdef pe_use_x86_64
3342 num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3344 num_entries = pe_get32 (dll, opthdr_ofs + 92);
3347 /* No import or export directory entry. */
3348 if (num_entries < 1)
3351 #ifdef pe_use_x86_64
3352 export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
3353 export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
3355 export_rva = pe_get32 (dll, opthdr_ofs + 96);
3356 export_size = pe_get32 (dll, opthdr_ofs + 100);
3359 /* No export table - nothing to export. */
3360 if (export_size == 0)
3363 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
3364 secptr = (pe_header_offset + 4 + 20 +
3365 pe_get16 (dll, pe_header_offset + 4 + 16));
3368 /* Get the rva and size of the export section. */
3369 for (i = 0; i < nsections; i++)
3372 bfd_vma secptr1 = secptr + 40 * i;
3373 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3374 bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
3375 bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
3377 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
3378 bfd_bread (sname, (bfd_size_type) 8, dll);
3380 if (vaddr <= export_rva && vaddr + vsize > export_rva)
3382 expptr = fptr + (export_rva - vaddr);
3383 if (export_rva + export_size > vaddr + vsize)
3384 export_size = vsize - (export_rva - vaddr);
3389 /* Scan sections and store the base and size of the
3390 data and bss segments in data/base_start/end. */
3391 for (i = 0; i < nsections; i++)
3393 bfd_vma secptr1 = secptr + 40 * i;
3394 bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
3395 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3396 bfd_vma flags = pe_get32 (dll, secptr1 + 36);
3400 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
3401 bfd_bread (sec_name, (bfd_size_type) 8, dll);
3403 if (strcmp(sec_name,".data") == 0)
3406 data_end = vaddr + vsize;
3408 if (pe_dll_extra_pe_debug)
3409 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3410 __FUNCTION__, sec_name, (unsigned long) vaddr,
3411 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3413 else if (strcmp(sec_name,".rdata") == 0)
3415 rdata_start = vaddr;
3416 rdata_end = vaddr + vsize;
3418 if (pe_dll_extra_pe_debug)
3419 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3420 __FUNCTION__, sec_name, (unsigned long) vaddr,
3421 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3423 else if (strcmp (sec_name,".bss") == 0)
3426 bss_end = vaddr + vsize;
3428 if (pe_dll_extra_pe_debug)
3429 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3430 __FUNCTION__, sec_name, (unsigned long) vaddr,
3431 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3435 expdata = xmalloc (export_size);
3436 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
3437 bfd_bread (expdata, (bfd_size_type) export_size, dll);
3438 erva = (char *) expdata - export_rva;
3440 if (pe_def_file == 0)
3441 pe_def_file = def_file_empty ();
3443 nexp = pe_as32 (expdata + 24);
3444 name_rvas = pe_as32 (expdata + 32);
3445 exp_funcbase = pe_as32 (expdata + 28);
3447 /* Use internal dll name instead of filename
3448 to enable symbolic dll linking. */
3449 dllname = erva + pe_as32 (expdata + 12);
3451 /* Check to see if the dll has already been added to
3452 the definition list and if so return without error.
3453 This avoids multiple symbol definitions. */
3454 if (def_get_module (pe_def_file, dllname))
3456 if (pe_dll_extra_pe_debug)
3457 printf ("%s is already loaded\n", dllname);
3461 /* This is an optimized version of the insertion loop, which avoids lots of
3462 calls to realloc and memmove from def_file_add_import. */
3463 if ((from = def_file_add_import_from (pe_def_file, nexp,
3464 erva + pe_as32 (erva + name_rvas),
3465 dllname, 0, NULL, NULL)) >= 0)
3467 for (i = 0; i < nexp; i++)
3469 /* Pointer to the names vector. */
3470 bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3471 def_file_import *imp;
3472 /* Pointer to the function address vector. */
3473 bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3474 /* is_data is true if the address is in the data, rdata or bss
3477 (func_rva >= data_start && func_rva < data_end)
3478 || (func_rva >= rdata_start && func_rva < rdata_end)
3479 || (func_rva >= bss_start && func_rva < bss_end);
3481 imp = def_file_add_import_at (pe_def_file, from + i, erva + name_rva,
3482 dllname, i, NULL, NULL);
3483 /* Mark symbol type. */
3484 imp->data = is_data;
3486 if (pe_dll_extra_pe_debug)
3487 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3488 __FUNCTION__, dllname, erva + name_rva,
3489 (unsigned long) func_rva, is_data ? "(data)" : "");
3495 /* Iterate through the list of symbols. */
3496 for (i = 0; i < nexp; i++)
3498 /* Pointer to the names vector. */
3499 bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3500 def_file_import *imp;
3501 /* Pointer to the function address vector. */
3502 bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3505 /* Skip unwanted symbols, which are
3506 exported in buggy auto-import releases. */
3507 if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
3510 /* is_data is true if the address is in the data, rdata or bss
3513 (func_rva >= data_start && func_rva < data_end)
3514 || (func_rva >= rdata_start && func_rva < rdata_end)
3515 || (func_rva >= bss_start && func_rva < bss_end);
3517 imp = def_file_add_import (pe_def_file, erva + name_rva,
3518 dllname, i, NULL, NULL, &is_dup);
3519 /* Mark symbol type. */
3521 imp->data = is_data;
3523 if (pe_dll_extra_pe_debug)
3524 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3525 __FUNCTION__, dllname, erva + name_rva,
3526 (unsigned long) func_rva, is_data ? "(data)" : "");
3534 pe_output_file_set_long_section_names (bfd *abfd)
3536 if (pe_use_coff_long_section_names < 0)
3538 if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
3539 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3542 /* These are the main functions, called from the emulation. The first
3543 is called after the bfds are read, so we can guess at how much space
3544 we need. The second is called after everything is placed, so we
3545 can put the right values in place. */
3548 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
3550 pe_dll_id_target (bfd_get_target (abfd));
3551 pe_output_file_set_long_section_names (abfd);
3552 process_def_file_and_drectve (abfd, info);
3554 if (pe_def_file->num_exports == 0 && !bfd_link_pic (info))
3557 generate_edata (abfd, info);
3558 build_filler_bfd (1);
3559 pe_output_file_set_long_section_names (filler_bfd);
3563 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3565 pe_dll_id_target (bfd_get_target (abfd));
3566 pe_output_file_set_long_section_names (abfd);
3567 build_filler_bfd (0);
3568 pe_output_file_set_long_section_names (filler_bfd);
3572 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
3574 pe_dll_id_target (bfd_get_target (abfd));
3575 pe_output_file_set_long_section_names (abfd);
3576 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3578 generate_reloc (abfd, info);
3581 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3583 /* Resize the sections. */
3584 lang_reset_memory_regions ();
3585 lang_size_sections (NULL, TRUE);
3587 /* Redo special stuff. */
3588 ldemul_after_allocation ();
3590 /* Do the assignments again. */
3591 lang_do_assignments (lang_final_phase_enum);
3594 fill_edata (abfd, info);
3596 if (bfd_link_dll (info))
3597 pe_data (abfd)->dll = 1;
3599 edata_s->contents = edata_d;
3600 reloc_s->contents = reloc_d;
3604 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
3606 pe_dll_id_target (bfd_get_target (abfd));
3607 pe_output_file_set_long_section_names (abfd);
3608 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3610 generate_reloc (abfd, info);
3613 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3615 /* Resize the sections. */
3616 lang_reset_memory_regions ();
3617 lang_size_sections (NULL, TRUE);
3619 /* Redo special stuff. */
3620 ldemul_after_allocation ();
3622 /* Do the assignments again. */
3623 lang_do_assignments (lang_final_phase_enum);
3625 reloc_s->contents = reloc_d;
3629 pe_bfd_is_dll (bfd *abfd)
3631 return (bfd_get_format (abfd) == bfd_object
3633 && pe_data (abfd)->dll);