1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008 Free Software Foundation, Inc.
4 Written by DJ Delorie <dj@cygnus.com>
6 This file is part of the GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 #include "libiberty.h"
27 #include "safe-ctype.h"
40 #include "coff/internal.h"
41 #include "../bfd/libcoff.h"
46 #define PE_IDATA4_SIZE 8
47 #define PE_IDATA5_SIZE 8
50 #define AOUTSZ PEPAOUTSZ
51 #define PEAOUTHDR PEPAOUTHDR
59 #ifndef PE_IDATA4_SIZE
60 #define PE_IDATA4_SIZE 4
63 #ifndef PE_IDATA5_SIZE
64 #define PE_IDATA5_SIZE 4
67 /* This file turns a regular Windows PE image into a DLL. Because of
68 the complexity of this operation, it has been broken down into a
69 number of separate modules which are all called by the main function
70 at the end of this file. This function is not re-entrant and is
71 normally only called once, so static variables are used to reduce
72 the number of parameters and return values required.
74 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
76 /* Auto-import feature by Paul Sokolovsky
80 1. With this feature on, DLL clients can import variables from DLL
81 without any concern from their side (for example, without any source
84 2. This is done completely in bounds of the PE specification (to be fair,
85 there's a place where it pokes nose out of, but in practice it works).
86 So, resulting module can be used with any other PE compiler/linker.
88 3. Auto-import is fully compatible with standard import method and they
89 can be mixed together.
91 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
92 reference to it; load time: negligible; virtual/physical memory: should be
93 less than effect of DLL relocation, and I sincerely hope it doesn't affect
94 DLL sharability (too much).
98 The obvious and only way to get rid of dllimport insanity is to make client
99 access variable directly in the DLL, bypassing extra dereference. I.e.,
100 whenever client contains something like
104 address of dll_var in the command should be relocated to point into loaded
105 DLL. The aim is to make OS loader do so, and than make ld help with that.
106 Import section of PE made following way: there's a vector of structures
107 each describing imports from particular DLL. Each such structure points
108 to two other parallel vectors: one holding imported names, and one which
109 will hold address of corresponding imported name. So, the solution is
110 de-vectorize these structures, making import locations be sparse and
111 pointing directly into code. Before continuing, it is worth a note that,
112 while authors strives to make PE act ELF-like, there're some other people
113 make ELF act PE-like: elfvector, ;-) .
117 For each reference of data symbol to be imported from DLL (to set of which
118 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
119 import fixup entry is generated. That entry is of type
120 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
121 fixup entry contains pointer to symbol's address within .text section
122 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
123 (so, DLL name is referenced by multiple entries), and pointer to symbol
124 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
125 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
126 containing imported name. Here comes that "on the edge" problem mentioned
127 above: PE specification rambles that name vector (OriginalFirstThunk)
128 should run in parallel with addresses vector (FirstThunk), i.e. that they
129 should have same number of elements and terminated with zero. We violate
130 this, since FirstThunk points directly into machine code. But in practice,
131 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
132 puts addresses to FirstThunk, not something else. It once again should be
133 noted that dll and symbol name structures are reused across fixup entries
134 and should be there anyway to support standard import stuff, so sustained
135 overhead is 20 bytes per reference. Other question is whether having several
136 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
137 done even by native compiler/linker (libth32's functions are in fact reside
138 in windows9x kernel32.dll, so if you use it, you have two
139 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
140 referencing the same PE structures several times is valid. The answer is why
141 not, prohibiting that (detecting violation) would require more work on
142 behalf of loader than not doing it.
144 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
146 static void add_bfd_to_link (bfd *, const char *, struct bfd_link_info *);
148 /* For emultempl/pe.em. */
150 def_file * pe_def_file = 0;
151 int pe_dll_export_everything = 0;
152 int pe_dll_do_default_excludes = 1;
153 int pe_dll_kill_ats = 0;
154 int pe_dll_stdcall_aliases = 0;
155 int pe_dll_warn_dup_exports = 0;
156 int pe_dll_compat_implib = 0;
157 int pe_dll_extra_pe_debug = 0;
159 /* Static variables and types. */
161 static bfd_vma image_base;
162 static bfd *filler_bfd;
163 static struct bfd_section *edata_s, *reloc_s;
164 static unsigned char *edata_d, *reloc_d;
165 static size_t edata_sz, reloc_sz;
166 static int runtime_pseudo_relocs_created = 0;
167 static int runtime_pseudp_reloc_v2_init = 0;
174 autofilter_entry_type;
178 const char *target_name;
179 const char *object_target;
180 unsigned int imagebase_reloc;
183 bfd_boolean underscored;
184 const autofilter_entry_type* autofilter_symbollist;
188 static const autofilter_entry_type autofilter_symbollist_generic[] =
190 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
191 /* Entry point symbols. */
192 { STRING_COMMA_LEN ("DllMain") },
193 { STRING_COMMA_LEN ("DllMainCRTStartup") },
194 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
195 /* Runtime pseudo-reloc. */
196 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
197 { STRING_COMMA_LEN ("do_pseudo_reloc") },
201 static const autofilter_entry_type autofilter_symbollist_i386[] =
203 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
204 /* Entry point symbols, and entry hooks. */
205 { STRING_COMMA_LEN ("cygwin_crt0") },
207 { STRING_COMMA_LEN ("DllMain") },
208 { STRING_COMMA_LEN ("DllEntryPoint") },
209 { STRING_COMMA_LEN ("DllMainCRTStartup") },
210 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
211 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
212 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
214 { STRING_COMMA_LEN ("DllMain@12") },
215 { STRING_COMMA_LEN ("DllEntryPoint@0") },
216 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
217 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
218 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
219 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
220 { STRING_COMMA_LEN ("cygwin_attach_dll") },
222 { STRING_COMMA_LEN ("cygwin_premain0") },
223 { STRING_COMMA_LEN ("cygwin_premain1") },
224 { STRING_COMMA_LEN ("cygwin_premain2") },
225 { STRING_COMMA_LEN ("cygwin_premain3") },
226 /* Runtime pseudo-reloc. */
227 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
228 { STRING_COMMA_LEN ("do_pseudo_reloc") },
229 /* Global vars that should not be exported. */
230 { STRING_COMMA_LEN ("impure_ptr") },
231 { STRING_COMMA_LEN ("_impure_ptr") },
232 { STRING_COMMA_LEN ("_fmode") },
233 { STRING_COMMA_LEN ("environ") },
237 #define PE_ARCH_i386 1
239 #define PE_ARCH_mips 3
240 #define PE_ARCH_arm 4
241 #define PE_ARCH_arm_epoc 5
242 #define PE_ARCH_arm_wince 6
244 static const pe_details_type pe_detail_list[] =
259 autofilter_symbollist_i386
264 16 /* R_SH_IMAGEBASE */,
268 autofilter_symbollist_generic
277 autofilter_symbollist_generic
286 autofilter_symbollist_generic
289 "epoc-pei-arm-little",
290 "epoc-pe-arm-little",
295 autofilter_symbollist_generic
298 "pei-arm-wince-little",
299 "pe-arm-wince-little",
300 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
304 autofilter_symbollist_generic
306 { NULL, NULL, 0, 0, 0, FALSE, NULL }
309 static const pe_details_type *pe_details;
311 /* Do not specify library suffix explicitly, to allow for dllized versions. */
312 static const autofilter_entry_type autofilter_liblist[] =
314 { STRING_COMMA_LEN ("libcegcc") },
315 { STRING_COMMA_LEN ("libcygwin") },
316 { STRING_COMMA_LEN ("libgcc") },
317 { STRING_COMMA_LEN ("libgcc_s") },
318 { STRING_COMMA_LEN ("libstdc++") },
319 { STRING_COMMA_LEN ("libmingw32") },
320 { STRING_COMMA_LEN ("libmingwex") },
321 { STRING_COMMA_LEN ("libg2c") },
322 { STRING_COMMA_LEN ("libsupc++") },
323 { STRING_COMMA_LEN ("libobjc") },
324 { STRING_COMMA_LEN ("libgcj") },
328 /* Regardless of the suffix issue mentioned above, we must ensure that
329 we do not falsely match on a leading substring, such as when libtool
330 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
331 This routine ensures that the leading part of the name matches and that
332 it is followed by only an optional version suffix and a file extension,
333 returning zero if so or -1 if not. */
334 static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
336 if (strncmp (libname, afptr->name, afptr->len))
339 libname += afptr->len;
341 /* Be liberal in interpreting what counts as a version suffix; we
342 accept anything that has a dash to separate it from the name and
343 begins with a digit. */
344 if (libname[0] == '-')
346 if (!ISDIGIT (*++libname))
348 /* Ensure the filename has an extension. */
349 while (*++libname != '.')
353 else if (libname[0] != '.')
359 static const autofilter_entry_type autofilter_objlist[] =
361 { STRING_COMMA_LEN ("crt0.o") },
362 { STRING_COMMA_LEN ("crt1.o") },
363 { STRING_COMMA_LEN ("crt2.o") },
364 { STRING_COMMA_LEN ("dllcrt1.o") },
365 { STRING_COMMA_LEN ("dllcrt2.o") },
366 { STRING_COMMA_LEN ("gcrt0.o") },
367 { STRING_COMMA_LEN ("gcrt1.o") },
368 { STRING_COMMA_LEN ("gcrt2.o") },
369 { STRING_COMMA_LEN ("crtbegin.o") },
370 { STRING_COMMA_LEN ("crtend.o") },
374 static const autofilter_entry_type autofilter_symbolprefixlist[] =
376 /* _imp_ is treated specially, as it is always underscored. */
377 /* { STRING_COMMA_LEN ("_imp_") }, */
378 /* Don't export some c++ symbols. */
379 { STRING_COMMA_LEN ("__rtti_") },
380 { STRING_COMMA_LEN ("__builtin_") },
381 /* Don't re-export auto-imported symbols. */
382 { STRING_COMMA_LEN ("_nm_") },
383 /* Don't export symbols specifying internal DLL layout. */
384 { STRING_COMMA_LEN ("_head_") },
385 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
386 /* Don't export section labels or artificial symbols
388 { STRING_COMMA_LEN (".") },
392 static const autofilter_entry_type autofilter_symbolsuffixlist[] =
394 { STRING_COMMA_LEN ("_iname") },
395 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
399 #define U(str) (pe_details->underscored ? "_" str : str)
402 pe_dll_id_target (const char *target)
406 for (i = 0; pe_detail_list[i].target_name; i++)
407 if (strcmp (pe_detail_list[i].target_name, target) == 0
408 || strcmp (pe_detail_list[i].object_target, target) == 0)
410 pe_details = pe_detail_list + i;
413 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
417 /* Helper functions for qsort. Relocs must be sorted so that we can write
418 them out by pages. */
429 reloc_sort (const void *va, const void *vb)
431 bfd_vma a = ((const reloc_data_type *) va)->vma;
432 bfd_vma b = ((const reloc_data_type *) vb)->vma;
434 return (a > b) ? 1 : ((a < b) ? -1 : 0);
438 pe_export_sort (const void *va, const void *vb)
440 const def_file_export *a = va;
441 const def_file_export *b = vb;
443 return strcmp (a->name, b->name);
446 /* Read and process the .DEF file. */
448 /* These correspond to the entries in pe_def_file->exports[]. I use
449 exported_symbol_sections[i] to tag whether or not the symbol was
450 defined, since we can't export symbols we don't have. */
452 static bfd_vma *exported_symbol_offsets;
453 static struct bfd_section **exported_symbol_sections;
454 static int export_table_size;
455 static int count_exported;
456 static int count_exported_byname;
457 static int count_with_ordinals;
458 static const char *dll_name;
459 static int min_ordinal, max_ordinal;
460 static int *exported_symbols;
462 typedef struct exclude_list_struct
465 struct exclude_list_struct *next;
470 static struct exclude_list_struct *excludes = 0;
473 pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
476 char *exclude_string;
478 local_copy = xstrdup (new_excludes);
480 exclude_string = strtok (local_copy, ",:");
481 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
483 struct exclude_list_struct *new_exclude;
485 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
486 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
487 strcpy (new_exclude->string, exclude_string);
488 new_exclude->type = type;
489 new_exclude->next = excludes;
490 excludes = new_exclude;
497 is_import (const char* n)
499 return (CONST_STRNEQ (n, "__imp_"));
502 /* abfd is a bfd containing n (or NULL)
503 It can be used for contextual checks. */
506 auto_export (bfd *abfd, def_file *d, const char *n)
509 struct exclude_list_struct *ex;
510 const autofilter_entry_type *afptr;
511 const char * libname = 0;
512 if (abfd && abfd->my_archive)
513 libname = lbasename (abfd->my_archive->filename);
515 for (i = 0; i < d->num_exports; i++)
516 if (strcmp (d->exports[i].name, n) == 0)
519 if (pe_dll_do_default_excludes)
524 if (pe_dll_extra_pe_debug)
525 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
526 n, abfd, abfd->my_archive);
528 /* First of all, make context checks:
529 Don't export anything from standard libs. */
532 afptr = autofilter_liblist;
536 if (libnamencmp (libname, afptr) == 0 )
542 /* Next, exclude symbols from certain startup objects. */
544 if (abfd && (p = lbasename (abfd->filename)))
546 afptr = autofilter_objlist;
549 if (strcmp (p, afptr->name) == 0)
555 /* Don't try to blindly exclude all symbols
556 that begin with '__'; this was tried and
557 it is too restrictive. Instead we have
558 a target specific list to use: */
559 afptr = pe_details->autofilter_symbollist;
563 if (strcmp (n, afptr->name) == 0)
569 /* Next, exclude symbols starting with ... */
570 afptr = autofilter_symbolprefixlist;
573 if (strncmp (n, afptr->name, afptr->len) == 0)
579 /* Finally, exclude symbols ending with ... */
581 afptr = autofilter_symbolsuffixlist;
584 if ((len >= afptr->len)
585 /* Add 1 to insure match with trailing '\0'. */
586 && strncmp (n + len - afptr->len, afptr->name,
587 afptr->len + 1) == 0)
594 for (ex = excludes; ex; ex = ex->next)
596 if (ex->type == EXCLUDELIBS)
599 && ((strcmp (libname, ex->string) == 0)
600 || (strcasecmp ("ALL", ex->string) == 0)))
603 else if (ex->type == EXCLUDEFORIMPLIB)
605 if (strcmp (abfd->filename, ex->string) == 0)
608 else if (strcmp (n, ex->string) == 0)
616 process_def_file (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
619 struct bfd_link_hash_entry *blhe;
621 struct bfd_section *s;
622 def_file_export *e = 0;
625 pe_def_file = def_file_empty ();
627 /* First, run around to all the objects looking for the .drectve
628 sections, and push those into the def file too. */
629 for (b = info->input_bfds; b; b = b->link_next)
631 s = bfd_get_section_by_name (b, ".drectve");
635 char *buf = xmalloc (size);
637 bfd_get_section_contents (b, s, buf, 0, size);
638 def_file_add_directive (pe_def_file, buf, size);
643 /* If we are not building a DLL, when there are no exports
644 we do not build an export table at all. */
645 if (!pe_dll_export_everything && pe_def_file->num_exports == 0
649 /* Now, maybe export everything else the default way. */
650 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
652 for (b = info->input_bfds; b; b = b->link_next)
657 if (!bfd_generic_link_read_symbols (b))
659 einfo (_("%B%F: could not read symbols: %E\n"), b);
663 symbols = bfd_get_outsymbols (b);
664 nsyms = bfd_get_symcount (b);
666 for (j = 0; j < nsyms; j++)
668 /* We should export symbols which are either global or not
669 anything at all. (.bss data is the latter)
670 We should not export undefined symbols. */
671 if (symbols[j]->section != &bfd_und_section
672 && ((symbols[j]->flags & BSF_GLOBAL)
673 || (symbols[j]->flags == 0)))
675 const char *sn = symbols[j]->name;
677 /* We should not re-export imported stuff. */
683 name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
684 sprintf (name, "%s%s", "__imp_", sn);
686 blhe = bfd_link_hash_lookup (info->hash, name,
687 FALSE, FALSE, FALSE);
690 if (blhe && blhe->type == bfd_link_hash_defined)
694 if (pe_details->underscored && *sn == '_')
697 if (auto_export (b, pe_def_file, sn))
700 p=def_file_add_export (pe_def_file, sn, 0, -1);
701 /* Fill data flag properly, from dlltool.c. */
702 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
710 #define NE pe_def_file->num_exports
712 /* Canonicalize the export list. */
715 for (i = 0; i < NE; i++)
717 if (strchr (pe_def_file->exports[i].name, '@'))
719 /* This will preserve internal_name, which may have been
720 pointing to the same memory as name, or might not
722 int lead_at = (*pe_def_file->exports[i].name == '@');
723 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
724 char *tmp_at = strchr (tmp, '@');
729 einfo (_("%XCannot export %s: invalid export name\n"),
730 pe_def_file->exports[i].name);
731 pe_def_file->exports[i].name = tmp;
736 if (pe_dll_stdcall_aliases)
738 for (i = 0; i < NE; i++)
740 if (is_import (pe_def_file->exports[i].name))
743 if (strchr (pe_def_file->exports[i].name, '@'))
745 int lead_at = (*pe_def_file->exports[i].name == '@');
746 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
748 *(strchr (tmp, '@')) = 0;
749 if (auto_export (NULL, pe_def_file, tmp))
750 def_file_add_export (pe_def_file, tmp,
751 pe_def_file->exports[i].internal_name,
759 /* Convenience, but watch out for it changing. */
760 e = pe_def_file->exports;
762 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
763 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
765 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
769 count_exported_byname = 0;
770 count_with_ordinals = 0;
772 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
774 for (i = 0, j = 0; i < NE; i++)
776 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
778 /* This is a duplicate. */
779 if (e[j - 1].ordinal != -1
780 && e[i].ordinal != -1
781 && e[j - 1].ordinal != e[i].ordinal)
783 if (pe_dll_warn_dup_exports)
784 /* xgettext:c-format */
785 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
786 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
790 if (pe_dll_warn_dup_exports)
791 /* xgettext:c-format */
792 einfo (_("Warning, duplicate EXPORT: %s\n"),
796 if (e[i].ordinal != -1)
797 e[j - 1].ordinal = e[i].ordinal;
798 e[j - 1].flag_private |= e[i].flag_private;
799 e[j - 1].flag_constant |= e[i].flag_constant;
800 e[j - 1].flag_noname |= e[i].flag_noname;
801 e[j - 1].flag_data |= e[i].flag_data;
810 pe_def_file->num_exports = j; /* == NE */
812 for (i = 0; i < NE; i++)
816 /* Check for forward exports */
817 if (strchr (pe_def_file->exports[i].internal_name, '.'))
820 if (!pe_def_file->exports[i].flag_noname)
821 count_exported_byname++;
823 pe_def_file->exports[i].flag_forward = 1;
825 if (pe_def_file->exports[i].ordinal != -1)
827 if (max_ordinal < pe_def_file->exports[i].ordinal)
828 max_ordinal = pe_def_file->exports[i].ordinal;
829 if (min_ordinal > pe_def_file->exports[i].ordinal)
830 min_ordinal = pe_def_file->exports[i].ordinal;
831 count_with_ordinals++;
837 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
838 if (pe_details->underscored
839 && (*pe_def_file->exports[i].internal_name != '@'))
842 strcpy (name + 1, pe_def_file->exports[i].internal_name);
845 strcpy (name, pe_def_file->exports[i].internal_name);
847 blhe = bfd_link_hash_lookup (info->hash,
852 && (blhe->type == bfd_link_hash_defined
853 || (blhe->type == bfd_link_hash_common)))
856 if (!pe_def_file->exports[i].flag_noname)
857 count_exported_byname++;
859 /* Only fill in the sections. The actual offsets are computed
860 in fill_exported_offsets() after common symbols are laid
862 if (blhe->type == bfd_link_hash_defined)
863 exported_symbol_sections[i] = blhe->u.def.section;
865 exported_symbol_sections[i] = blhe->u.c.p->section;
867 if (pe_def_file->exports[i].ordinal != -1)
869 if (max_ordinal < pe_def_file->exports[i].ordinal)
870 max_ordinal = pe_def_file->exports[i].ordinal;
871 if (min_ordinal > pe_def_file->exports[i].ordinal)
872 min_ordinal = pe_def_file->exports[i].ordinal;
873 count_with_ordinals++;
876 else if (blhe && blhe->type == bfd_link_hash_undefined)
878 /* xgettext:c-format */
879 einfo (_("%XCannot export %s: symbol not defined\n"),
880 pe_def_file->exports[i].internal_name);
884 /* xgettext:c-format */
885 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
886 pe_def_file->exports[i].internal_name,
887 blhe->type, bfd_link_hash_defined);
891 /* xgettext:c-format */
892 einfo (_("%XCannot export %s: symbol not found\n"),
893 pe_def_file->exports[i].internal_name);
899 /* Build the bfd that will contain .edata and .reloc sections. */
902 build_filler_bfd (int include_edata)
904 lang_input_statement_type *filler_file;
905 filler_file = lang_add_input_file ("dll stuff",
906 lang_input_file_is_fake_enum,
908 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff",
909 link_info.output_bfd);
910 if (filler_bfd == NULL
911 || !bfd_set_arch_mach (filler_bfd,
912 bfd_get_arch (link_info.output_bfd),
913 bfd_get_mach (link_info.output_bfd)))
915 einfo ("%X%P: can not create BFD: %E\n");
921 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
923 || !bfd_set_section_flags (filler_bfd, edata_s,
930 einfo ("%X%P: can not create .edata section: %E\n");
933 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
936 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
938 || !bfd_set_section_flags (filler_bfd, reloc_s,
945 einfo ("%X%P: can not create .reloc section: %E\n");
949 bfd_set_section_size (filler_bfd, reloc_s, 0);
951 ldlang_add_file (filler_file);
954 /* Gather all the exported symbols and build the .edata section. */
957 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
960 int name_table_size = 0;
963 /* First, we need to know how many exported symbols there are,
964 and what the range of ordinals is. */
965 if (pe_def_file->name)
966 dll_name = pe_def_file->name;
969 dll_name = abfd->filename;
971 for (dlnp = dll_name; *dlnp; dlnp++)
972 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
976 if (count_with_ordinals && max_ordinal > count_exported)
978 if (min_ordinal > max_ordinal - count_exported + 1)
979 min_ordinal = max_ordinal - count_exported + 1;
984 max_ordinal = count_exported;
987 export_table_size = max_ordinal - min_ordinal + 1;
988 exported_symbols = xmalloc (export_table_size * sizeof (int));
989 for (i = 0; i < export_table_size; i++)
990 exported_symbols[i] = -1;
992 /* Now we need to assign ordinals to those that don't have them. */
993 for (i = 0; i < NE; i++)
995 if (exported_symbol_sections[i] ||
996 pe_def_file->exports[i].flag_forward)
998 if (pe_def_file->exports[i].ordinal != -1)
1000 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
1001 int pi = exported_symbols[ei];
1005 /* xgettext:c-format */
1006 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1007 pe_def_file->exports[i].ordinal,
1008 pe_def_file->exports[i].name,
1009 pe_def_file->exports[pi].name);
1011 exported_symbols[ei] = i;
1013 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
1016 /* Reserve space for the forward name. */
1017 if (pe_def_file->exports[i].flag_forward)
1019 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
1023 next_ordinal = min_ordinal;
1024 for (i = 0; i < NE; i++)
1025 if ((exported_symbol_sections[i] ||
1026 pe_def_file->exports[i].flag_forward) &&
1027 pe_def_file->exports[i].ordinal == -1)
1029 while (exported_symbols[next_ordinal - min_ordinal] != -1)
1032 exported_symbols[next_ordinal - min_ordinal] = i;
1033 pe_def_file->exports[i].ordinal = next_ordinal;
1036 /* OK, now we can allocate some memory. */
1037 edata_sz = (40 /* directory */
1038 + 4 * export_table_size /* addresses */
1039 + 4 * count_exported_byname /* name ptrs */
1040 + 2 * count_exported_byname /* ordinals */
1041 + name_table_size + strlen (dll_name) + 1);
1044 /* Fill the exported symbol offsets. The preliminary work has already
1045 been done in process_def_file(). */
1048 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
1051 struct bfd_link_hash_entry *blhe;
1053 for (i = 0; i < pe_def_file->num_exports; i++)
1057 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
1058 if (pe_details->underscored
1059 && *pe_def_file->exports[i].internal_name != '@')
1062 strcpy (name + 1, pe_def_file->exports[i].internal_name);
1065 strcpy (name, pe_def_file->exports[i].internal_name);
1067 blhe = bfd_link_hash_lookup (info->hash,
1069 FALSE, FALSE, TRUE);
1071 if (blhe && blhe->type == bfd_link_hash_defined)
1072 exported_symbol_offsets[i] = blhe->u.def.value;
1079 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1082 unsigned char *edirectory;
1083 unsigned char *eaddresses;
1084 unsigned char *enameptrs;
1085 unsigned char *eordinals;
1091 edata_d = xmalloc (edata_sz);
1093 /* Note use of array pointer math here. */
1094 edirectory = edata_d;
1095 eaddresses = edata_d + 40;
1096 enameptrs = eaddresses + 4 * export_table_size;
1097 eordinals = enameptrs + 4 * count_exported_byname;
1098 enamestr = (char *) eordinals + 2 * count_exported_byname;
1100 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1101 + edata_s->output_section->vma - image_base)
1103 memset (edata_d, 0, edata_sz);
1104 bfd_put_32 (abfd, now, edata_d + 4);
1105 if (pe_def_file->version_major != -1)
1107 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1108 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1111 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1112 strcpy (enamestr, dll_name);
1113 enamestr += strlen (enamestr) + 1;
1114 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1115 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1116 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1117 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1118 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1119 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1121 fill_exported_offsets (abfd, info);
1123 /* Ok, now for the filling in part.
1124 Scan alphabetically - ie the ordering in the exports[] table,
1125 rather than by ordinal - the ordering in the exported_symbol[]
1126 table. See dlltool.c and:
1127 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1128 for more information. */
1130 for (s = 0; s < NE; s++)
1132 struct bfd_section *ssec = exported_symbol_sections[s];
1133 if (pe_def_file->exports[s].ordinal != -1 &&
1134 (pe_def_file->exports[s].flag_forward || ssec != NULL))
1136 int ord = pe_def_file->exports[s].ordinal;
1138 if (pe_def_file->exports[s].flag_forward)
1140 bfd_put_32 (abfd, ERVA (enamestr),
1141 eaddresses + 4 * (ord - min_ordinal));
1143 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1144 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1148 bfd_vma srva = (exported_symbol_offsets[s]
1149 + ssec->output_section->vma
1150 + ssec->output_offset);
1152 bfd_put_32 (abfd, srva - image_base,
1153 eaddresses + 4 * (ord - min_ordinal));
1156 if (!pe_def_file->exports[s].flag_noname)
1158 char *ename = pe_def_file->exports[s].name;
1160 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1162 strcpy (enamestr, ename);
1163 enamestr += strlen (enamestr) + 1;
1164 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1166 pe_def_file->exports[s].hint = hint++;
1173 static struct bfd_section *current_sec;
1176 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1178 int (*cb) (arelent *, asection *))
1183 for (b = info->input_bfds; b; b = b->link_next)
1188 if (!bfd_generic_link_read_symbols (b))
1190 einfo (_("%B%F: could not read symbols: %E\n"), b);
1194 symbols = bfd_get_outsymbols (b);
1195 nsyms = bfd_get_symcount (b);
1197 for (s = b->sections; s; s = s->next)
1200 int relsize, nrelocs, i;
1201 int flags = bfd_get_section_flags (b, s);
1203 /* Skip discarded linkonce sections. */
1204 if (flags & SEC_LINK_ONCE
1205 && s->output_section == bfd_abs_section_ptr)
1210 relsize = bfd_get_reloc_upper_bound (b, s);
1211 relocs = xmalloc (relsize);
1212 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1214 for (i = 0; i < nrelocs; i++)
1216 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1218 if (!strcmp (name, sym->name))
1224 /* Warning: the allocated symbols are remembered in BFD and reused
1225 later, so don't free them! */
1226 /* free (symbols); */
1231 /* Gather all the relocations and build the .reloc section. */
1234 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1237 /* For .reloc stuff. */
1238 reloc_data_type *reloc_data;
1239 int total_relocs = 0;
1241 bfd_vma sec_page = (bfd_vma) -1;
1242 bfd_vma page_ptr, page_count;
1245 struct bfd_section *s;
1248 for (b = info->input_bfds; b; b = b->link_next)
1249 for (s = b->sections; s; s = s->next)
1250 total_relocs += s->reloc_count;
1252 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1256 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1259 int relsize, nrelocs, i;
1261 for (s = b->sections; s; s = s->next)
1263 bfd_vma sec_vma = s->output_section->vma + s->output_offset;
1267 /* If it's not loaded, we don't need to relocate it this way. */
1268 if (!(s->output_section->flags & SEC_LOAD))
1271 /* I don't know why there would be a reloc for these, but I've
1272 seen it happen - DJ */
1273 if (s->output_section == &bfd_abs_section)
1276 if (s->output_section->vma == 0)
1278 /* Huh? Shouldn't happen, but punt if it does. */
1279 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1280 s->output_section->name, s->output_section->index,
1281 s->output_section->flags);
1285 if (!bfd_generic_link_read_symbols (b))
1287 einfo (_("%B%F: could not read symbols: %E\n"), b);
1291 symbols = bfd_get_outsymbols (b);
1292 nsyms = bfd_get_symcount (b);
1293 relsize = bfd_get_reloc_upper_bound (b, s);
1294 relocs = xmalloc (relsize);
1295 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1297 for (i = 0; i < nrelocs; i++)
1299 if (pe_dll_extra_pe_debug)
1301 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1302 printf ("rel: %s\n", sym->name);
1304 if (!relocs[i]->howto->pc_relative
1305 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1308 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1310 /* Don't create relocs for undefined weak symbols. */
1311 if (sym->flags == BSF_WEAK)
1313 struct bfd_link_hash_entry *blhe
1314 = bfd_link_hash_lookup (info->hash, sym->name,
1315 FALSE, FALSE, FALSE);
1316 if (!blhe || blhe->type != bfd_link_hash_defined)
1320 sym_vma = (relocs[i]->addend
1323 + sym->section->output_offset
1324 + sym->section->output_section->vma);
1325 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1327 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1329 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1330 relocs[i]->howto->rightshift)
1332 #ifdef pe_use_x86_64
1333 case BITS_AND_SHIFT (64, 0):
1334 reloc_data[total_relocs].type = 10;
1338 case BITS_AND_SHIFT (32, 0):
1339 reloc_data[total_relocs].type = 3;
1342 case BITS_AND_SHIFT (16, 0):
1343 reloc_data[total_relocs].type = 2;
1346 case BITS_AND_SHIFT (16, 16):
1347 reloc_data[total_relocs].type = 4;
1348 /* FIXME: we can't know the symbol's right value
1349 yet, but we probably can safely assume that
1350 CE will relocate us in 64k blocks, so leaving
1352 reloc_data[total_relocs].extra = 0;
1355 case BITS_AND_SHIFT (26, 2):
1356 reloc_data[total_relocs].type = 5;
1359 case BITS_AND_SHIFT (24, 2):
1360 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1361 Those ARM_xxx definitions should go in proper
1363 if (relocs[i]->howto->type == 0
1364 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1365 || relocs[i]->howto->type == 5)
1366 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1367 that has already been fully processed during a
1368 previous link stage, so ignore it here. */
1372 /* xgettext:c-format */
1373 einfo (_("%XError: %d-bit reloc in dll\n"),
1374 relocs[i]->howto->bitsize);
1380 /* Warning: the allocated symbols are remembered in BFD and
1381 reused later, so don't free them! */
1385 /* At this point, we have total_relocs relocation addresses in
1386 reloc_addresses, which are all suitable for the .reloc section.
1387 We must now create the new sections. */
1388 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1390 for (i = 0; i < total_relocs; i++)
1392 bfd_vma this_page = (reloc_data[i].vma >> 12);
1394 if (this_page != sec_page)
1396 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1398 sec_page = this_page;
1403 if (reloc_data[i].type == 4)
1407 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1408 reloc_d = xmalloc (reloc_sz);
1409 sec_page = (bfd_vma) -1;
1411 page_ptr = (bfd_vma) -1;
1414 for (i = 0; i < total_relocs; i++)
1416 bfd_vma rva = reloc_data[i].vma - image_base;
1417 bfd_vma this_page = (rva & ~0xfff);
1419 if (this_page != sec_page)
1421 while (reloc_sz & 3)
1422 reloc_d[reloc_sz++] = 0;
1424 if (page_ptr != (bfd_vma) -1)
1425 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1427 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1428 page_ptr = reloc_sz;
1430 sec_page = this_page;
1434 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1435 reloc_d + reloc_sz);
1438 if (reloc_data[i].type == 4)
1440 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1447 while (reloc_sz & 3)
1448 reloc_d[reloc_sz++] = 0;
1450 if (page_ptr != (bfd_vma) -1)
1451 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1453 while (reloc_sz < reloc_s->size)
1454 reloc_d[reloc_sz++] = 0;
1457 /* Given the exiting def_file structure, print out a .DEF file that
1458 corresponds to it. */
1461 quoteput (char *s, FILE *f, int needs_quotes)
1465 for (cp = s; *cp; cp++)
1480 if (*s == '"' || *s == '\\')
1494 pe_dll_generate_def_file (const char *pe_out_def_filename)
1497 FILE *out = fopen (pe_out_def_filename, "w");
1500 /* xgettext:c-format */
1501 einfo (_("%s: Can't open output def file %s\n"),
1502 program_name, pe_out_def_filename);
1506 if (pe_def_file->name)
1508 if (pe_def_file->is_dll)
1509 fprintf (out, "LIBRARY ");
1511 fprintf (out, "NAME ");
1513 quoteput (pe_def_file->name, out, 1);
1515 if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
1517 fprintf (out, " BASE=0x");
1518 fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
1520 fprintf (out, "\n");
1523 if (pe_def_file->description)
1525 fprintf (out, "DESCRIPTION ");
1526 quoteput (pe_def_file->description, out, 1);
1527 fprintf (out, "\n");
1530 if (pe_def_file->version_minor != -1)
1531 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1532 pe_def_file->version_minor);
1533 else if (pe_def_file->version_major != -1)
1534 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1536 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1537 fprintf (out, "\n");
1539 if (pe_def_file->stack_commit != -1)
1540 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1541 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1542 else if (pe_def_file->stack_reserve != -1)
1543 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1545 if (pe_def_file->heap_commit != -1)
1546 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1547 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1548 else if (pe_def_file->heap_reserve != -1)
1549 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1551 if (pe_def_file->num_section_defs > 0)
1553 fprintf (out, "\nSECTIONS\n\n");
1555 for (i = 0; i < pe_def_file->num_section_defs; i++)
1558 quoteput (pe_def_file->section_defs[i].name, out, 0);
1560 if (pe_def_file->section_defs[i].class)
1562 fprintf (out, " CLASS ");
1563 quoteput (pe_def_file->section_defs[i].class, out, 0);
1566 if (pe_def_file->section_defs[i].flag_read)
1567 fprintf (out, " READ");
1569 if (pe_def_file->section_defs[i].flag_write)
1570 fprintf (out, " WRITE");
1572 if (pe_def_file->section_defs[i].flag_execute)
1573 fprintf (out, " EXECUTE");
1575 if (pe_def_file->section_defs[i].flag_shared)
1576 fprintf (out, " SHARED");
1578 fprintf (out, "\n");
1582 if (pe_def_file->num_exports > 0)
1584 fprintf (out, "EXPORTS\n");
1586 for (i = 0; i < pe_def_file->num_exports; i++)
1588 def_file_export *e = pe_def_file->exports + i;
1590 quoteput (e->name, out, 0);
1592 if (e->internal_name && strcmp (e->internal_name, e->name))
1594 fprintf (out, " = ");
1595 quoteput (e->internal_name, out, 0);
1598 if (e->ordinal != -1)
1599 fprintf (out, " @%d", e->ordinal);
1601 if (e->flag_private)
1602 fprintf (out, " PRIVATE");
1604 if (e->flag_constant)
1605 fprintf (out, " CONSTANT");
1608 fprintf (out, " NONAME");
1611 fprintf (out, " DATA");
1613 fprintf (out, "\n");
1617 if (pe_def_file->num_imports > 0)
1619 fprintf (out, "\nIMPORTS\n\n");
1621 for (i = 0; i < pe_def_file->num_imports; i++)
1623 def_file_import *im = pe_def_file->imports + i;
1626 if (im->internal_name
1627 && (!im->name || strcmp (im->internal_name, im->name)))
1629 quoteput (im->internal_name, out, 0);
1630 fprintf (out, " = ");
1633 quoteput (im->module->name, out, 0);
1637 quoteput (im->name, out, 0);
1639 fprintf (out, "%d", im->ordinal);
1641 fprintf (out, "\n");
1646 fprintf (out, _("; no contents available\n"));
1648 if (fclose (out) == EOF)
1649 /* xgettext:c-format */
1650 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1653 /* Generate the import library. */
1655 static asymbol **symtab;
1658 static const char *dll_filename;
1659 static char *dll_symname;
1661 #define UNDSEC (asection *) &bfd_und_section
1664 quick_section (bfd *abfd, const char *name, int flags, int align)
1669 sec = bfd_make_section_old_way (abfd, name);
1670 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1671 bfd_set_section_alignment (abfd, sec, align);
1672 /* Remember to undo this before trying to link internally! */
1673 sec->output_section = sec;
1675 sym = bfd_make_empty_symbol (abfd);
1676 symtab[symptr++] = sym;
1677 sym->name = sec->name;
1679 sym->flags = BSF_LOCAL;
1686 quick_symbol (bfd *abfd,
1695 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1700 sym = bfd_make_empty_symbol (abfd);
1705 symtab[symptr++] = sym;
1708 static arelent *reltab = 0;
1709 static int relcount = 0, relsize = 0;
1712 quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
1714 if (relcount >= relsize - 1)
1718 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1720 reltab = xmalloc (relsize * sizeof (arelent));
1722 reltab[relcount].address = address;
1723 reltab[relcount].addend = 0;
1724 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1725 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1730 save_relocs (asection *sec)
1734 sec->relocation = reltab;
1735 sec->reloc_count = relcount;
1736 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1737 for (i = 0; i < relcount; i++)
1738 sec->orelocation[i] = sec->relocation + i;
1739 sec->orelocation[relcount] = 0;
1740 sec->flags |= SEC_RELOC;
1742 relcount = relsize = 0;
1745 /* .section .idata$2
1746 .global __head_my_dll
1763 make_head (bfd *parent)
1765 asection *id2, *id5, *id4;
1766 unsigned char *d2, *d5, *d4;
1770 oname = xmalloc (20);
1771 sprintf (oname, "d%06d.o", tmp_seq);
1774 abfd = bfd_create (oname, parent);
1775 bfd_find_target (pe_details->object_target, abfd);
1776 bfd_make_writable (abfd);
1778 bfd_set_format (abfd, bfd_object);
1779 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1782 symtab = xmalloc (6 * sizeof (asymbol *));
1783 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1784 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1785 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1786 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1787 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1789 /* OK, pay attention here. I got confused myself looking back at
1790 it. We create a four-byte section to mark the beginning of the
1791 list, and we include an offset of 4 in the section, so that the
1792 pointer to the list points to the *end* of this section, which is
1793 the start of the list of sections from other objects. */
1795 bfd_set_section_size (abfd, id2, 20);
1799 d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
1800 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1801 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1802 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1805 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1806 d5 = xmalloc (PE_IDATA5_SIZE);
1808 memset (d5, 0, PE_IDATA5_SIZE);
1810 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1811 d4 = xmalloc (PE_IDATA4_SIZE);
1813 memset (d4, 0, PE_IDATA4_SIZE);
1815 bfd_set_symtab (abfd, symtab, symptr);
1817 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1818 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1819 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1821 bfd_make_readable (abfd);
1825 /* .section .idata$4
1832 .global __my_dll_iname
1837 make_tail (bfd *parent)
1839 asection *id4, *id5, *id7;
1840 unsigned char *d4, *d5, *d7;
1845 oname = xmalloc (20);
1846 sprintf (oname, "d%06d.o", tmp_seq);
1849 abfd = bfd_create (oname, parent);
1850 bfd_find_target (pe_details->object_target, abfd);
1851 bfd_make_writable (abfd);
1853 bfd_set_format (abfd, bfd_object);
1854 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1857 symtab = xmalloc (5 * sizeof (asymbol *));
1858 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1859 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1860 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1861 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1863 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1864 d4 = xmalloc (PE_IDATA4_SIZE);
1866 memset (d4, 0, PE_IDATA4_SIZE);
1868 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1869 d5 = xmalloc (PE_IDATA5_SIZE);
1871 memset (d5, 0, PE_IDATA5_SIZE);
1873 len = strlen (dll_filename) + 1;
1876 bfd_set_section_size (abfd, id7, len);
1879 strcpy ((char *) d7, dll_filename);
1880 /* If len was odd, the above
1881 strcpy leaves behind an undefined byte. That is harmless,
1882 but we set it to 0 just so the binary dumps are pretty. */
1885 bfd_set_symtab (abfd, symtab, symptr);
1887 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1888 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1889 bfd_set_section_contents (abfd, id7, d7, 0, len);
1891 bfd_make_readable (abfd);
1897 .global ___imp_function
1898 .global __imp__function
1900 jmp *__imp__function:
1914 .asciz "function" xlate? (add underscore, kill at) */
1916 static const unsigned char jmp_ix86_bytes[] =
1918 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1926 .dw __imp_function */
1928 static const unsigned char jmp_sh_bytes[] =
1930 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1934 lui $t0,<high:__imp_function>
1935 lw $t0,<low:__imp_function>
1939 static const unsigned char jmp_mips_bytes[] =
1941 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1942 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1945 static const unsigned char jmp_arm_bytes[] =
1947 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1948 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1954 make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
1956 asection *tx, *id7, *id5, *id4, *id6;
1957 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1961 const unsigned char *jmp_bytes = NULL;
1962 int jmp_byte_count = 0;
1964 /* Include the jump stub section only if it is needed. A jump
1965 stub is needed if the symbol being imported <sym> is a function
1966 symbol and there is at least one undefined reference to that
1967 symbol. In other words, if all the import references to <sym> are
1968 explicitly through _declspec(dllimport) then the jump stub is not
1970 if (include_jmp_stub)
1972 switch (pe_details->pe_arch)
1975 jmp_bytes = jmp_ix86_bytes;
1976 jmp_byte_count = sizeof (jmp_ix86_bytes);
1979 jmp_bytes = jmp_sh_bytes;
1980 jmp_byte_count = sizeof (jmp_sh_bytes);
1983 jmp_bytes = jmp_mips_bytes;
1984 jmp_byte_count = sizeof (jmp_mips_bytes);
1987 case PE_ARCH_arm_epoc:
1988 case PE_ARCH_arm_wince:
1989 jmp_bytes = jmp_arm_bytes;
1990 jmp_byte_count = sizeof (jmp_arm_bytes);
1997 oname = xmalloc (20);
1998 sprintf (oname, "d%06d.o", tmp_seq);
2001 abfd = bfd_create (oname, parent);
2002 bfd_find_target (pe_details->object_target, abfd);
2003 bfd_make_writable (abfd);
2005 bfd_set_format (abfd, bfd_object);
2006 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2009 symtab = xmalloc (11 * sizeof (asymbol *));
2010 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
2011 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2012 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2013 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2014 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
2016 if (*exp->internal_name == '@')
2018 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2020 if (include_jmp_stub)
2021 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
2022 quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
2024 /* Fastcall applies only to functions,
2025 so no need for auto-import symbol. */
2029 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2031 if (include_jmp_stub)
2032 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
2034 quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
2036 /* Symbol to reference ord/name of imported
2037 data symbol, used to implement auto-import. */
2039 quick_symbol (abfd, U ("_nm_"), U (""), exp->internal_name, id6,
2042 if (pe_dll_compat_implib)
2043 quick_symbol (abfd, U ("__imp_"), exp->internal_name, "", id5,
2046 if (include_jmp_stub)
2048 bfd_set_section_size (abfd, tx, jmp_byte_count);
2049 td = xmalloc (jmp_byte_count);
2051 memcpy (td, jmp_bytes, jmp_byte_count);
2053 switch (pe_details->pe_arch)
2056 #ifdef pe_use_x86_64
2057 quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
2059 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
2063 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2066 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
2067 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
2068 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2071 case PE_ARCH_arm_epoc:
2072 case PE_ARCH_arm_wince:
2073 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2081 bfd_set_section_size (abfd, tx, 0);
2083 bfd_set_section_size (abfd, id7, 4);
2087 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2090 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2091 d5 = xmalloc (PE_IDATA5_SIZE);
2093 memset (d5, 0, PE_IDATA5_SIZE);
2095 if (exp->flag_noname)
2097 d5[0] = exp->ordinal;
2098 d5[1] = exp->ordinal >> 8;
2099 d5[PE_IDATA5_SIZE - 1] = 0x80;
2103 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2107 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2108 d4 = xmalloc (PE_IDATA4_SIZE);
2110 memset (d4, 0, PE_IDATA4_SIZE);
2112 if (exp->flag_noname)
2114 d4[0] = exp->ordinal;
2115 d4[1] = exp->ordinal >> 8;
2116 d4[PE_IDATA4_SIZE - 1] = 0x80;
2120 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2124 if (exp->flag_noname)
2127 bfd_set_section_size (abfd, id6, 0);
2131 /* { short, asciz } */
2132 len = 2 + strlen (exp->name) + 1;
2135 bfd_set_section_size (abfd, id6, len);
2138 memset (d6, 0, len);
2139 d6[0] = exp->hint & 0xff;
2140 d6[1] = exp->hint >> 8;
2141 strcpy ((char *) d6 + 2, exp->name);
2144 bfd_set_symtab (abfd, symtab, symptr);
2146 if (include_jmp_stub)
2147 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2148 bfd_set_section_contents (abfd, id7, d7, 0, 4);
2149 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2150 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2151 if (!exp->flag_noname)
2152 bfd_set_section_contents (abfd, id6, d6, 0, len);
2154 bfd_make_readable (abfd);
2159 make_singleton_name_thunk (const char *import, bfd *parent)
2161 /* Name thunks go to idata$4. */
2167 oname = xmalloc (20);
2168 sprintf (oname, "nmth%06d.o", tmp_seq);
2171 abfd = bfd_create (oname, parent);
2172 bfd_find_target (pe_details->object_target, abfd);
2173 bfd_make_writable (abfd);
2175 bfd_set_format (abfd, bfd_object);
2176 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2179 symtab = xmalloc (3 * sizeof (asymbol *));
2180 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2181 quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
2182 quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
2184 /* We need space for the real thunk and for the null terminator. */
2185 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2186 d4 = xmalloc (PE_IDATA4_SIZE * 2);
2188 memset (d4, 0, PE_IDATA4_SIZE * 2);
2189 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2192 bfd_set_symtab (abfd, symtab, symptr);
2194 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2196 bfd_make_readable (abfd);
2201 make_import_fixup_mark (arelent *rel)
2203 /* We convert reloc to symbol, for later reference. */
2205 static char *fixup_name = NULL;
2206 static size_t buffer_len = 0;
2208 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2210 bfd *abfd = bfd_asymbol_bfd (sym);
2211 struct bfd_link_hash_entry *bh;
2215 fixup_name = xmalloc (384);
2219 if (strlen (sym->name) + 25 > buffer_len)
2220 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2221 bigger than 20 digits long, we've got worse problems than
2222 overflowing this buffer... */
2225 /* New buffer size is length of symbol, plus 25, but
2226 then rounded up to the nearest multiple of 128. */
2227 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2228 fixup_name = xmalloc (buffer_len);
2231 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2234 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2235 current_sec, /* sym->section, */
2236 rel->address, NULL, TRUE, FALSE, &bh);
2241 /* .section .idata$2
2242 .rva __nm_thnk_SYM (singleton thunk with name of func)
2245 .rva __my_dll_iname (name of dll)
2246 .rva __fuNN_SYM (pointer to reference (address) in text) */
2249 make_import_fixup_entry (const char *name,
2250 const char *fixup_name,
2251 const char *dll_symname,
2259 oname = xmalloc (20);
2260 sprintf (oname, "fu%06d.o", tmp_seq);
2263 abfd = bfd_create (oname, parent);
2264 bfd_find_target (pe_details->object_target, abfd);
2265 bfd_make_writable (abfd);
2267 bfd_set_format (abfd, bfd_object);
2268 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2271 symtab = xmalloc (6 * sizeof (asymbol *));
2272 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2274 quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2275 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2276 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2278 bfd_set_section_size (abfd, id2, 20);
2282 d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
2284 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2285 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2286 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2289 bfd_set_symtab (abfd, symtab, symptr);
2291 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2293 bfd_make_readable (abfd);
2297 /* .section .rdata_runtime_pseudo_reloc
2299 .rva __fuNN_SYM (pointer to reference (address) in text) */
2302 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2303 const char *fixup_name,
2304 bfd_vma addend ATTRIBUTE_UNUSED,
2309 unsigned char *rt_rel_d;
2312 oname = xmalloc (20);
2313 sprintf (oname, "rtr%06d.o", tmp_seq);
2316 abfd = bfd_create (oname, parent);
2317 bfd_find_target (pe_details->object_target, abfd);
2318 bfd_make_writable (abfd);
2320 bfd_set_format (abfd, bfd_object);
2321 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2324 if (link_info.pei386_runtime_pseudo_reloc == 2)
2326 symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
2330 symtab = xmalloc (2 * sizeof (asymbol *));
2332 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2333 SEC_HAS_CONTENTS, 2);
2335 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2337 if (link_info.pei386_runtime_pseudo_reloc == 2)
2340 if (! runtime_pseudp_reloc_v2_init)
2343 runtime_pseudp_reloc_v2_init = 1;
2345 quick_symbol (abfd, U ("_imp_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2347 bfd_set_section_size (abfd, rt_rel, size);
2348 rt_rel_d = xmalloc (size);
2349 rt_rel->contents = rt_rel_d;
2350 memset (rt_rel_d, 0, size);
2351 quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
2352 quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
2353 bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
2355 bfd_put_32 (abfd, 1, rt_rel_d + 8);
2356 save_relocs (rt_rel);
2358 bfd_set_symtab (abfd, symtab, symptr);
2360 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
2364 bfd_set_section_size (abfd, rt_rel, 8);
2365 rt_rel_d = xmalloc (8);
2366 rt_rel->contents = rt_rel_d;
2367 memset (rt_rel_d, 0, 8);
2369 bfd_put_32 (abfd, addend, rt_rel_d);
2370 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2372 save_relocs (rt_rel);
2374 bfd_set_symtab (abfd, symtab, symptr);
2376 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2378 bfd_make_readable (abfd);
2383 .rva __pei386_runtime_relocator */
2386 pe_create_runtime_relocator_reference (bfd *parent)
2388 asection *extern_rt_rel;
2389 unsigned char *extern_rt_rel_d;
2393 oname = xmalloc (20);
2394 sprintf (oname, "ertr%06d.o", tmp_seq);
2397 abfd = bfd_create (oname, parent);
2398 bfd_find_target (pe_details->object_target, abfd);
2399 bfd_make_writable (abfd);
2401 bfd_set_format (abfd, bfd_object);
2402 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2405 symtab = xmalloc (2 * sizeof (asymbol *));
2406 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2408 quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2411 bfd_set_section_size (abfd, extern_rt_rel, 4);
2412 extern_rt_rel_d = xmalloc (4);
2413 extern_rt_rel->contents = extern_rt_rel_d;
2415 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2416 save_relocs (extern_rt_rel);
2418 bfd_set_symtab (abfd, symtab, symptr);
2420 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
2422 bfd_make_readable (abfd);
2427 pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend)
2430 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2431 struct bfd_link_hash_entry *name_thunk_sym;
2432 const char *name = sym->name;
2433 char *fixup_name = make_import_fixup_mark (rel);
2436 sprintf (buf, U ("_nm_thnk_%s"), name);
2438 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2440 if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2442 bfd *b = make_singleton_name_thunk (name, link_info.output_bfd);
2443 add_bfd_to_link (b, b->filename, &link_info);
2445 /* If we ever use autoimport, we have to cast text section writable. */
2446 config.text_read_only = FALSE;
2447 link_info.output_bfd->flags &= ~WP_TEXT;
2450 if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2452 extern char * pe_data_import_dll;
2453 char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2455 b = make_import_fixup_entry (name, fixup_name, dll_symname,
2456 link_info.output_bfd);
2457 add_bfd_to_link (b, b->filename, &link_info);
2460 if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
2461 || link_info.pei386_runtime_pseudo_reloc == 2)
2463 if (pe_dll_extra_pe_debug)
2464 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2465 fixup_name, (int) addend);
2467 b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
2468 link_info.output_bfd);
2469 add_bfd_to_link (b, b->filename, &link_info);
2471 if (runtime_pseudo_relocs_created == 0)
2473 b = pe_create_runtime_relocator_reference (link_info.output_bfd);
2474 add_bfd_to_link (b, b->filename, &link_info);
2476 runtime_pseudo_relocs_created++;
2478 else if (addend != 0)
2480 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2481 s->owner, s, rel->address, sym->name);
2488 pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
2497 dll_filename = (def->name) ? def->name : dll_name;
2498 dll_symname = xstrdup (dll_filename);
2499 for (i = 0; dll_symname[i]; i++)
2500 if (!ISALNUM (dll_symname[i]))
2501 dll_symname[i] = '_';
2503 unlink_if_ordinary (impfilename);
2505 outarch = bfd_openw (impfilename, 0);
2509 /* xgettext:c-format */
2510 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2514 /* xgettext:c-format */
2515 info_msg (_("Creating library file: %s\n"), impfilename);
2517 bfd_set_format (outarch, bfd_archive);
2518 outarch->has_armap = 1;
2520 /* Work out a reasonable size of things to put onto one line. */
2521 ar_head = make_head (outarch);
2523 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2524 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next)
2526 /* Iterate the exclude list. */
2527 struct exclude_list_struct *ex;
2529 for (ex = excludes, found = 0; ex && !found; ex = ex->next)
2531 if (ex->type != EXCLUDEFORIMPLIB)
2533 found = (strcmp (ex->string, ibfd->filename) == 0);
2535 /* If it matched, we must open a fresh BFD for it (the original
2536 input BFD is still needed for the DLL's final link) and add
2537 it into the archive member chain. */
2540 bfd *newbfd = bfd_openr (ibfd->my_archive
2541 ? ibfd->my_archive->filename : ibfd->filename, NULL);
2544 einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
2547 if (ibfd->my_archive)
2549 /* Must now iterate through archive until we find the
2550 required member. A minor shame that we'll open the
2551 archive once per member that we require from it, and
2552 leak those archive bfds rather than reuse them. */
2553 bfd *arbfd = newbfd;
2554 if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
2556 einfo (_("%X%s(%s): can't find member in non-archive file"),
2557 ibfd->my_archive->filename, ibfd->filename);
2561 while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
2563 if (strcmp (newbfd->filename, ibfd->filename) == 0)
2568 einfo (_("%X%s(%s): can't find member in archive"),
2569 ibfd->my_archive->filename, ibfd->filename);
2573 newbfd->archive_next = head;
2578 for (i = 0; i < def->num_exports; i++)
2580 /* The import library doesn't know about the internal name. */
2581 char *internal = def->exports[i].internal_name;
2584 /* Don't add PRIVATE entries to import lib. */
2585 if (pe_def_file->exports[i].flag_private)
2587 def->exports[i].internal_name = def->exports[i].name;
2588 n = make_one (def->exports + i, outarch,
2589 ! (def->exports + i)->flag_data);
2590 n->archive_next = head;
2592 def->exports[i].internal_name = internal;
2595 ar_tail = make_tail (outarch);
2597 if (ar_head == NULL || ar_tail == NULL)
2600 /* Now stick them all into the archive. */
2601 ar_head->archive_next = head;
2602 ar_tail->archive_next = ar_head;
2605 if (! bfd_set_archive_head (outarch, head))
2606 einfo ("%Xbfd_set_archive_head: %E\n");
2608 if (! bfd_close (outarch))
2609 einfo ("%Xbfd_close %s: %E\n", impfilename);
2611 while (head != NULL)
2613 bfd *n = head->archive_next;
2620 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *link_info)
2622 lang_input_statement_type *fake_file;
2624 fake_file = lang_add_input_file (name,
2625 lang_input_file_is_fake_enum,
2627 fake_file->the_bfd = abfd;
2628 ldlang_add_file (fake_file);
2630 if (!bfd_link_add_symbols (abfd, link_info))
2631 einfo ("%Xaddsym %s: %E\n", name);
2635 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *link_info)
2637 def_file_module *module;
2639 pe_dll_id_target (bfd_get_target (output_bfd));
2644 for (module = pe_def_file->modules; module; module = module->next)
2648 dll_filename = module->name;
2649 dll_symname = xstrdup (module->name);
2650 for (i = 0; dll_symname[i]; i++)
2651 if (!ISALNUM (dll_symname[i]))
2652 dll_symname[i] = '_';
2656 for (i = 0; i < pe_def_file->num_imports; i++)
2657 if (pe_def_file->imports[i].module == module)
2659 def_file_export exp;
2660 struct bfd_link_hash_entry *blhe;
2661 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2662 /* See if we need this import. */
2663 size_t len = strlen (pe_def_file->imports[i].internal_name);
2664 char *name = xmalloc (len + 2 + 6);
2665 bfd_boolean include_jmp_stub = FALSE;
2668 sprintf (name, "%s",
2669 pe_def_file->imports[i].internal_name);
2671 sprintf (name, "%s%s",U (""),
2672 pe_def_file->imports[i].internal_name);
2674 blhe = bfd_link_hash_lookup (link_info->hash, name,
2675 FALSE, FALSE, FALSE);
2677 /* Include the jump stub for <sym> only if the <sym>
2679 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2682 sprintf (name, "%s%s", "__imp_",
2683 pe_def_file->imports[i].internal_name);
2685 sprintf (name, "%s%s%s", "__imp_", U (""),
2686 pe_def_file->imports[i].internal_name);
2688 blhe = bfd_link_hash_lookup (link_info->hash, name,
2689 FALSE, FALSE, FALSE);
2692 include_jmp_stub = TRUE;
2696 if (blhe && blhe->type == bfd_link_hash_undefined)
2702 bfd *ar_head = make_head (output_bfd);
2703 add_bfd_to_link (ar_head, ar_head->filename, link_info);
2706 exp.internal_name = pe_def_file->imports[i].internal_name;
2707 exp.name = pe_def_file->imports[i].name;
2708 exp.ordinal = pe_def_file->imports[i].ordinal;
2709 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2710 exp.flag_private = 0;
2711 exp.flag_constant = 0;
2712 exp.flag_data = pe_def_file->imports[i].data;
2713 exp.flag_noname = exp.name ? 0 : 1;
2714 one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
2715 add_bfd_to_link (one, one->filename, link_info);
2720 bfd *ar_tail = make_tail (output_bfd);
2721 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2728 /* We were handed a *.DLL file. Parse it and turn it into a set of
2729 IMPORTS directives in the def file. Return TRUE if the file was
2730 handled, FALSE if not. */
2733 pe_get16 (bfd *abfd, int where)
2737 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2738 bfd_bread (b, (bfd_size_type) 2, abfd);
2739 return b[0] + (b[1] << 8);
2743 pe_get32 (bfd *abfd, int where)
2747 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2748 bfd_bread (b, (bfd_size_type) 4, abfd);
2749 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2755 unsigned char *b = ptr;
2757 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2761 pe_implied_import_dll (const char *filename)
2764 bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
2765 bfd_vma export_rva, export_size, nsections, secptr, expptr;
2766 bfd_vma exp_funcbase;
2767 unsigned char *expdata;
2769 bfd_vma name_rvas, ordinals, nexp, ordbase;
2770 const char *dll_name;
2771 /* Initialization with start > end guarantees that is_data
2772 will not be set by mistake, and avoids compiler warning. */
2773 bfd_vma data_start = 1;
2774 bfd_vma data_end = 0;
2775 bfd_vma rdata_start = 1;
2776 bfd_vma rdata_end = 0;
2777 bfd_vma bss_start = 1;
2778 bfd_vma bss_end = 0;
2780 /* No, I can't use bfd here. kernel32.dll puts its export table in
2781 the middle of the .rdata section. */
2782 dll = bfd_openr (filename, pe_details->target_name);
2785 einfo ("%Xopen %s: %E\n", filename);
2789 /* PEI dlls seem to be bfd_objects. */
2790 if (!bfd_check_format (dll, bfd_object))
2792 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2796 /* Get pe_header, optional header and numbers of export entries. */
2797 pe_header_offset = pe_get32 (dll, 0x3c);
2798 opthdr_ofs = pe_header_offset + 4 + 20;
2799 #ifdef pe_use_x86_64
2800 num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2802 num_entries = pe_get32 (dll, opthdr_ofs + 92);
2805 if (num_entries < 1) /* No exports. */
2808 #ifdef pe_use_x86_64
2809 export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
2810 export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
2812 export_rva = pe_get32 (dll, opthdr_ofs + 96);
2813 export_size = pe_get32 (dll, opthdr_ofs + 100);
2816 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2817 secptr = (pe_header_offset + 4 + 20 +
2818 pe_get16 (dll, pe_header_offset + 4 + 16));
2821 /* Get the rva and size of the export section. */
2822 for (i = 0; i < nsections; i++)
2825 bfd_vma secptr1 = secptr + 40 * i;
2826 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
2827 bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
2828 bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
2830 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2831 bfd_bread (sname, (bfd_size_type) 8, dll);
2833 if (vaddr <= export_rva && vaddr + vsize > export_rva)
2835 expptr = fptr + (export_rva - vaddr);
2836 if (export_rva + export_size > vaddr + vsize)
2837 export_size = vsize - (export_rva - vaddr);
2842 /* Scan sections and store the base and size of the
2843 data and bss segments in data/base_start/end. */
2844 for (i = 0; i < nsections; i++)
2846 bfd_vma secptr1 = secptr + 40 * i;
2847 bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
2848 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
2849 bfd_vma flags = pe_get32 (dll, secptr1 + 36);
2853 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
2854 bfd_bread (sec_name, (bfd_size_type) 8, dll);
2856 if (strcmp(sec_name,".data") == 0)
2859 data_end = vaddr + vsize;
2861 if (pe_dll_extra_pe_debug)
2862 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2863 __FUNCTION__, sec_name, (unsigned long) vaddr,
2864 (unsigned long) (vaddr + vsize), (unsigned long) flags);
2866 else if (strcmp(sec_name,".rdata") == 0)
2868 rdata_start = vaddr;
2869 rdata_end = vaddr + vsize;
2871 if (pe_dll_extra_pe_debug)
2872 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2873 __FUNCTION__, sec_name, (unsigned long) vaddr,
2874 (unsigned long) (vaddr + vsize), (unsigned long) flags);
2876 else if (strcmp (sec_name,".bss") == 0)
2879 bss_end = vaddr + vsize;
2881 if (pe_dll_extra_pe_debug)
2882 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2883 __FUNCTION__, sec_name, (unsigned long) vaddr,
2884 (unsigned long) (vaddr + vsize), (unsigned long) flags);
2888 expdata = xmalloc (export_size);
2889 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2890 bfd_bread (expdata, (bfd_size_type) export_size, dll);
2891 erva = (char *) expdata - export_rva;
2893 if (pe_def_file == 0)
2894 pe_def_file = def_file_empty ();
2896 nexp = pe_as32 (expdata + 24);
2897 name_rvas = pe_as32 (expdata + 32);
2898 ordinals = pe_as32 (expdata + 36);
2899 ordbase = pe_as32 (expdata + 16);
2900 exp_funcbase = pe_as32 (expdata + 28);
2902 /* Use internal dll name instead of filename
2903 to enable symbolic dll linking. */
2904 dll_name = erva + pe_as32 (expdata + 12);
2906 /* Check to see if the dll has already been added to
2907 the definition list and if so return without error.
2908 This avoids multiple symbol definitions. */
2909 if (def_get_module (pe_def_file, dll_name))
2911 if (pe_dll_extra_pe_debug)
2912 printf ("%s is already loaded\n", dll_name);
2916 /* Iterate through the list of symbols. */
2917 for (i = 0; i < nexp; i++)
2919 /* Pointer to the names vector. */
2920 bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
2921 def_file_import *imp;
2922 /* Pointer to the function address vector. */
2923 bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
2926 /* Skip unwanted symbols, which are
2927 exported in buggy auto-import releases. */
2928 if (! CONST_STRNEQ (erva + name_rva, "_nm_"))
2930 /* is_data is true if the address is in the data, rdata or bss
2933 (func_rva >= data_start && func_rva < data_end)
2934 || (func_rva >= rdata_start && func_rva < rdata_end)
2935 || (func_rva >= bss_start && func_rva < bss_end);
2937 imp = def_file_add_import (pe_def_file, erva + name_rva,
2939 /* Mark symbol type. */
2940 imp->data = is_data;
2942 if (pe_dll_extra_pe_debug)
2943 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2944 __FUNCTION__, dll_name, erva + name_rva,
2945 (unsigned long) func_rva, is_data ? "(data)" : "");
2952 /* These are the main functions, called from the emulation. The first
2953 is called after the bfds are read, so we can guess at how much space
2954 we need. The second is called after everything is placed, so we
2955 can put the right values in place. */
2958 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
2960 pe_dll_id_target (bfd_get_target (abfd));
2961 process_def_file (abfd, info);
2963 if (pe_def_file->num_exports == 0 && !info->shared)
2966 generate_edata (abfd, info);
2967 build_filler_bfd (1);
2971 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2973 pe_dll_id_target (bfd_get_target (abfd));
2974 build_filler_bfd (0);
2978 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
2980 pe_dll_id_target (bfd_get_target (abfd));
2981 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2983 generate_reloc (abfd, info);
2986 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2988 /* Resize the sections. */
2989 lang_reset_memory_regions ();
2990 lang_size_sections (NULL, TRUE);
2992 /* Redo special stuff. */
2993 ldemul_after_allocation ();
2995 /* Do the assignments again. */
2996 lang_do_assignments ();
2999 fill_edata (abfd, info);
3001 if (info->shared && !info->pie)
3002 pe_data (abfd)->dll = 1;
3004 edata_s->contents = edata_d;
3005 reloc_s->contents = reloc_d;
3009 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
3011 pe_dll_id_target (bfd_get_target (abfd));
3012 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3014 generate_reloc (abfd, info);
3017 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3019 /* Resize the sections. */
3020 lang_reset_memory_regions ();
3021 lang_size_sections (NULL, TRUE);
3023 /* Redo special stuff. */
3024 ldemul_after_allocation ();
3026 /* Do the assignments again. */
3027 lang_do_assignments ();
3029 reloc_s->contents = reloc_d;
3033 pe_bfd_is_dll (bfd *abfd)
3035 return (bfd_get_format (abfd) == bfd_object
3037 && pe_data (abfd)->dll);