1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
4 Written by DJ Delorie <dj@cygnus.com>
6 This file is part of GLD, the Gnu Linker.
8 GLD 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 2, or (at your option)
13 GLD 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 GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
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;
173 autofilter_entry_type;
179 unsigned int imagebase_reloc;
182 bfd_boolean underscored;
183 autofilter_entry_type* autofilter_symbollist;
187 static autofilter_entry_type autofilter_symbollist_generic[] =
189 { STRING_COMMA_LEN (".text") },
190 /* Entry point symbols. */
191 { STRING_COMMA_LEN ("DllMain") },
192 { STRING_COMMA_LEN ("DllMainCRTStartup") },
193 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
194 /* Runtime pseudo-reloc. */
195 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
196 { STRING_COMMA_LEN ("do_pseudo_reloc") },
197 { STRING_COMMA_LEN (NULL) }
200 static autofilter_entry_type autofilter_symbollist_i386[] =
202 { STRING_COMMA_LEN (".text") },
203 /* Entry point symbols, and entry hooks. */
204 { STRING_COMMA_LEN ("cygwin_crt0") },
205 { STRING_COMMA_LEN ("DllMain@12") },
206 { STRING_COMMA_LEN ("DllEntryPoint@0") },
207 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
208 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
209 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
210 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
211 { STRING_COMMA_LEN ("cygwin_attach_dll") },
212 { STRING_COMMA_LEN ("cygwin_premain0") },
213 { STRING_COMMA_LEN ("cygwin_premain1") },
214 { STRING_COMMA_LEN ("cygwin_premain2") },
215 { STRING_COMMA_LEN ("cygwin_premain3") },
216 /* Runtime pseudo-reloc. */
217 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
218 { STRING_COMMA_LEN ("do_pseudo_reloc") },
219 /* Global vars that should not be exported. */
220 { STRING_COMMA_LEN ("impure_ptr") },
221 { STRING_COMMA_LEN ("_impure_ptr") },
222 { STRING_COMMA_LEN ("_fmode") },
223 { STRING_COMMA_LEN ("environ") },
224 { STRING_COMMA_LEN (NULL) }
227 #define PE_ARCH_i386 1
229 #define PE_ARCH_mips 3
230 #define PE_ARCH_arm 4
231 #define PE_ARCH_arm_epoc 5
232 #define PE_ARCH_arm_wince 6
234 static pe_details_type pe_detail_list[] =
249 autofilter_symbollist_i386
254 16 /* R_SH_IMAGEBASE */,
258 autofilter_symbollist_generic
267 autofilter_symbollist_generic
276 autofilter_symbollist_generic
279 "epoc-pei-arm-little",
280 "epoc-pe-arm-little",
285 autofilter_symbollist_generic
288 "pei-arm-wince-little",
289 "pe-arm-wince-little",
290 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
294 autofilter_symbollist_generic
296 { NULL, NULL, 0, 0, 0, FALSE, NULL }
299 static pe_details_type *pe_details;
301 /* Do not specify library suffix explicitly, to allow for dllized versions. */
302 static autofilter_entry_type autofilter_liblist[] =
304 { STRING_COMMA_LEN ("libcegcc") },
305 { STRING_COMMA_LEN ("libcygwin") },
306 { STRING_COMMA_LEN ("libgcc") },
307 { STRING_COMMA_LEN ("libstdc++") },
308 { STRING_COMMA_LEN ("libmingw32") },
309 { STRING_COMMA_LEN ("libmingwex") },
310 { STRING_COMMA_LEN ("libg2c") },
311 { STRING_COMMA_LEN ("libsupc++") },
312 { STRING_COMMA_LEN ("libobjc") },
313 { STRING_COMMA_LEN ("libgcj") },
314 { STRING_COMMA_LEN (NULL) }
317 static autofilter_entry_type autofilter_objlist[] =
319 { STRING_COMMA_LEN ("crt0.o") },
320 { STRING_COMMA_LEN ("crt1.o") },
321 { STRING_COMMA_LEN ("crt2.o") },
322 { STRING_COMMA_LEN ("dllcrt1.o") },
323 { STRING_COMMA_LEN ("dllcrt2.o") },
324 { STRING_COMMA_LEN ("gcrt0.o") },
325 { STRING_COMMA_LEN ("gcrt1.o") },
326 { STRING_COMMA_LEN ("gcrt2.o") },
327 { STRING_COMMA_LEN ("crtbegin.o") },
328 { STRING_COMMA_LEN ("crtend.o") },
329 { STRING_COMMA_LEN (NULL) }
332 static autofilter_entry_type autofilter_symbolprefixlist[] =
334 /* _imp_ is treated specially, as it is always underscored. */
335 /* { STRING_COMMA_LEN ("_imp_") }, */
336 /* Don't export some c++ symbols. */
337 { STRING_COMMA_LEN ("__rtti_") },
338 { STRING_COMMA_LEN ("__builtin_") },
339 /* Don't re-export auto-imported symbols. */
340 { STRING_COMMA_LEN ("_nm_") },
341 /* Don't export symbols specifying internal DLL layout. */
342 { STRING_COMMA_LEN ("_head_") },
343 { STRING_COMMA_LEN (NULL) }
346 static autofilter_entry_type autofilter_symbolsuffixlist[] =
348 { STRING_COMMA_LEN ("_iname") },
349 { STRING_COMMA_LEN (NULL) }
352 #define U(str) (pe_details->underscored ? "_" str : str)
355 pe_dll_id_target (const char *target)
359 for (i = 0; pe_detail_list[i].target_name; i++)
360 if (strcmp (pe_detail_list[i].target_name, target) == 0
361 || strcmp (pe_detail_list[i].object_target, target) == 0)
363 pe_details = pe_detail_list + i;
366 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
370 /* Helper functions for qsort. Relocs must be sorted so that we can write
371 them out by pages. */
382 reloc_sort (const void *va, const void *vb)
384 bfd_vma a = ((const reloc_data_type *) va)->vma;
385 bfd_vma b = ((const reloc_data_type *) vb)->vma;
387 return (a > b) ? 1 : ((a < b) ? -1 : 0);
391 pe_export_sort (const void *va, const void *vb)
393 const def_file_export *a = va;
394 const def_file_export *b = vb;
396 return strcmp (a->name, b->name);
399 /* Read and process the .DEF file. */
401 /* These correspond to the entries in pe_def_file->exports[]. I use
402 exported_symbol_sections[i] to tag whether or not the symbol was
403 defined, since we can't export symbols we don't have. */
405 static bfd_vma *exported_symbol_offsets;
406 static struct bfd_section **exported_symbol_sections;
407 static int export_table_size;
408 static int count_exported;
409 static int count_exported_byname;
410 static int count_with_ordinals;
411 static const char *dll_name;
412 static int min_ordinal, max_ordinal;
413 static int *exported_symbols;
415 typedef struct exclude_list_struct
418 struct exclude_list_struct *next;
423 static struct exclude_list_struct *excludes = 0;
426 pe_dll_add_excludes (const char *new_excludes, const int type)
429 char *exclude_string;
431 local_copy = xstrdup (new_excludes);
433 exclude_string = strtok (local_copy, ",:");
434 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
436 struct exclude_list_struct *new_exclude;
438 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
439 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
440 strcpy (new_exclude->string, exclude_string);
441 new_exclude->type = type;
442 new_exclude->next = excludes;
443 excludes = new_exclude;
450 is_import (const char* n)
452 return (CONST_STRNEQ (n, "__imp_"));
455 /* abfd is a bfd containing n (or NULL)
456 It can be used for contextual checks. */
459 auto_export (bfd *abfd, def_file *d, const char *n)
462 struct exclude_list_struct *ex;
463 autofilter_entry_type *afptr;
464 const char * libname = 0;
465 if (abfd && abfd->my_archive)
466 libname = lbasename (abfd->my_archive->filename);
468 for (i = 0; i < d->num_exports; i++)
469 if (strcmp (d->exports[i].name, n) == 0)
472 if (pe_dll_do_default_excludes)
477 if (pe_dll_extra_pe_debug)
478 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
479 n, abfd, abfd->my_archive);
481 /* First of all, make context checks:
482 Don't export anything from standard libs. */
485 afptr = autofilter_liblist;
489 if (strncmp (libname, afptr->name, afptr->len) == 0 )
495 /* Next, exclude symbols from certain startup objects. */
497 if (abfd && (p = lbasename (abfd->filename)))
499 afptr = autofilter_objlist;
502 if (strcmp (p, afptr->name) == 0)
508 /* Don't try to blindly exclude all symbols
509 that begin with '__'; this was tried and
510 it is too restrictive. Instead we have
511 a target specific list to use: */
512 afptr = pe_details->autofilter_symbollist;
516 if (strcmp (n, afptr->name) == 0)
522 /* Next, exclude symbols starting with ... */
523 afptr = autofilter_symbolprefixlist;
526 if (strncmp (n, afptr->name, afptr->len) == 0)
532 /* Finally, exclude symbols ending with ... */
534 afptr = autofilter_symbolsuffixlist;
537 if ((len >= afptr->len)
538 /* Add 1 to insure match with trailing '\0'. */
539 && strncmp (n + len - afptr->len, afptr->name,
540 afptr->len + 1) == 0)
547 for (ex = excludes; ex; ex = ex->next)
549 if (ex->type == 1) /* exclude-libs */
552 && ((strcmp (libname, ex->string) == 0)
553 || (strcasecmp ("ALL", ex->string) == 0)))
556 else if (strcmp (n, ex->string) == 0)
564 process_def_file (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
567 struct bfd_link_hash_entry *blhe;
569 struct bfd_section *s;
570 def_file_export *e = 0;
573 pe_def_file = def_file_empty ();
575 /* First, run around to all the objects looking for the .drectve
576 sections, and push those into the def file too. */
577 for (b = info->input_bfds; b; b = b->link_next)
579 s = bfd_get_section_by_name (b, ".drectve");
583 char *buf = xmalloc (size);
585 bfd_get_section_contents (b, s, buf, 0, size);
586 def_file_add_directive (pe_def_file, buf, size);
591 /* If we are not building a DLL, when there are no exports
592 we do not build an export table at all. */
593 if (!pe_dll_export_everything && pe_def_file->num_exports == 0
597 /* Now, maybe export everything else the default way. */
598 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
600 for (b = info->input_bfds; b; b = b->link_next)
605 symsize = bfd_get_symtab_upper_bound (b);
606 symbols = xmalloc (symsize);
607 nsyms = bfd_canonicalize_symtab (b, symbols);
609 for (j = 0; j < nsyms; j++)
611 /* We should export symbols which are either global or not
612 anything at all. (.bss data is the latter)
613 We should not export undefined symbols. */
614 if (symbols[j]->section != &bfd_und_section
615 && ((symbols[j]->flags & BSF_GLOBAL)
616 || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
618 const char *sn = symbols[j]->name;
620 /* We should not re-export imported stuff. */
625 char *name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
626 sprintf (name, "%s%s", "__imp_", sn);
628 blhe = bfd_link_hash_lookup (info->hash, name,
629 FALSE, FALSE, FALSE);
632 if (blhe && blhe->type == bfd_link_hash_defined)
636 if (pe_details->underscored && *sn == '_')
639 if (auto_export (b, pe_def_file, sn))
642 p=def_file_add_export (pe_def_file, sn, 0, -1);
643 /* Fill data flag properly, from dlltool.c. */
644 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
652 #define NE pe_def_file->num_exports
654 /* Canonicalize the export list. */
657 for (i = 0; i < NE; i++)
659 if (strchr (pe_def_file->exports[i].name, '@'))
661 /* This will preserve internal_name, which may have been
662 pointing to the same memory as name, or might not
664 int lead_at = (*pe_def_file->exports[i].name == '@');
665 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
666 char *tmp_at = strchr (tmp, '@');
671 einfo (_("%XCannot export %s: invalid export name\n"),
672 pe_def_file->exports[i].name);
673 pe_def_file->exports[i].name = tmp;
678 if (pe_dll_stdcall_aliases)
680 for (i = 0; i < NE; i++)
682 if (is_import (pe_def_file->exports[i].name))
685 if (strchr (pe_def_file->exports[i].name, '@'))
687 int lead_at = (*pe_def_file->exports[i].name == '@');
688 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
690 *(strchr (tmp, '@')) = 0;
691 if (auto_export (NULL, pe_def_file, tmp))
692 def_file_add_export (pe_def_file, tmp,
693 pe_def_file->exports[i].internal_name,
701 /* Convenience, but watch out for it changing. */
702 e = pe_def_file->exports;
704 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
705 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
707 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
711 count_exported_byname = 0;
712 count_with_ordinals = 0;
714 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
716 for (i = 0, j = 0; i < NE; i++)
718 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
720 /* This is a duplicate. */
721 if (e[j - 1].ordinal != -1
722 && e[i].ordinal != -1
723 && e[j - 1].ordinal != e[i].ordinal)
725 if (pe_dll_warn_dup_exports)
726 /* xgettext:c-format */
727 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
728 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
732 if (pe_dll_warn_dup_exports)
733 /* xgettext:c-format */
734 einfo (_("Warning, duplicate EXPORT: %s\n"),
738 if (e[i].ordinal != -1)
739 e[j - 1].ordinal = e[i].ordinal;
740 e[j - 1].flag_private |= e[i].flag_private;
741 e[j - 1].flag_constant |= e[i].flag_constant;
742 e[j - 1].flag_noname |= e[i].flag_noname;
743 e[j - 1].flag_data |= e[i].flag_data;
752 pe_def_file->num_exports = j; /* == NE */
754 for (i = 0; i < NE; i++)
758 /* Check for forward exports */
759 if (strchr (pe_def_file->exports[i].internal_name, '.'))
762 if (!pe_def_file->exports[i].flag_noname)
763 count_exported_byname++;
765 pe_def_file->exports[i].flag_forward = 1;
767 if (pe_def_file->exports[i].ordinal != -1)
769 if (max_ordinal < pe_def_file->exports[i].ordinal)
770 max_ordinal = pe_def_file->exports[i].ordinal;
771 if (min_ordinal > pe_def_file->exports[i].ordinal)
772 min_ordinal = pe_def_file->exports[i].ordinal;
773 count_with_ordinals++;
779 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
780 if (pe_details->underscored
781 && (*pe_def_file->exports[i].internal_name != '@'))
784 strcpy (name + 1, pe_def_file->exports[i].internal_name);
787 strcpy (name, pe_def_file->exports[i].internal_name);
789 blhe = bfd_link_hash_lookup (info->hash,
794 && (blhe->type == bfd_link_hash_defined
795 || (blhe->type == bfd_link_hash_common)))
798 if (!pe_def_file->exports[i].flag_noname)
799 count_exported_byname++;
801 /* Only fill in the sections. The actual offsets are computed
802 in fill_exported_offsets() after common symbols are laid
804 if (blhe->type == bfd_link_hash_defined)
805 exported_symbol_sections[i] = blhe->u.def.section;
807 exported_symbol_sections[i] = blhe->u.c.p->section;
809 if (pe_def_file->exports[i].ordinal != -1)
811 if (max_ordinal < pe_def_file->exports[i].ordinal)
812 max_ordinal = pe_def_file->exports[i].ordinal;
813 if (min_ordinal > pe_def_file->exports[i].ordinal)
814 min_ordinal = pe_def_file->exports[i].ordinal;
815 count_with_ordinals++;
818 else if (blhe && blhe->type == bfd_link_hash_undefined)
820 /* xgettext:c-format */
821 einfo (_("%XCannot export %s: symbol not defined\n"),
822 pe_def_file->exports[i].internal_name);
826 /* xgettext:c-format */
827 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
828 pe_def_file->exports[i].internal_name,
829 blhe->type, bfd_link_hash_defined);
833 /* xgettext:c-format */
834 einfo (_("%XCannot export %s: symbol not found\n"),
835 pe_def_file->exports[i].internal_name);
841 /* Build the bfd that will contain .edata and .reloc sections. */
844 build_filler_bfd (int include_edata)
846 lang_input_statement_type *filler_file;
847 filler_file = lang_add_input_file ("dll stuff",
848 lang_input_file_is_fake_enum,
850 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
851 if (filler_bfd == NULL
852 || !bfd_set_arch_mach (filler_bfd,
853 bfd_get_arch (output_bfd),
854 bfd_get_mach (output_bfd)))
856 einfo ("%X%P: can not create BFD: %E\n");
862 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
864 || !bfd_set_section_flags (filler_bfd, edata_s,
871 einfo ("%X%P: can not create .edata section: %E\n");
874 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
877 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
879 || !bfd_set_section_flags (filler_bfd, reloc_s,
886 einfo ("%X%P: can not create .reloc section: %E\n");
890 bfd_set_section_size (filler_bfd, reloc_s, 0);
892 ldlang_add_file (filler_file);
895 /* Gather all the exported symbols and build the .edata section. */
898 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
901 int name_table_size = 0;
904 /* First, we need to know how many exported symbols there are,
905 and what the range of ordinals is. */
906 if (pe_def_file->name)
907 dll_name = pe_def_file->name;
910 dll_name = abfd->filename;
912 for (dlnp = dll_name; *dlnp; dlnp++)
913 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
917 if (count_with_ordinals && max_ordinal > count_exported)
919 if (min_ordinal > max_ordinal - count_exported + 1)
920 min_ordinal = max_ordinal - count_exported + 1;
925 max_ordinal = count_exported;
928 export_table_size = max_ordinal - min_ordinal + 1;
929 exported_symbols = xmalloc (export_table_size * sizeof (int));
930 for (i = 0; i < export_table_size; i++)
931 exported_symbols[i] = -1;
933 /* Now we need to assign ordinals to those that don't have them. */
934 for (i = 0; i < NE; i++)
936 if (exported_symbol_sections[i] ||
937 pe_def_file->exports[i].flag_forward)
939 if (pe_def_file->exports[i].ordinal != -1)
941 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
942 int pi = exported_symbols[ei];
946 /* xgettext:c-format */
947 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
948 pe_def_file->exports[i].ordinal,
949 pe_def_file->exports[i].name,
950 pe_def_file->exports[pi].name);
952 exported_symbols[ei] = i;
954 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
957 /* Reserve space for the forward name. */
958 if (pe_def_file->exports[i].flag_forward)
960 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
964 next_ordinal = min_ordinal;
965 for (i = 0; i < NE; i++)
966 if ((exported_symbol_sections[i] ||
967 pe_def_file->exports[i].flag_forward) &&
968 pe_def_file->exports[i].ordinal == -1)
970 while (exported_symbols[next_ordinal - min_ordinal] != -1)
973 exported_symbols[next_ordinal - min_ordinal] = i;
974 pe_def_file->exports[i].ordinal = next_ordinal;
977 /* OK, now we can allocate some memory. */
978 edata_sz = (40 /* directory */
979 + 4 * export_table_size /* addresses */
980 + 4 * count_exported_byname /* name ptrs */
981 + 2 * count_exported_byname /* ordinals */
982 + name_table_size + strlen (dll_name) + 1);
985 /* Fill the exported symbol offsets. The preliminary work has already
986 been done in process_def_file(). */
989 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
992 struct bfd_link_hash_entry *blhe;
994 for (i = 0; i < pe_def_file->num_exports; i++)
998 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
999 if (pe_details->underscored
1000 && *pe_def_file->exports[i].internal_name != '@')
1003 strcpy (name + 1, pe_def_file->exports[i].internal_name);
1006 strcpy (name, pe_def_file->exports[i].internal_name);
1008 blhe = bfd_link_hash_lookup (info->hash,
1010 FALSE, FALSE, TRUE);
1012 if (blhe && blhe->type == bfd_link_hash_defined)
1013 exported_symbol_offsets[i] = blhe->u.def.value;
1020 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1023 unsigned char *edirectory;
1024 unsigned char *eaddresses;
1025 unsigned char *enameptrs;
1026 unsigned char *eordinals;
1032 edata_d = xmalloc (edata_sz);
1034 /* Note use of array pointer math here. */
1035 edirectory = edata_d;
1036 eaddresses = edata_d + 40;
1037 enameptrs = eaddresses + 4 * export_table_size;
1038 eordinals = enameptrs + 4 * count_exported_byname;
1039 enamestr = (char *) eordinals + 2 * count_exported_byname;
1041 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1042 + edata_s->output_section->vma - image_base)
1044 memset (edata_d, 0, edata_sz);
1045 bfd_put_32 (abfd, now, edata_d + 4);
1046 if (pe_def_file->version_major != -1)
1048 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1049 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1052 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1053 strcpy (enamestr, dll_name);
1054 enamestr += strlen (enamestr) + 1;
1055 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1056 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1057 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1058 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1059 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1060 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1062 fill_exported_offsets (abfd, info);
1064 /* Ok, now for the filling in part.
1065 Scan alphabetically - ie the ordering in the exports[] table,
1066 rather than by ordinal - the ordering in the exported_symbol[]
1067 table. See dlltool.c and:
1068 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1069 for more information. */
1071 for (s = 0; s < NE; s++)
1073 struct bfd_section *ssec = exported_symbol_sections[s];
1074 if (pe_def_file->exports[s].ordinal != -1 &&
1075 (pe_def_file->exports[s].flag_forward || ssec != NULL))
1077 int ord = pe_def_file->exports[s].ordinal;
1079 if (pe_def_file->exports[s].flag_forward)
1081 bfd_put_32 (abfd, ERVA (enamestr),
1082 eaddresses + 4 * (ord - min_ordinal));
1084 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1085 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1089 unsigned long srva = (exported_symbol_offsets[s]
1090 + ssec->output_section->vma
1091 + ssec->output_offset);
1093 bfd_put_32 (abfd, srva - image_base,
1094 eaddresses + 4 * (ord - min_ordinal));
1097 if (!pe_def_file->exports[s].flag_noname)
1099 char *ename = pe_def_file->exports[s].name;
1101 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1103 strcpy (enamestr, ename);
1104 enamestr += strlen (enamestr) + 1;
1105 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1107 pe_def_file->exports[s].hint = hint++;
1114 static struct bfd_section *current_sec;
1117 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1119 int (*cb) (arelent *, asection *))
1124 for (b = info->input_bfds; b; b = b->link_next)
1129 symsize = bfd_get_symtab_upper_bound (b);
1130 symbols = xmalloc (symsize);
1131 nsyms = bfd_canonicalize_symtab (b, symbols);
1133 for (s = b->sections; s; s = s->next)
1136 int relsize, nrelocs, i;
1137 int flags = bfd_get_section_flags (b, s);
1139 /* Skip discarded linkonce sections. */
1140 if (flags & SEC_LINK_ONCE
1141 && s->output_section == bfd_abs_section_ptr)
1146 relsize = bfd_get_reloc_upper_bound (b, s);
1147 relocs = xmalloc (relsize);
1148 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1150 for (i = 0; i < nrelocs; i++)
1152 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1154 if (!strcmp (name, sym->name))
1160 /* Warning: the allocated symbols are remembered in BFD and reused
1161 later, so don't free them! */
1162 /* free (symbols); */
1167 /* Gather all the relocations and build the .reloc section. */
1170 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1173 /* For .reloc stuff. */
1174 reloc_data_type *reloc_data;
1175 int total_relocs = 0;
1177 unsigned long sec_page = (unsigned long) -1;
1178 unsigned long page_ptr, page_count;
1181 struct bfd_section *s;
1184 for (b = info->input_bfds; b; b = b->link_next)
1185 for (s = b->sections; s; s = s->next)
1186 total_relocs += s->reloc_count;
1188 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1192 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1195 int relsize, nrelocs, i;
1197 for (s = b->sections; s; s = s->next)
1199 unsigned long sec_vma = s->output_section->vma + s->output_offset;
1203 /* If it's not loaded, we don't need to relocate it this way. */
1204 if (!(s->output_section->flags & SEC_LOAD))
1207 /* I don't know why there would be a reloc for these, but I've
1208 seen it happen - DJ */
1209 if (s->output_section == &bfd_abs_section)
1212 if (s->output_section->vma == 0)
1214 /* Huh? Shouldn't happen, but punt if it does. */
1215 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1216 s->output_section->name, s->output_section->index,
1217 s->output_section->flags);
1221 symsize = bfd_get_symtab_upper_bound (b);
1222 symbols = xmalloc (symsize);
1223 nsyms = bfd_canonicalize_symtab (b, symbols);
1225 relsize = bfd_get_reloc_upper_bound (b, s);
1226 relocs = xmalloc (relsize);
1227 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1229 for (i = 0; i < nrelocs; i++)
1231 if (pe_dll_extra_pe_debug)
1233 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1234 printf ("rel: %s\n", sym->name);
1236 if (!relocs[i]->howto->pc_relative
1237 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1240 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1242 sym_vma = (relocs[i]->addend
1245 + sym->section->output_offset
1246 + sym->section->output_section->vma);
1247 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1249 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1251 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1252 relocs[i]->howto->rightshift)
1254 #ifdef pe_use_x86_64
1255 case BITS_AND_SHIFT (64, 0):
1256 reloc_data[total_relocs].type = 10;
1260 case BITS_AND_SHIFT (32, 0):
1261 reloc_data[total_relocs].type = 3;
1264 case BITS_AND_SHIFT (16, 0):
1265 reloc_data[total_relocs].type = 2;
1268 case BITS_AND_SHIFT (16, 16):
1269 reloc_data[total_relocs].type = 4;
1270 /* FIXME: we can't know the symbol's right value
1271 yet, but we probably can safely assume that
1272 CE will relocate us in 64k blocks, so leaving
1274 reloc_data[total_relocs].extra = 0;
1277 case BITS_AND_SHIFT (26, 2):
1278 reloc_data[total_relocs].type = 5;
1281 case BITS_AND_SHIFT (24, 2):
1282 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1283 Those ARM_xxx definitions should go in proper
1285 if (relocs[i]->howto->type == 0
1286 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1287 || relocs[i]->howto->type == 5)
1288 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1289 that has already been fully processed during a
1290 previous link stage, so ignore it here. */
1294 /* xgettext:c-format */
1295 einfo (_("%XError: %d-bit reloc in dll\n"),
1296 relocs[i]->howto->bitsize);
1302 /* Warning: the allocated symbols are remembered in BFD and
1303 reused later, so don't free them! */
1307 /* At this point, we have total_relocs relocation addresses in
1308 reloc_addresses, which are all suitable for the .reloc section.
1309 We must now create the new sections. */
1310 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1312 for (i = 0; i < total_relocs; i++)
1314 unsigned long this_page = (reloc_data[i].vma >> 12);
1316 if (this_page != sec_page)
1318 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1320 sec_page = this_page;
1325 if (reloc_data[i].type == 4)
1329 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1330 reloc_d = xmalloc (reloc_sz);
1331 sec_page = (unsigned long) -1;
1333 page_ptr = (unsigned long) -1;
1336 for (i = 0; i < total_relocs; i++)
1338 unsigned long rva = reloc_data[i].vma - image_base;
1339 unsigned long this_page = (rva & ~0xfff);
1341 if (this_page != sec_page)
1343 while (reloc_sz & 3)
1344 reloc_d[reloc_sz++] = 0;
1346 if (page_ptr != (unsigned long) -1)
1347 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1349 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1350 page_ptr = reloc_sz;
1352 sec_page = this_page;
1356 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1357 reloc_d + reloc_sz);
1360 if (reloc_data[i].type == 4)
1362 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1369 while (reloc_sz & 3)
1370 reloc_d[reloc_sz++] = 0;
1372 if (page_ptr != (unsigned long) -1)
1373 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1375 while (reloc_sz < reloc_s->size)
1376 reloc_d[reloc_sz++] = 0;
1379 /* Given the exiting def_file structure, print out a .DEF file that
1380 corresponds to it. */
1383 quoteput (char *s, FILE *f, int needs_quotes)
1387 for (cp = s; *cp; cp++)
1402 if (*s == '"' || *s == '\\')
1416 pe_dll_generate_def_file (const char *pe_out_def_filename)
1419 FILE *out = fopen (pe_out_def_filename, "w");
1422 /* xgettext:c-format */
1423 einfo (_("%s: Can't open output def file %s\n"),
1424 program_name, pe_out_def_filename);
1428 if (pe_def_file->name)
1430 if (pe_def_file->is_dll)
1431 fprintf (out, "LIBRARY ");
1433 fprintf (out, "NAME ");
1435 quoteput (pe_def_file->name, out, 1);
1437 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
1438 fprintf (out, " BASE=0x%lx",
1439 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
1440 fprintf (out, "\n");
1443 if (pe_def_file->description)
1445 fprintf (out, "DESCRIPTION ");
1446 quoteput (pe_def_file->description, out, 1);
1447 fprintf (out, "\n");
1450 if (pe_def_file->version_minor != -1)
1451 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1452 pe_def_file->version_minor);
1453 else if (pe_def_file->version_major != -1)
1454 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1456 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1457 fprintf (out, "\n");
1459 if (pe_def_file->stack_commit != -1)
1460 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1461 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1462 else if (pe_def_file->stack_reserve != -1)
1463 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1465 if (pe_def_file->heap_commit != -1)
1466 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1467 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1468 else if (pe_def_file->heap_reserve != -1)
1469 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1471 if (pe_def_file->num_section_defs > 0)
1473 fprintf (out, "\nSECTIONS\n\n");
1475 for (i = 0; i < pe_def_file->num_section_defs; i++)
1478 quoteput (pe_def_file->section_defs[i].name, out, 0);
1480 if (pe_def_file->section_defs[i].class)
1482 fprintf (out, " CLASS ");
1483 quoteput (pe_def_file->section_defs[i].class, out, 0);
1486 if (pe_def_file->section_defs[i].flag_read)
1487 fprintf (out, " READ");
1489 if (pe_def_file->section_defs[i].flag_write)
1490 fprintf (out, " WRITE");
1492 if (pe_def_file->section_defs[i].flag_execute)
1493 fprintf (out, " EXECUTE");
1495 if (pe_def_file->section_defs[i].flag_shared)
1496 fprintf (out, " SHARED");
1498 fprintf (out, "\n");
1502 if (pe_def_file->num_exports > 0)
1504 fprintf (out, "EXPORTS\n");
1506 for (i = 0; i < pe_def_file->num_exports; i++)
1508 def_file_export *e = pe_def_file->exports + i;
1510 quoteput (e->name, out, 0);
1512 if (e->internal_name && strcmp (e->internal_name, e->name))
1514 fprintf (out, " = ");
1515 quoteput (e->internal_name, out, 0);
1518 if (e->ordinal != -1)
1519 fprintf (out, " @%d", e->ordinal);
1521 if (e->flag_private)
1522 fprintf (out, " PRIVATE");
1524 if (e->flag_constant)
1525 fprintf (out, " CONSTANT");
1528 fprintf (out, " NONAME");
1531 fprintf (out, " DATA");
1533 fprintf (out, "\n");
1537 if (pe_def_file->num_imports > 0)
1539 fprintf (out, "\nIMPORTS\n\n");
1541 for (i = 0; i < pe_def_file->num_imports; i++)
1543 def_file_import *im = pe_def_file->imports + i;
1546 if (im->internal_name
1547 && (!im->name || strcmp (im->internal_name, im->name)))
1549 quoteput (im->internal_name, out, 0);
1550 fprintf (out, " = ");
1553 quoteput (im->module->name, out, 0);
1557 quoteput (im->name, out, 0);
1559 fprintf (out, "%d", im->ordinal);
1561 fprintf (out, "\n");
1566 fprintf (out, _("; no contents available\n"));
1568 if (fclose (out) == EOF)
1569 /* xgettext:c-format */
1570 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1573 /* Generate the import library. */
1575 static asymbol **symtab;
1578 static const char *dll_filename;
1579 static char *dll_symname;
1581 #define UNDSEC (asection *) &bfd_und_section
1584 quick_section (bfd *abfd, const char *name, int flags, int align)
1589 sec = bfd_make_section_old_way (abfd, name);
1590 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1591 bfd_set_section_alignment (abfd, sec, align);
1592 /* Remember to undo this before trying to link internally! */
1593 sec->output_section = sec;
1595 sym = bfd_make_empty_symbol (abfd);
1596 symtab[symptr++] = sym;
1597 sym->name = sec->name;
1599 sym->flags = BSF_LOCAL;
1606 quick_symbol (bfd *abfd,
1615 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1620 sym = bfd_make_empty_symbol (abfd);
1625 symtab[symptr++] = sym;
1628 static arelent *reltab = 0;
1629 static int relcount = 0, relsize = 0;
1632 quick_reloc (bfd *abfd, int address, int which_howto, int symidx)
1634 if (relcount >= relsize - 1)
1638 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1640 reltab = xmalloc (relsize * sizeof (arelent));
1642 reltab[relcount].address = address;
1643 reltab[relcount].addend = 0;
1644 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1645 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1650 save_relocs (asection *sec)
1654 sec->relocation = reltab;
1655 sec->reloc_count = relcount;
1656 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1657 for (i = 0; i < relcount; i++)
1658 sec->orelocation[i] = sec->relocation + i;
1659 sec->orelocation[relcount] = 0;
1660 sec->flags |= SEC_RELOC;
1662 relcount = relsize = 0;
1665 /* .section .idata$2
1666 .global __head_my_dll
1683 make_head (bfd *parent)
1685 asection *id2, *id5, *id4;
1686 unsigned char *d2, *d5, *d4;
1690 oname = xmalloc (20);
1691 sprintf (oname, "d%06d.o", tmp_seq);
1694 abfd = bfd_create (oname, parent);
1695 bfd_find_target (pe_details->object_target, abfd);
1696 bfd_make_writable (abfd);
1698 bfd_set_format (abfd, bfd_object);
1699 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1702 symtab = xmalloc (6 * sizeof (asymbol *));
1703 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1704 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1705 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1706 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1707 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1709 /* OK, pay attention here. I got confused myself looking back at
1710 it. We create a four-byte section to mark the beginning of the
1711 list, and we include an offset of 4 in the section, so that the
1712 pointer to the list points to the *end* of this section, which is
1713 the start of the list of sections from other objects. */
1715 bfd_set_section_size (abfd, id2, 20);
1719 d2[0] = d2[16] = 4; /* Reloc addend. */
1720 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1721 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1722 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1725 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1726 d5 = xmalloc (PE_IDATA5_SIZE);
1728 memset (d5, 0, PE_IDATA5_SIZE);
1730 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1731 d4 = xmalloc (PE_IDATA4_SIZE);
1733 memset (d4, 0, PE_IDATA4_SIZE);
1735 bfd_set_symtab (abfd, symtab, symptr);
1737 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1738 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1739 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1741 bfd_make_readable (abfd);
1745 /* .section .idata$4
1752 .global __my_dll_iname
1757 make_tail (bfd *parent)
1759 asection *id4, *id5, *id7;
1760 unsigned char *d4, *d5, *d7;
1765 oname = xmalloc (20);
1766 sprintf (oname, "d%06d.o", tmp_seq);
1769 abfd = bfd_create (oname, parent);
1770 bfd_find_target (pe_details->object_target, abfd);
1771 bfd_make_writable (abfd);
1773 bfd_set_format (abfd, bfd_object);
1774 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1777 symtab = xmalloc (5 * sizeof (asymbol *));
1778 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1779 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1780 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1781 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1783 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1784 d4 = xmalloc (PE_IDATA4_SIZE);
1786 memset (d4, 0, PE_IDATA4_SIZE);
1788 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1789 d5 = xmalloc (PE_IDATA5_SIZE);
1791 memset (d5, 0, PE_IDATA5_SIZE);
1793 len = strlen (dll_filename) + 1;
1796 bfd_set_section_size (abfd, id7, len);
1799 strcpy ((char *) d7, dll_filename);
1801 bfd_set_symtab (abfd, symtab, symptr);
1803 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1804 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1805 bfd_set_section_contents (abfd, id7, d7, 0, len);
1807 bfd_make_readable (abfd);
1813 .global ___imp_function
1814 .global __imp__function
1816 jmp *__imp__function:
1830 .asciz "function" xlate? (add underscore, kill at) */
1832 static unsigned char jmp_ix86_bytes[] =
1834 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1842 .dw __imp_function */
1844 static unsigned char jmp_sh_bytes[] =
1846 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1850 lui $t0,<high:__imp_function>
1851 lw $t0,<low:__imp_function>
1855 static unsigned char jmp_mips_bytes[] =
1857 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1858 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1861 static unsigned char jmp_arm_bytes[] =
1863 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1864 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1870 make_one (def_file_export *exp, bfd *parent)
1872 asection *tx, *id7, *id5, *id4, *id6;
1873 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1877 unsigned char *jmp_bytes = NULL;
1878 int jmp_byte_count = 0;
1880 switch (pe_details->pe_arch)
1883 jmp_bytes = jmp_ix86_bytes;
1884 jmp_byte_count = sizeof (jmp_ix86_bytes);
1887 jmp_bytes = jmp_sh_bytes;
1888 jmp_byte_count = sizeof (jmp_sh_bytes);
1891 jmp_bytes = jmp_mips_bytes;
1892 jmp_byte_count = sizeof (jmp_mips_bytes);
1895 case PE_ARCH_arm_epoc:
1896 case PE_ARCH_arm_wince:
1897 jmp_bytes = jmp_arm_bytes;
1898 jmp_byte_count = sizeof (jmp_arm_bytes);
1904 oname = xmalloc (20);
1905 sprintf (oname, "d%06d.o", tmp_seq);
1908 abfd = bfd_create (oname, parent);
1909 bfd_find_target (pe_details->object_target, abfd);
1910 bfd_make_writable (abfd);
1912 bfd_set_format (abfd, bfd_object);
1913 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1916 symtab = xmalloc (11 * sizeof (asymbol *));
1917 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1918 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1919 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1920 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1921 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1923 if (*exp->internal_name == '@')
1925 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1927 if (! exp->flag_data)
1928 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
1929 quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
1931 /* Fastcall applies only to functions,
1932 so no need for auto-import symbol. */
1936 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1938 if (! exp->flag_data)
1939 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
1941 quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
1943 /* Symbol to reference ord/name of imported
1944 data symbol, used to implement auto-import. */
1946 quick_symbol (abfd, U ("_nm_"), U (""), exp->internal_name, id6,
1949 if (pe_dll_compat_implib)
1950 quick_symbol (abfd, U ("__imp_"), exp->internal_name, "", id5,
1953 if (! exp->flag_data)
1955 bfd_set_section_size (abfd, tx, jmp_byte_count);
1956 td = xmalloc (jmp_byte_count);
1958 memcpy (td, jmp_bytes, jmp_byte_count);
1960 switch (pe_details->pe_arch)
1963 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1966 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1969 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1970 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1971 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1974 case PE_ARCH_arm_epoc:
1975 case PE_ARCH_arm_wince:
1976 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1984 bfd_set_section_size (abfd, id7, 4);
1988 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
1991 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1992 d5 = xmalloc (PE_IDATA5_SIZE);
1994 memset (d5, 0, PE_IDATA5_SIZE);
1996 if (exp->flag_noname)
1998 d5[0] = exp->ordinal;
1999 d5[1] = exp->ordinal >> 8;
2000 d5[PE_IDATA5_SIZE - 1] = 0x80;
2004 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2008 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2009 d4 = xmalloc (PE_IDATA4_SIZE);
2011 memset (d4, 0, PE_IDATA4_SIZE);
2013 if (exp->flag_noname)
2015 d4[0] = exp->ordinal;
2016 d4[1] = exp->ordinal >> 8;
2017 d4[PE_IDATA4_SIZE - 1] = 0x80;
2021 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2025 if (exp->flag_noname)
2028 bfd_set_section_size (abfd, id6, 0);
2032 len = strlen (exp->name) + 3;
2035 bfd_set_section_size (abfd, id6, len);
2038 memset (d6, 0, len);
2039 d6[0] = exp->hint & 0xff;
2040 d6[1] = exp->hint >> 8;
2041 strcpy ((char *) d6 + 2, exp->name);
2044 bfd_set_symtab (abfd, symtab, symptr);
2046 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2047 bfd_set_section_contents (abfd, id7, d7, 0, 4);
2048 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2049 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2050 if (!exp->flag_noname)
2051 bfd_set_section_contents (abfd, id6, d6, 0, len);
2053 bfd_make_readable (abfd);
2058 make_singleton_name_thunk (const char *import, bfd *parent)
2060 /* Name thunks go to idata$4. */
2066 oname = xmalloc (20);
2067 sprintf (oname, "nmth%06d.o", tmp_seq);
2070 abfd = bfd_create (oname, parent);
2071 bfd_find_target (pe_details->object_target, abfd);
2072 bfd_make_writable (abfd);
2074 bfd_set_format (abfd, bfd_object);
2075 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2078 symtab = xmalloc (3 * sizeof (asymbol *));
2079 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2080 quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
2081 quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
2083 /* We need space for the real thunk and for the null terminator. */
2084 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2085 d4 = xmalloc (PE_IDATA4_SIZE * 2);
2087 memset (d4, 0, PE_IDATA4_SIZE * 2);
2088 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2091 bfd_set_symtab (abfd, symtab, symptr);
2093 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2095 bfd_make_readable (abfd);
2100 make_import_fixup_mark (arelent *rel)
2102 /* We convert reloc to symbol, for later reference. */
2104 static char *fixup_name = NULL;
2105 static size_t buffer_len = 0;
2107 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2109 bfd *abfd = bfd_asymbol_bfd (sym);
2110 struct bfd_link_hash_entry *bh;
2114 fixup_name = xmalloc (384);
2118 if (strlen (sym->name) + 25 > buffer_len)
2119 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2120 bigger than 20 digits long, we've got worse problems than
2121 overflowing this buffer... */
2124 /* New buffer size is length of symbol, plus 25, but
2125 then rounded up to the nearest multiple of 128. */
2126 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2127 fixup_name = xmalloc (buffer_len);
2130 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2133 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2134 current_sec, /* sym->section, */
2135 rel->address, NULL, TRUE, FALSE, &bh);
2140 /* .section .idata$2
2141 .rva __nm_thnk_SYM (singleton thunk with name of func)
2144 .rva __my_dll_iname (name of dll)
2145 .rva __fuNN_SYM (pointer to reference (address) in text) */
2148 make_import_fixup_entry (const char *name,
2149 const char *fixup_name,
2150 const char *dll_symname,
2158 oname = xmalloc (20);
2159 sprintf (oname, "fu%06d.o", tmp_seq);
2162 abfd = bfd_create (oname, parent);
2163 bfd_find_target (pe_details->object_target, abfd);
2164 bfd_make_writable (abfd);
2166 bfd_set_format (abfd, bfd_object);
2167 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2170 symtab = xmalloc (6 * sizeof (asymbol *));
2171 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2173 quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2174 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2175 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2177 bfd_set_section_size (abfd, id2, 20);
2182 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2183 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2184 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2187 bfd_set_symtab (abfd, symtab, symptr);
2189 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2191 bfd_make_readable (abfd);
2195 /* .section .rdata_runtime_pseudo_reloc
2197 .rva __fuNN_SYM (pointer to reference (address) in text) */
2200 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2201 const char *fixup_name,
2206 unsigned char *rt_rel_d;
2210 oname = xmalloc (20);
2211 sprintf (oname, "rtr%06d.o", tmp_seq);
2214 abfd = bfd_create (oname, parent);
2215 bfd_find_target (pe_details->object_target, abfd);
2216 bfd_make_writable (abfd);
2218 bfd_set_format (abfd, bfd_object);
2219 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2222 symtab = xmalloc (2 * sizeof (asymbol *));
2223 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2224 SEC_HAS_CONTENTS, 2);
2226 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2228 bfd_set_section_size (abfd, rt_rel, 8);
2229 rt_rel_d = xmalloc (8);
2230 rt_rel->contents = rt_rel_d;
2231 memset (rt_rel_d, 0, 8);
2232 bfd_put_32 (abfd, addend, rt_rel_d);
2234 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2235 save_relocs (rt_rel);
2237 bfd_set_symtab (abfd, symtab, symptr);
2239 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2241 bfd_make_readable (abfd);
2246 .rva __pei386_runtime_relocator */
2249 pe_create_runtime_relocator_reference (bfd *parent)
2251 asection *extern_rt_rel;
2252 unsigned char *extern_rt_rel_d;
2256 oname = xmalloc (20);
2257 sprintf (oname, "ertr%06d.o", tmp_seq);
2260 abfd = bfd_create (oname, parent);
2261 bfd_find_target (pe_details->object_target, abfd);
2262 bfd_make_writable (abfd);
2264 bfd_set_format (abfd, bfd_object);
2265 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2268 symtab = xmalloc (2 * sizeof (asymbol *));
2269 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2271 quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2274 bfd_set_section_size (abfd, extern_rt_rel, 4);
2275 extern_rt_rel_d = xmalloc (4);
2276 extern_rt_rel->contents = extern_rt_rel_d;
2278 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2279 save_relocs (extern_rt_rel);
2281 bfd_set_symtab (abfd, symtab, symptr);
2283 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
2285 bfd_make_readable (abfd);
2290 pe_create_import_fixup (arelent *rel, asection *s, int addend)
2293 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2294 struct bfd_link_hash_entry *name_thunk_sym;
2295 const char *name = sym->name;
2296 char *fixup_name = make_import_fixup_mark (rel);
2299 sprintf (buf, U ("_nm_thnk_%s"), name);
2301 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2303 if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2305 bfd *b = make_singleton_name_thunk (name, output_bfd);
2306 add_bfd_to_link (b, b->filename, &link_info);
2308 /* If we ever use autoimport, we have to cast text section writable. */
2309 config.text_read_only = FALSE;
2310 output_bfd->flags &= ~WP_TEXT;
2313 if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2315 extern char * pe_data_import_dll;
2316 char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2318 b = make_import_fixup_entry (name, fixup_name, dll_symname, output_bfd);
2319 add_bfd_to_link (b, b->filename, &link_info);
2324 if (link_info.pei386_runtime_pseudo_reloc)
2326 if (pe_dll_extra_pe_debug)
2327 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2328 fixup_name, addend);
2329 b = make_runtime_pseudo_reloc (name, fixup_name, addend, output_bfd);
2330 add_bfd_to_link (b, b->filename, &link_info);
2332 if (runtime_pseudo_relocs_created == 0)
2334 b = pe_create_runtime_relocator_reference (output_bfd);
2335 add_bfd_to_link (b, b->filename, &link_info);
2337 runtime_pseudo_relocs_created++;
2341 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2342 s->owner, s, rel->address, sym->name);
2350 pe_dll_generate_implib (def_file *def, const char *impfilename)
2358 dll_filename = (def->name) ? def->name : dll_name;
2359 dll_symname = xstrdup (dll_filename);
2360 for (i = 0; dll_symname[i]; i++)
2361 if (!ISALNUM (dll_symname[i]))
2362 dll_symname[i] = '_';
2364 unlink_if_ordinary (impfilename);
2366 outarch = bfd_openw (impfilename, 0);
2370 /* xgettext:c-format */
2371 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2375 /* xgettext:c-format */
2376 info_msg (_("Creating library file: %s\n"), impfilename);
2378 bfd_set_format (outarch, bfd_archive);
2379 outarch->has_armap = 1;
2381 /* Work out a reasonable size of things to put onto one line. */
2382 ar_head = make_head (outarch);
2384 for (i = 0; i < def->num_exports; i++)
2386 /* The import library doesn't know about the internal name. */
2387 char *internal = def->exports[i].internal_name;
2390 /* Don't add PRIVATE entries to import lib. */
2391 if (pe_def_file->exports[i].flag_private)
2393 def->exports[i].internal_name = def->exports[i].name;
2394 n = make_one (def->exports + i, outarch);
2397 def->exports[i].internal_name = internal;
2400 ar_tail = make_tail (outarch);
2402 if (ar_head == NULL || ar_tail == NULL)
2405 /* Now stick them all into the archive. */
2406 ar_head->next = head;
2407 ar_tail->next = ar_head;
2410 if (! bfd_set_archive_head (outarch, head))
2411 einfo ("%Xbfd_set_archive_head: %E\n");
2413 if (! bfd_close (outarch))
2414 einfo ("%Xbfd_close %s: %E\n", impfilename);
2416 while (head != NULL)
2418 bfd *n = head->next;
2425 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *link_info)
2427 lang_input_statement_type *fake_file;
2429 fake_file = lang_add_input_file (name,
2430 lang_input_file_is_fake_enum,
2432 fake_file->the_bfd = abfd;
2433 ldlang_add_file (fake_file);
2435 if (!bfd_link_add_symbols (abfd, link_info))
2436 einfo ("%Xaddsym %s: %E\n", name);
2440 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *link_info)
2442 def_file_module *module;
2444 pe_dll_id_target (bfd_get_target (output_bfd));
2449 for (module = pe_def_file->modules; module; module = module->next)
2453 dll_filename = module->name;
2454 dll_symname = xstrdup (module->name);
2455 for (i = 0; dll_symname[i]; i++)
2456 if (!ISALNUM (dll_symname[i]))
2457 dll_symname[i] = '_';
2461 for (i = 0; i < pe_def_file->num_imports; i++)
2462 if (pe_def_file->imports[i].module == module)
2464 def_file_export exp;
2465 struct bfd_link_hash_entry *blhe;
2466 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2467 /* See if we need this import. */
2468 size_t len = strlen (pe_def_file->imports[i].internal_name);
2469 char *name = xmalloc (len + 2 + 6);
2472 sprintf (name, "%s",
2473 pe_def_file->imports[i].internal_name);
2475 sprintf (name, "%s%s",U (""),
2476 pe_def_file->imports[i].internal_name);
2478 blhe = bfd_link_hash_lookup (link_info->hash, name,
2479 FALSE, FALSE, FALSE);
2481 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2484 sprintf (name, "%s%s", "__imp_",
2485 pe_def_file->imports[i].internal_name);
2487 sprintf (name, "%s%s%s", "__imp_", U (""),
2488 pe_def_file->imports[i].internal_name);
2490 blhe = bfd_link_hash_lookup (link_info->hash, name,
2491 FALSE, FALSE, FALSE);
2495 if (blhe && blhe->type == bfd_link_hash_undefined)
2501 bfd *ar_head = make_head (output_bfd);
2502 add_bfd_to_link (ar_head, ar_head->filename, link_info);
2505 exp.internal_name = pe_def_file->imports[i].internal_name;
2506 exp.name = pe_def_file->imports[i].name;
2507 exp.ordinal = pe_def_file->imports[i].ordinal;
2508 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2509 exp.flag_private = 0;
2510 exp.flag_constant = 0;
2511 exp.flag_data = pe_def_file->imports[i].data;
2512 exp.flag_noname = exp.name ? 0 : 1;
2513 one = make_one (&exp, output_bfd);
2514 add_bfd_to_link (one, one->filename, link_info);
2519 bfd *ar_tail = make_tail (output_bfd);
2520 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2527 /* We were handed a *.DLL file. Parse it and turn it into a set of
2528 IMPORTS directives in the def file. Return TRUE if the file was
2529 handled, FALSE if not. */
2532 pe_get16 (bfd *abfd, int where)
2536 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2537 bfd_bread (b, (bfd_size_type) 2, abfd);
2538 return b[0] + (b[1] << 8);
2542 pe_get32 (bfd *abfd, int where)
2546 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2547 bfd_bread (b, (bfd_size_type) 4, abfd);
2548 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2554 unsigned char *b = ptr;
2556 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2560 pe_implied_import_dll (const char *filename)
2563 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
2564 unsigned long export_rva, export_size, nsections, secptr, expptr;
2565 unsigned long exp_funcbase;
2566 unsigned char *expdata;
2568 unsigned long name_rvas, ordinals, nexp, ordbase;
2569 const char *dll_name;
2570 /* Initialization with start > end guarantees that is_data
2571 will not be set by mistake, and avoids compiler warning. */
2572 unsigned long data_start = 1;
2573 unsigned long data_end = 0;
2574 unsigned long rdata_start = 1;
2575 unsigned long rdata_end = 0;
2576 unsigned long bss_start = 1;
2577 unsigned long bss_end = 0;
2579 /* No, I can't use bfd here. kernel32.dll puts its export table in
2580 the middle of the .rdata section. */
2581 dll = bfd_openr (filename, pe_details->target_name);
2584 einfo ("%Xopen %s: %E\n", filename);
2588 /* PEI dlls seem to be bfd_objects. */
2589 if (!bfd_check_format (dll, bfd_object))
2591 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2595 /* Get pe_header, optional header and numbers of export entries. */
2596 pe_header_offset = pe_get32 (dll, 0x3c);
2597 opthdr_ofs = pe_header_offset + 4 + 20;
2598 #ifdef pe_use_x86_64
2599 num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2601 num_entries = pe_get32 (dll, opthdr_ofs + 92);
2604 if (num_entries < 1) /* No exports. */
2607 #ifdef pe_use_x86_64
2608 export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
2609 export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
2611 export_rva = pe_get32 (dll, opthdr_ofs + 96);
2612 export_size = pe_get32 (dll, opthdr_ofs + 100);
2615 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2616 secptr = (pe_header_offset + 4 + 20 +
2617 pe_get16 (dll, pe_header_offset + 4 + 16));
2620 /* Get the rva and size of the export section. */
2621 for (i = 0; i < nsections; i++)
2624 unsigned long secptr1 = secptr + 40 * i;
2625 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2626 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
2627 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
2629 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2630 bfd_bread (sname, (bfd_size_type) 8, dll);
2632 if (vaddr <= export_rva && vaddr + vsize > export_rva)
2634 expptr = fptr + (export_rva - vaddr);
2635 if (export_rva + export_size > vaddr + vsize)
2636 export_size = vsize - (export_rva - vaddr);
2641 /* Scan sections and store the base and size of the
2642 data and bss segments in data/base_start/end. */
2643 for (i = 0; i < nsections; i++)
2645 unsigned long secptr1 = secptr + 40 * i;
2646 unsigned long vsize = pe_get32 (dll, secptr1 + 8);
2647 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2648 unsigned long flags = pe_get32 (dll, secptr1 + 36);
2652 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
2653 bfd_bread (sec_name, (bfd_size_type) 8, dll);
2655 if (strcmp(sec_name,".data") == 0)
2658 data_end = vaddr + vsize;
2660 if (pe_dll_extra_pe_debug)
2661 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2662 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2664 else if (strcmp(sec_name,".rdata") == 0)
2666 rdata_start = vaddr;
2667 rdata_end = vaddr + vsize;
2669 if (pe_dll_extra_pe_debug)
2670 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2671 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2673 else if (strcmp (sec_name,".bss") == 0)
2676 bss_end = vaddr + vsize;
2678 if (pe_dll_extra_pe_debug)
2679 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2680 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2684 expdata = xmalloc (export_size);
2685 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2686 bfd_bread (expdata, (bfd_size_type) export_size, dll);
2687 erva = (char *) expdata - export_rva;
2689 if (pe_def_file == 0)
2690 pe_def_file = def_file_empty ();
2692 nexp = pe_as32 (expdata + 24);
2693 name_rvas = pe_as32 (expdata + 32);
2694 ordinals = pe_as32 (expdata + 36);
2695 ordbase = pe_as32 (expdata + 16);
2696 exp_funcbase = pe_as32 (expdata + 28);
2698 /* Use internal dll name instead of filename
2699 to enable symbolic dll linking. */
2700 dll_name = erva + pe_as32 (expdata + 12);
2702 /* Check to see if the dll has already been added to
2703 the definition list and if so return without error.
2704 This avoids multiple symbol definitions. */
2705 if (def_get_module (pe_def_file, dll_name))
2707 if (pe_dll_extra_pe_debug)
2708 printf ("%s is already loaded\n", dll_name);
2712 /* Iterate through the list of symbols. */
2713 for (i = 0; i < nexp; i++)
2715 /* Pointer to the names vector. */
2716 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
2717 def_file_import *imp;
2718 /* Pointer to the function address vector. */
2719 unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
2722 /* Skip unwanted symbols, which are
2723 exported in buggy auto-import releases. */
2724 if (! CONST_STRNEQ (erva + name_rva, "_nm_"))
2726 /* is_data is true if the address is in the data, rdata or bss
2729 (func_rva >= data_start && func_rva < data_end)
2730 || (func_rva >= rdata_start && func_rva < rdata_end)
2731 || (func_rva >= bss_start && func_rva < bss_end);
2733 imp = def_file_add_import (pe_def_file, erva + name_rva,
2735 /* Mark symbol type. */
2736 imp->data = is_data;
2738 if (pe_dll_extra_pe_debug)
2739 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2740 __FUNCTION__, dll_name, erva + name_rva,
2741 func_rva, is_data ? "(data)" : "");
2748 /* These are the main functions, called from the emulation. The first
2749 is called after the bfds are read, so we can guess at how much space
2750 we need. The second is called after everything is placed, so we
2751 can put the right values in place. */
2754 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
2756 pe_dll_id_target (bfd_get_target (abfd));
2757 process_def_file (abfd, info);
2759 if (pe_def_file->num_exports == 0 && !info->shared)
2762 generate_edata (abfd, info);
2763 build_filler_bfd (1);
2767 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2769 pe_dll_id_target (bfd_get_target (abfd));
2770 build_filler_bfd (0);
2774 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
2776 pe_dll_id_target (bfd_get_target (abfd));
2777 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2779 generate_reloc (abfd, info);
2782 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2784 /* Resize the sections. */
2785 lang_reset_memory_regions ();
2786 lang_size_sections (NULL, TRUE);
2788 /* Redo special stuff. */
2789 ldemul_after_allocation ();
2791 /* Do the assignments again. */
2792 lang_do_assignments ();
2795 fill_edata (abfd, info);
2797 if (info->shared && !info->pie)
2798 pe_data (abfd)->dll = 1;
2800 edata_s->contents = edata_d;
2801 reloc_s->contents = reloc_d;
2805 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
2807 pe_dll_id_target (bfd_get_target (abfd));
2808 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2810 generate_reloc (abfd, info);
2813 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2815 /* Resize the sections. */
2816 lang_reset_memory_regions ();
2817 lang_size_sections (NULL, TRUE);
2819 /* Redo special stuff. */
2820 ldemul_after_allocation ();
2822 /* Do the assignments again. */
2823 lang_do_assignments ();
2825 reloc_s->contents = reloc_d;