1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
3 Written by DJ Delorie <dj@cygnus.com>
5 This file is part of GLD, the Gnu Linker.
7 GLD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GLD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GLD; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
39 #include "coff/internal.h"
40 #include "../bfd/libcoff.h"
44 /* This file turns a regular Windows PE image into a DLL. Because of
45 the complexity of this operation, it has been broken down into a
46 number of separate modules which are all called by the main function
47 at the end of this file. This function is not re-entrant and is
48 normally only called once, so static variables are used to reduce
49 the number of parameters and return values required.
51 See also: ld/emultempl/pe.em. */
53 /* Auto-import feature by Paul Sokolovsky
57 1. With this feature on, DLL clients can import variables from DLL
58 without any concern from their side (for example, without any source
61 2. This is done completely in bounds of the PE specification (to be fair,
62 there's a place where it pokes nose out of, but in practise it works).
63 So, resulting module can be used with any other PE compiler/linker.
65 3. Auto-import is fully compatible with standard import method and they
66 can be mixed together.
68 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
69 reference to it; load time: negligible; virtual/physical memory: should be
70 less than effect of DLL relocation, and I sincerely hope it doesn't affect
71 DLL sharability (too much).
75 The obvious and only way to get rid of dllimport insanity is to make client
76 access variable directly in the DLL, bypassing extra dereference. I.e.,
77 whenever client contains someting like
81 address of dll_var in the command should be relocated to point into loaded
82 DLL. The aim is to make OS loader do so, and than make ld help with that.
83 Import section of PE made following way: there's a vector of structures
84 each describing imports from particular DLL. Each such structure points
85 to two other parellel vectors: one holding imported names, and one which
86 will hold address of corresponding imported name. So, the solution is
87 de-vectorize these structures, making import locations be sparse and
88 pointing directly into code. Before continuing, it is worth a note that,
89 while authors strives to make PE act ELF-like, there're some other people
90 make ELF act PE-like: elfvector, ;-) .
94 For each reference of data symbol to be imported from DLL (to set of which
95 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
96 import fixup entry is generated. That entry is of type
97 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$3 subsection. Each
98 fixup entry contains pointer to symbol's address within .text section
99 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
100 (so, DLL name is referenced by multiple entries), and pointer to symbol
101 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
102 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
103 containing imported name. Here comes that "om the edge" problem mentioned
104 above: PE specification rambles that name vector (OriginalFirstThunk)
105 should run in parallel with addresses vector (FirstThunk), i.e. that they
106 should have same number of elements and terminated with zero. We violate
107 this, since FirstThunk points directly into machine code. But in practise,
108 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
109 puts addresses to FirstThunk, not something else. It once again should be
110 noted that dll and symbol name structures are reused across fixup entries
111 and should be there anyway to support standard import stuff, so sustained
112 overhead is 20 bytes per reference. Other question is whether having several
113 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
114 done even by native compiler/linker (libth32's functions are in fact reside
115 in windows9x kernel32.dll, so if you use it, you have two
116 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
117 referencing the same PE structures several times is valid. The answer is why
118 not, prohibitting that (detecting violation) would require more work on
119 behalf of loader than not doing it.
121 See also: ld/emultempl/pe.em. */
124 add_bfd_to_link PARAMS ((bfd *, const char *, struct bfd_link_info *));
126 /* For emultempl/pe.em. */
128 def_file * pe_def_file = 0;
129 int pe_dll_export_everything = 0;
130 int pe_dll_do_default_excludes = 1;
131 int pe_dll_kill_ats = 0;
132 int pe_dll_stdcall_aliases = 0;
133 int pe_dll_warn_dup_exports = 0;
134 int pe_dll_compat_implib = 0;
135 int pe_dll_extra_pe_debug = 0;
137 /* Static variables and types. */
139 static bfd_vma image_base;
140 static bfd *filler_bfd;
141 static struct sec *edata_s, *reloc_s;
142 static unsigned char *edata_d, *reloc_d;
143 static size_t edata_sz, reloc_sz;
149 unsigned int imagebase_reloc;
161 autofilter_entry_type;
163 #define PE_ARCH_i386 1
165 #define PE_ARCH_mips 3
166 #define PE_ARCH_arm 4
167 #define PE_ARCH_arm_epoc 5
169 static pe_details_type pe_detail_list[] =
182 16 /* R_SH_IMAGEBASE */,
204 "epoc-pei-arm-little",
205 "epoc-pe-arm-little",
211 { NULL, NULL, 0, 0, 0, 0 }
214 static pe_details_type *pe_details;
216 static autofilter_entry_type autofilter_symbollist[] =
218 { "DllMain@12", 10 },
219 { "DllEntryPoint@0", 15 },
220 { "DllMainCRTStartup@12", 20 },
221 { "_cygwin_dll_entry@12", 20 },
222 { "_cygwin_crt0_common@8", 21 },
223 { "_cygwin_noncygwin_dll_entry@12", 30 },
224 { "impure_ptr", 10 },
228 /* Do not specify library suffix explicitly, to allow for dllized versions. */
229 static autofilter_entry_type autofilter_liblist[] =
232 { "libstdc++.", 10 },
233 { "libmingw32.", 11 },
237 static autofilter_entry_type autofilter_objlist[] =
245 static autofilter_entry_type autofilter_symbolprefixlist[] =
247 /* { "__imp_", 6 }, */
248 /* Do __imp_ explicitly to save time. */
250 { "__builtin_", 10 },
251 /* Don't export symbols specifying internal DLL layout. */
254 { "_impure_ptr", 11 },
255 { "cygwin_attach_dll", 17 },
256 { "cygwin_premain0", 15 },
257 { "cygwin_premain1", 15 },
258 { "cygwin_premain2", 15 },
259 { "cygwin_premain3", 15 },
264 static autofilter_entry_type autofilter_symbolsuffixlist[] =
270 #define U(str) (pe_details->underscored ? "_" str : str)
272 static int reloc_sort PARAMS ((const void *, const void *));
273 static int pe_export_sort PARAMS ((const void *, const void *));
274 static int auto_export PARAMS ((bfd *, def_file *, const char *));
275 static void process_def_file PARAMS ((bfd *, struct bfd_link_info *));
276 static void build_filler_bfd PARAMS ((int));
277 static void generate_edata PARAMS ((bfd *, struct bfd_link_info *));
278 static void fill_exported_offsets PARAMS ((bfd *, struct bfd_link_info *));
279 static void fill_edata PARAMS ((bfd *, struct bfd_link_info *));
280 static void generate_reloc PARAMS ((bfd *, struct bfd_link_info *));
281 static void quoteput PARAMS ((char *, FILE *, int));
282 static asection *quick_section PARAMS ((bfd *, const char *, int, int));
283 static void quick_symbol
284 PARAMS ((bfd *, const char *, const char *, const char *,
285 asection *, int, int));
286 static void quick_reloc PARAMS ((bfd *, int, int, int));
287 static bfd *make_head PARAMS ((bfd *));
288 static bfd *make_tail PARAMS ((bfd *));
289 static bfd *make_one PARAMS ((def_file_export *, bfd *));
290 static bfd *make_singleton_name_thunk PARAMS ((const char *, bfd *));
291 static char *make_import_fixup_mark PARAMS ((arelent *));
292 static bfd *make_import_fixup_entry
293 PARAMS ((const char *, const char *, const char *, bfd *));
294 static unsigned int pe_get16 PARAMS ((bfd *, int));
295 static unsigned int pe_get32 PARAMS ((bfd *, int));
296 static unsigned int pe_as32 PARAMS ((void *));
299 pe_dll_id_target (target)
304 for (i = 0; pe_detail_list[i].target_name; i++)
305 if (strcmp (pe_detail_list[i].target_name, target) == 0
306 || strcmp (pe_detail_list[i].object_target, target) == 0)
308 pe_details = pe_detail_list + i;
311 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
315 /* Helper functions for qsort. Relocs must be sorted so that we can write
316 them out by pages. */
330 bfd_vma a = ((reloc_data_type *) va)->vma;
331 bfd_vma b = ((reloc_data_type *) vb)->vma;
333 return (a > b) ? 1 : ((a < b) ? -1 : 0);
337 pe_export_sort (va, vb)
340 def_file_export *a = (def_file_export *) va;
341 def_file_export *b = (def_file_export *) vb;
343 return strcmp (a->name, b->name);
346 /* Read and process the .DEF file. */
348 /* These correspond to the entries in pe_def_file->exports[]. I use
349 exported_symbol_sections[i] to tag whether or not the symbol was
350 defined, since we can't export symbols we don't have. */
352 static bfd_vma *exported_symbol_offsets;
353 static struct sec **exported_symbol_sections;
354 static int export_table_size;
355 static int count_exported;
356 static int count_exported_byname;
357 static int count_with_ordinals;
358 static const char *dll_name;
359 static int min_ordinal, max_ordinal;
360 static int *exported_symbols;
362 typedef struct exclude_list_struct
365 struct exclude_list_struct *next;
369 static struct exclude_list_struct *excludes = 0;
372 pe_dll_add_excludes (new_excludes)
373 const char *new_excludes;
376 char *exclude_string;
378 local_copy = xstrdup (new_excludes);
380 exclude_string = strtok (local_copy, ",:");
381 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
383 struct exclude_list_struct *new_exclude;
385 new_exclude = ((struct exclude_list_struct *)
386 xmalloc (sizeof (struct exclude_list_struct)));
387 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 1);
388 strcpy (new_exclude->string, exclude_string);
389 new_exclude->next = excludes;
390 excludes = new_exclude;
396 /* abfd is a bfd containing n (or NULL)
397 It can be used for contextual checks. */
400 auto_export (abfd, d, n)
406 struct exclude_list_struct *ex;
407 autofilter_entry_type *afptr;
409 /* We should not re-export imported stuff. */
410 if (strncmp (n, "_imp__", 6) == 0)
413 for (i = 0; i < d->num_exports; i++)
414 if (strcmp (d->exports[i].name, n) == 0)
417 if (pe_dll_do_default_excludes)
422 if (pe_dll_extra_pe_debug)
423 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
424 n, abfd, abfd->my_archive);
426 /* First of all, make context checks:
427 Don't export anything from libgcc. */
428 if (abfd && abfd->my_archive)
430 afptr = autofilter_liblist;
434 if (strstr (abfd->my_archive->filename, afptr->name))
440 /* Next, exclude symbols from certain startup objects. */
441 afptr = autofilter_objlist;
446 (p = strstr (abfd->filename, afptr->name)) &&
447 (*(p + afptr->len - 1) == 0))
453 /* Don't try to blindly exclude all symbols
454 that begin with '__'; this was tried and
455 it is too restrictive. */
457 /* Then, exclude specific symbols. */
458 afptr = autofilter_symbollist;
461 if (strcmp (n, afptr->name) == 0)
467 /* Next, exclude symbols starting with ... */
468 afptr = autofilter_symbolprefixlist;
471 if (strncmp (n, afptr->name, afptr->len) == 0)
477 /* Finally, exclude symbols ending with ... */
479 afptr = autofilter_symbolsuffixlist;
482 if ((len >= afptr->len) &&
483 /* Add 1 to insure match with trailing '\0'. */
484 strncmp (n + len - afptr->len, afptr->name,
485 afptr->len + 1) == 0)
492 for (ex = excludes; ex; ex = ex->next)
493 if (strcmp (n, ex->string) == 0)
500 process_def_file (abfd, info)
501 bfd *abfd ATTRIBUTE_UNUSED;
502 struct bfd_link_info *info;
505 struct bfd_link_hash_entry *blhe;
508 def_file_export *e = 0;
511 pe_def_file = def_file_empty ();
513 /* First, run around to all the objects looking for the .drectve
514 sections, and push those into the def file too. */
515 for (b = info->input_bfds; b; b = b->link_next)
517 s = bfd_get_section_by_name (b, ".drectve");
520 int size = bfd_get_section_size_before_reloc (s);
521 char *buf = xmalloc (size);
523 bfd_get_section_contents (b, s, buf, 0, size);
524 def_file_add_directive (pe_def_file, buf, size);
529 /* Now, maybe export everything else the default way. */
530 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
532 for (b = info->input_bfds; b; b = b->link_next)
537 symsize = bfd_get_symtab_upper_bound (b);
538 symbols = (asymbol **) xmalloc (symsize);
539 nsyms = bfd_canonicalize_symtab (b, symbols);
541 for (j = 0; j < nsyms; j++)
543 /* We should export symbols which are either global or not
544 anything at all. (.bss data is the latter)
545 We should not export undefined symbols. */
546 if (symbols[j]->section != &bfd_und_section
547 && ((symbols[j]->flags & BSF_GLOBAL)
548 || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
550 const char *sn = symbols[j]->name;
552 /* We should not re-export imported stuff. */
554 char *name = (char *) xmalloc (strlen (sn) + 2 + 6);
555 sprintf (name, "%s%s", U("_imp_"), sn);
557 blhe = bfd_link_hash_lookup (info->hash, name,
558 false, false, false);
561 if (blhe && blhe->type == bfd_link_hash_defined)
568 if (auto_export (b, pe_def_file, sn))
571 p=def_file_add_export (pe_def_file, sn, 0, -1);
572 /* Fill data flag properly, from dlltool.c. */
573 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
581 #define NE pe_def_file->num_exports
583 /* Canonicalize the export list. */
586 for (i = 0; i < NE; i++)
588 if (strchr (pe_def_file->exports[i].name, '@'))
590 /* This will preserve internal_name, which may have been
591 pointing to the same memory as name, or might not
593 char *tmp = xstrdup (pe_def_file->exports[i].name);
595 *(strchr (tmp, '@')) = 0;
596 pe_def_file->exports[i].name = tmp;
601 if (pe_dll_stdcall_aliases)
603 for (i = 0; i < NE; i++)
605 if (strchr (pe_def_file->exports[i].name, '@'))
607 char *tmp = xstrdup (pe_def_file->exports[i].name);
609 *(strchr (tmp, '@')) = 0;
610 if (auto_export (NULL, pe_def_file, tmp))
611 def_file_add_export (pe_def_file, tmp,
612 pe_def_file->exports[i].internal_name,
620 /* Convenience, but watch out for it changing. */
621 e = pe_def_file->exports;
623 exported_symbol_offsets = (bfd_vma *) xmalloc (NE * sizeof (bfd_vma));
624 exported_symbol_sections = (struct sec **) xmalloc (NE * sizeof (struct sec *));
626 memset (exported_symbol_sections, 0, NE * sizeof (struct sec *));
630 count_exported_byname = 0;
631 count_with_ordinals = 0;
633 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]), pe_export_sort);
634 for (i = 0, j = 0; i < NE; i++)
636 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
638 /* This is a duplicate. */
639 if (e[j - 1].ordinal != -1
640 && e[i].ordinal != -1
641 && e[j - 1].ordinal != e[i].ordinal)
643 if (pe_dll_warn_dup_exports)
644 /* xgettext:c-format */
645 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
646 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
650 if (pe_dll_warn_dup_exports)
651 /* xgettext:c-format */
652 einfo (_("Warning, duplicate EXPORT: %s\n"),
656 if (e[i].ordinal != -1)
657 e[j - 1].ordinal = e[i].ordinal;
658 e[j - 1].flag_private |= e[i].flag_private;
659 e[j - 1].flag_constant |= e[i].flag_constant;
660 e[j - 1].flag_noname |= e[i].flag_noname;
661 e[j - 1].flag_data |= e[i].flag_data;
670 pe_def_file->num_exports = j; /* == NE */
672 for (i = 0; i < NE; i++)
674 char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
676 if (pe_details->underscored)
679 strcpy (name + 1, pe_def_file->exports[i].internal_name);
682 strcpy (name, pe_def_file->exports[i].internal_name);
684 blhe = bfd_link_hash_lookup (info->hash,
689 && (blhe->type == bfd_link_hash_defined
690 || (blhe->type == bfd_link_hash_common)))
693 if (!pe_def_file->exports[i].flag_noname)
694 count_exported_byname++;
696 /* Only fill in the sections. The actual offsets are computed
697 in fill_exported_offsets() after common symbols are laid
699 if (blhe->type == bfd_link_hash_defined)
700 exported_symbol_sections[i] = blhe->u.def.section;
702 exported_symbol_sections[i] = blhe->u.c.p->section;
704 if (pe_def_file->exports[i].ordinal != -1)
706 if (max_ordinal < pe_def_file->exports[i].ordinal)
707 max_ordinal = pe_def_file->exports[i].ordinal;
708 if (min_ordinal > pe_def_file->exports[i].ordinal)
709 min_ordinal = pe_def_file->exports[i].ordinal;
710 count_with_ordinals++;
713 else if (blhe && blhe->type == bfd_link_hash_undefined)
715 /* xgettext:c-format */
716 einfo (_("%XCannot export %s: symbol not defined\n"),
717 pe_def_file->exports[i].internal_name);
721 /* xgettext:c-format */
722 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
723 pe_def_file->exports[i].internal_name,
724 blhe->type, bfd_link_hash_defined);
728 /* xgettext:c-format */
729 einfo (_("%XCannot export %s: symbol not found\n"),
730 pe_def_file->exports[i].internal_name);
736 /* Build the bfd that will contain .edata and .reloc sections. */
739 build_filler_bfd (include_edata)
742 lang_input_statement_type *filler_file;
743 filler_file = lang_add_input_file ("dll stuff",
744 lang_input_file_is_fake_enum,
746 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
747 if (filler_bfd == NULL
748 || !bfd_set_arch_mach (filler_bfd,
749 bfd_get_arch (output_bfd),
750 bfd_get_mach (output_bfd)))
752 einfo ("%X%P: can not create BFD %E\n");
758 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
760 || !bfd_set_section_flags (filler_bfd, edata_s,
767 einfo ("%X%P: can not create .edata section: %E\n");
770 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
773 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
775 || !bfd_set_section_flags (filler_bfd, reloc_s,
782 einfo ("%X%P: can not create .reloc section: %E\n");
786 bfd_set_section_size (filler_bfd, reloc_s, 0);
788 ldlang_add_file (filler_file);
791 /* Gather all the exported symbols and build the .edata section. */
794 generate_edata (abfd, info)
796 struct bfd_link_info *info ATTRIBUTE_UNUSED;
799 int name_table_size = 0;
802 /* First, we need to know how many exported symbols there are,
803 and what the range of ordinals is. */
804 if (pe_def_file->name)
805 dll_name = pe_def_file->name;
808 dll_name = abfd->filename;
810 for (dlnp = dll_name; *dlnp; dlnp++)
811 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
815 if (count_with_ordinals && max_ordinal > count_exported)
817 if (min_ordinal > max_ordinal - count_exported + 1)
818 min_ordinal = max_ordinal - count_exported + 1;
823 max_ordinal = count_exported;
826 export_table_size = max_ordinal - min_ordinal + 1;
827 exported_symbols = (int *) xmalloc (export_table_size * sizeof (int));
828 for (i = 0; i < export_table_size; i++)
829 exported_symbols[i] = -1;
831 /* Now we need to assign ordinals to those that don't have them. */
832 for (i = 0; i < NE; i++)
834 if (exported_symbol_sections[i])
836 if (pe_def_file->exports[i].ordinal != -1)
838 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
839 int pi = exported_symbols[ei];
843 /* xgettext:c-format */
844 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
845 pe_def_file->exports[i].ordinal,
846 pe_def_file->exports[i].name,
847 pe_def_file->exports[pi].name);
849 exported_symbols[ei] = i;
851 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
855 next_ordinal = min_ordinal;
856 for (i = 0; i < NE; i++)
857 if (exported_symbol_sections[i])
858 if (pe_def_file->exports[i].ordinal == -1)
860 while (exported_symbols[next_ordinal - min_ordinal] != -1)
863 exported_symbols[next_ordinal - min_ordinal] = i;
864 pe_def_file->exports[i].ordinal = next_ordinal;
867 /* OK, now we can allocate some memory. */
868 edata_sz = (40 /* directory */
869 + 4 * export_table_size /* addresses */
870 + 4 * count_exported_byname /* name ptrs */
871 + 2 * count_exported_byname /* ordinals */
872 + name_table_size + strlen (dll_name) + 1);
875 /* Fill the exported symbol offsets. The preliminary work has already
876 been done in process_def_file(). */
879 fill_exported_offsets (abfd, info)
880 bfd *abfd ATTRIBUTE_UNUSED;
881 struct bfd_link_info *info;
884 struct bfd_link_hash_entry *blhe;
886 for (i = 0; i < pe_def_file->num_exports; i++)
888 char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
890 if (pe_details->underscored)
893 strcpy (name + 1, pe_def_file->exports[i].internal_name);
896 strcpy (name, pe_def_file->exports[i].internal_name);
898 blhe = bfd_link_hash_lookup (info->hash,
902 if (blhe && (blhe->type == bfd_link_hash_defined))
903 exported_symbol_offsets[i] = blhe->u.def.value;
910 fill_edata (abfd, info)
912 struct bfd_link_info *info ATTRIBUTE_UNUSED;
915 unsigned char *edirectory;
916 unsigned long *eaddresses;
917 unsigned long *enameptrs;
918 unsigned short *eordinals;
919 unsigned char *enamestr;
924 edata_d = (unsigned char *) xmalloc (edata_sz);
926 /* Note use of array pointer math here. */
927 edirectory = edata_d;
928 eaddresses = (unsigned long *) (edata_d + 40);
929 enameptrs = eaddresses + export_table_size;
930 eordinals = (unsigned short *) (enameptrs + count_exported_byname);
931 enamestr = (char *) (eordinals + count_exported_byname);
933 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
935 memset (edata_d, 0, edata_sz);
936 bfd_put_32 (abfd, now, edata_d + 4);
937 if (pe_def_file->version_major != -1)
939 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
940 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
943 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
944 strcpy (enamestr, dll_name);
945 enamestr += strlen (enamestr) + 1;
946 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
947 bfd_put_32 (abfd, export_table_size, edata_d + 20);
948 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
949 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
950 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
951 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
953 fill_exported_offsets (abfd, info);
955 /* Ok, now for the filling in part. */
957 for (i = 0; i < export_table_size; i++)
959 int s = exported_symbols[i];
963 struct sec *ssec = exported_symbol_sections[s];
964 unsigned long srva = (exported_symbol_offsets[s]
965 + ssec->output_section->vma
966 + ssec->output_offset);
967 int ord = pe_def_file->exports[s].ordinal;
969 bfd_put_32 (abfd, srva - image_base,
970 (void *) (eaddresses + ord - min_ordinal));
972 if (!pe_def_file->exports[s].flag_noname)
974 char *ename = pe_def_file->exports[s].name;
975 bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs);
977 strcpy (enamestr, ename);
978 enamestr += strlen (enamestr) + 1;
979 bfd_put_16 (abfd, ord - min_ordinal, (void *) eordinals);
981 pe_def_file->exports[s].hint = hint++;
988 static struct sec *current_sec;
991 pe_walk_relocs_of_symbol (info, name, cb)
992 struct bfd_link_info *info;
994 int (*cb) (arelent *, asection *);
999 for (b = info->input_bfds; b; b = b->link_next)
1004 symsize = bfd_get_symtab_upper_bound (b);
1005 symbols = (asymbol **) xmalloc (symsize);
1006 nsyms = bfd_canonicalize_symtab (b, symbols);
1008 for (s = b->sections; s; s = s->next)
1011 int relsize, nrelocs, i;
1012 int flags = bfd_get_section_flags (b, s);
1014 /* Skip discarded linkonce sections. */
1015 if (flags & SEC_LINK_ONCE
1016 && s->output_section == bfd_abs_section_ptr)
1021 relsize = bfd_get_reloc_upper_bound (b, s);
1022 relocs = (arelent **) xmalloc ((size_t) relsize);
1023 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1025 for (i = 0; i < nrelocs; i++)
1027 struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1029 if (!strcmp (name, sym->name))
1035 /* Warning: the allocated symbols are remembered in BFD and reused
1036 later, so don't free them! */
1037 /* free (symbols); */
1042 /* Gather all the relocations and build the .reloc section. */
1045 generate_reloc (abfd, info)
1047 struct bfd_link_info *info;
1050 /* For .reloc stuff. */
1051 reloc_data_type *reloc_data;
1052 int total_relocs = 0;
1054 unsigned long sec_page = (unsigned long) (-1);
1055 unsigned long page_ptr, page_count;
1061 for (b = info->input_bfds; b; b = b->link_next)
1062 for (s = b->sections; s; s = s->next)
1063 total_relocs += s->reloc_count;
1066 (reloc_data_type *) xmalloc (total_relocs * sizeof (reloc_data_type));
1070 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1073 int relsize, nrelocs, i;
1075 for (s = b->sections; s; s = s->next)
1077 unsigned long sec_vma = s->output_section->vma + s->output_offset;
1081 /* If it's not loaded, we don't need to relocate it this way. */
1082 if (!(s->output_section->flags & SEC_LOAD))
1085 /* I don't know why there would be a reloc for these, but I've
1086 seen it happen - DJ */
1087 if (s->output_section == &bfd_abs_section)
1090 if (s->output_section->vma == 0)
1092 /* Huh? Shouldn't happen, but punt if it does. */
1093 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1094 s->output_section->name, s->output_section->index,
1095 s->output_section->flags);
1099 symsize = bfd_get_symtab_upper_bound (b);
1100 symbols = (asymbol **) xmalloc (symsize);
1101 nsyms = bfd_canonicalize_symtab (b, symbols);
1103 relsize = bfd_get_reloc_upper_bound (b, s);
1104 relocs = (arelent **) xmalloc ((size_t) relsize);
1105 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1107 for (i = 0; i < nrelocs; i++)
1109 if (pe_dll_extra_pe_debug)
1111 struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1112 printf("rel: %s\n",sym->name);
1114 if (!relocs[i]->howto->pc_relative
1115 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1118 struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1120 sym_vma = (relocs[i]->addend
1123 + sym->section->output_offset
1124 + sym->section->output_section->vma);
1125 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1127 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1129 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1130 relocs[i]->howto->rightshift)
1132 case BITS_AND_SHIFT (32, 0):
1133 reloc_data[total_relocs].type = 3;
1136 case BITS_AND_SHIFT (16, 0):
1137 reloc_data[total_relocs].type = 2;
1140 case BITS_AND_SHIFT (16, 16):
1141 reloc_data[total_relocs].type = 4;
1142 /* FIXME: we can't know the symbol's right value
1143 yet, but we probably can safely assume that
1144 CE will relocate us in 64k blocks, so leaving
1146 reloc_data[total_relocs].extra = 0;
1149 case BITS_AND_SHIFT (26, 2):
1150 reloc_data[total_relocs].type = 5;
1154 /* xgettext:c-format */
1155 einfo (_("%XError: %d-bit reloc in dll\n"),
1156 relocs[i]->howto->bitsize);
1162 /* Warning: the allocated symbols are remembered in BFD and
1163 reused later, so don't free them! */
1170 /* At this point, we have total_relocs relocation addresses in
1171 reloc_addresses, which are all suitable for the .reloc section.
1172 We must now create the new sections. */
1173 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1175 for (i = 0; i < total_relocs; i++)
1177 unsigned long this_page = (reloc_data[i].vma >> 12);
1179 if (this_page != sec_page)
1181 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1183 sec_page = this_page;
1188 if (reloc_data[i].type == 4)
1192 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1193 reloc_d = (unsigned char *) xmalloc (reloc_sz);
1194 sec_page = (unsigned long) (-1);
1196 page_ptr = (unsigned long) (-1);
1199 for (i = 0; i < total_relocs; i++)
1201 unsigned long rva = reloc_data[i].vma - image_base;
1202 unsigned long this_page = (rva & ~0xfff);
1204 if (this_page != sec_page)
1206 while (reloc_sz & 3)
1207 reloc_d[reloc_sz++] = 0;
1209 if (page_ptr != (unsigned long) (-1))
1210 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1212 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1213 page_ptr = reloc_sz;
1215 sec_page = this_page;
1219 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1220 reloc_d + reloc_sz);
1223 if (reloc_data[i].type == 4)
1225 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1232 while (reloc_sz & 3)
1233 reloc_d[reloc_sz++] = 0;
1235 if (page_ptr != (unsigned long) (-1))
1236 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1238 while (reloc_sz < reloc_s->_raw_size)
1239 reloc_d[reloc_sz++] = 0;
1242 /* Given the exiting def_file structure, print out a .DEF file that
1243 corresponds to it. */
1246 quoteput (s, f, needs_quotes)
1253 for (cp = s; *cp; cp++)
1268 if (*s == '"' || *s == '\\')
1282 pe_dll_generate_def_file (pe_out_def_filename)
1283 const char *pe_out_def_filename;
1286 FILE *out = fopen (pe_out_def_filename, "w");
1289 /* xgettext:c-format */
1290 einfo (_("%s: Can't open output def file %s\n"),
1291 program_name, pe_out_def_filename);
1295 if (pe_def_file->name)
1297 if (pe_def_file->is_dll)
1298 fprintf (out, "LIBRARY ");
1300 fprintf (out, "NAME ");
1302 quoteput (pe_def_file->name, out, 1);
1304 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
1305 fprintf (out, " BASE=0x%lx",
1306 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
1307 fprintf (out, "\n");
1310 if (pe_def_file->description)
1312 fprintf (out, "DESCRIPTION ");
1313 quoteput (pe_def_file->description, out, 1);
1314 fprintf (out, "\n");
1317 if (pe_def_file->version_minor != -1)
1318 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1319 pe_def_file->version_minor);
1320 else if (pe_def_file->version_major != -1)
1321 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1323 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1324 fprintf (out, "\n");
1326 if (pe_def_file->stack_commit != -1)
1327 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1328 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1329 else if (pe_def_file->stack_reserve != -1)
1330 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1332 if (pe_def_file->heap_commit != -1)
1333 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1334 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1335 else if (pe_def_file->heap_reserve != -1)
1336 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1338 if (pe_def_file->num_section_defs > 0)
1340 fprintf (out, "\nSECTIONS\n\n");
1342 for (i = 0; i < pe_def_file->num_section_defs; i++)
1345 quoteput (pe_def_file->section_defs[i].name, out, 0);
1347 if (pe_def_file->section_defs[i].class)
1349 fprintf (out, " CLASS ");
1350 quoteput (pe_def_file->section_defs[i].class, out, 0);
1353 if (pe_def_file->section_defs[i].flag_read)
1354 fprintf (out, " READ");
1356 if (pe_def_file->section_defs[i].flag_write)
1357 fprintf (out, " WRITE");
1359 if (pe_def_file->section_defs[i].flag_execute)
1360 fprintf (out, " EXECUTE");
1362 if (pe_def_file->section_defs[i].flag_shared)
1363 fprintf (out, " SHARED");
1365 fprintf (out, "\n");
1369 if (pe_def_file->num_exports > 0)
1371 fprintf (out, "EXPORTS\n");
1373 for (i = 0; i < pe_def_file->num_exports; i++)
1375 def_file_export *e = pe_def_file->exports + i;
1377 quoteput (e->name, out, 0);
1379 if (e->internal_name && strcmp (e->internal_name, e->name))
1381 fprintf (out, " = ");
1382 quoteput (e->internal_name, out, 0);
1385 if (e->ordinal != -1)
1386 fprintf (out, " @%d", e->ordinal);
1388 if (e->flag_private)
1389 fprintf (out, " PRIVATE");
1391 if (e->flag_constant)
1392 fprintf (out, " CONSTANT");
1395 fprintf (out, " NONAME");
1398 fprintf (out, " DATA");
1400 fprintf (out, "\n");
1404 if (pe_def_file->num_imports > 0)
1406 fprintf (out, "\nIMPORTS\n\n");
1408 for (i = 0; i < pe_def_file->num_imports; i++)
1410 def_file_import *im = pe_def_file->imports + i;
1413 if (im->internal_name
1414 && (!im->name || strcmp (im->internal_name, im->name)))
1416 quoteput (im->internal_name, out, 0);
1417 fprintf (out, " = ");
1420 quoteput (im->module->name, out, 0);
1424 quoteput (im->name, out, 0);
1426 fprintf (out, "%d", im->ordinal);
1428 fprintf (out, "\n");
1433 fprintf (out, _("; no contents available\n"));
1435 if (fclose (out) == EOF)
1436 /* xgettext:c-format */
1437 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1440 /* Generate the import library. */
1442 static asymbol **symtab;
1445 static const char *dll_filename;
1446 static char *dll_symname;
1448 #define UNDSEC (asection *) &bfd_und_section
1451 quick_section (abfd, name, flags, align)
1460 sec = bfd_make_section_old_way (abfd, name);
1461 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1462 bfd_set_section_alignment (abfd, sec, align);
1463 /* Remember to undo this before trying to link internally! */
1464 sec->output_section = sec;
1466 sym = bfd_make_empty_symbol (abfd);
1467 symtab[symptr++] = sym;
1468 sym->name = sec->name;
1470 sym->flags = BSF_LOCAL;
1477 quick_symbol (abfd, n1, n2, n3, sec, flags, addr)
1487 char *name = (char *) xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1492 sym = bfd_make_empty_symbol (abfd);
1497 symtab[symptr++] = sym;
1500 static arelent *reltab = 0;
1501 static int relcount = 0, relsize = 0;
1504 quick_reloc (abfd, address, which_howto, symidx)
1510 if (relcount >= (relsize - 1))
1514 reltab = (arelent *) xrealloc (reltab, relsize * sizeof (arelent));
1516 reltab = (arelent *) xmalloc (relsize * sizeof (arelent));
1518 reltab[relcount].address = address;
1519 reltab[relcount].addend = 0;
1520 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1521 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1526 save_relocs (asection *sec)
1530 sec->relocation = reltab;
1531 sec->reloc_count = relcount;
1532 sec->orelocation = (arelent **) xmalloc ((relcount + 1) * sizeof (arelent *));
1533 for (i = 0; i < relcount; i++)
1534 sec->orelocation[i] = sec->relocation + i;
1535 sec->orelocation[relcount] = 0;
1536 sec->flags |= SEC_RELOC;
1538 relcount = relsize = 0;
1541 /* .section .idata$2
1542 .global __head_my_dll
1562 asection *id2, *id5, *id4;
1563 unsigned char *d2, *d5, *d4;
1567 oname = (char *) xmalloc (20);
1568 sprintf (oname, "d%06d.o", tmp_seq);
1571 abfd = bfd_create (oname, parent);
1572 bfd_find_target (pe_details->object_target, abfd);
1573 bfd_make_writable (abfd);
1575 bfd_set_format (abfd, bfd_object);
1576 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1579 symtab = (asymbol **) xmalloc (6 * sizeof (asymbol *));
1580 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1581 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1582 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1583 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1584 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1586 /* OK, pay attention here. I got confused myself looking back at
1587 it. We create a four-byte section to mark the beginning of the
1588 list, and we include an offset of 4 in the section, so that the
1589 pointer to the list points to the *end* of this section, which is
1590 the start of the list of sections from other objects. */
1592 bfd_set_section_size (abfd, id2, 20);
1593 d2 = (unsigned char *) xmalloc (20);
1596 d2[0] = d2[16] = 4; /* Reloc addend. */
1597 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1598 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1599 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1602 bfd_set_section_size (abfd, id5, 4);
1603 d5 = (unsigned char *) xmalloc (4);
1607 bfd_set_section_size (abfd, id4, 4);
1608 d4 = (unsigned char *) xmalloc (4);
1612 bfd_set_symtab (abfd, symtab, symptr);
1614 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1615 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1616 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1618 bfd_make_readable (abfd);
1622 /* .section .idata$4
1627 .global __my_dll_iname
1635 asection *id4, *id5, *id7;
1636 unsigned char *d4, *d5, *d7;
1641 oname = (char *) xmalloc (20);
1642 sprintf (oname, "d%06d.o", tmp_seq);
1645 abfd = bfd_create (oname, parent);
1646 bfd_find_target (pe_details->object_target, abfd);
1647 bfd_make_writable (abfd);
1649 bfd_set_format (abfd, bfd_object);
1650 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1653 symtab = (asymbol **) xmalloc (5 * sizeof (asymbol *));
1654 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1655 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1656 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1657 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1659 bfd_set_section_size (abfd, id4, 4);
1660 d4 = (unsigned char *) xmalloc (4);
1664 bfd_set_section_size (abfd, id5, 4);
1665 d5 = (unsigned char *) xmalloc (4);
1669 len = strlen (dll_filename) + 1;
1672 bfd_set_section_size (abfd, id7, len);
1673 d7 = (unsigned char *) xmalloc (len);
1675 strcpy (d7, dll_filename);
1677 bfd_set_symtab (abfd, symtab, symptr);
1679 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1680 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1681 bfd_set_section_contents (abfd, id7, d7, 0, len);
1683 bfd_make_readable (abfd);
1689 .global ___imp_function
1690 .global __imp__function
1692 jmp *__imp__function:
1706 .asciz "function" xlate? (add underscore, kill at) */
1708 static unsigned char jmp_ix86_bytes[] =
1710 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1718 .dw __imp_function */
1720 static unsigned char jmp_sh_bytes[] =
1722 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1726 lui $t0,<high:__imp_function>
1727 lw $t0,<low:__imp_function>
1731 static unsigned char jmp_mips_bytes[] =
1733 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1734 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1738 make_one (exp, parent)
1739 def_file_export *exp;
1742 asection *tx, *id7, *id5, *id4, *id6;
1743 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1747 unsigned char *jmp_bytes = NULL;
1748 int jmp_byte_count = 0;
1750 switch (pe_details->pe_arch)
1753 jmp_bytes = jmp_ix86_bytes;
1754 jmp_byte_count = sizeof (jmp_ix86_bytes);
1757 jmp_bytes = jmp_sh_bytes;
1758 jmp_byte_count = sizeof (jmp_sh_bytes);
1761 jmp_bytes = jmp_mips_bytes;
1762 jmp_byte_count = sizeof (jmp_mips_bytes);
1768 oname = (char *) xmalloc (20);
1769 sprintf (oname, "d%06d.o", tmp_seq);
1772 abfd = bfd_create (oname, parent);
1773 bfd_find_target (pe_details->object_target, abfd);
1774 bfd_make_writable (abfd);
1776 bfd_set_format (abfd, bfd_object);
1777 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1780 symtab = (asymbol **) xmalloc (11 * sizeof (asymbol *));
1781 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1782 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1783 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1784 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1785 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1786 if (! exp->flag_data)
1787 quick_symbol (abfd, U (""), exp->internal_name, "", tx, BSF_GLOBAL, 0);
1788 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC, BSF_GLOBAL, 0);
1789 quick_symbol (abfd, U ("_imp__"), exp->internal_name, "", id5, BSF_GLOBAL, 0);
1790 /* Symbol to reference ord/name of imported
1791 symbol, used to implement auto-import. */
1792 quick_symbol (abfd, U("_nm__"), exp->internal_name, "", id6, BSF_GLOBAL, 0);
1793 if (pe_dll_compat_implib)
1794 quick_symbol (abfd, U ("__imp_"), exp->internal_name, "",
1795 id5, BSF_GLOBAL, 0);
1797 if (! exp->flag_data)
1799 bfd_set_section_size (abfd, tx, jmp_byte_count);
1800 td = (unsigned char *) xmalloc (jmp_byte_count);
1802 memcpy (td, jmp_bytes, jmp_byte_count);
1804 switch (pe_details->pe_arch)
1807 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1810 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1813 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1814 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1815 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1823 bfd_set_section_size (abfd, id7, 4);
1824 d7 = (unsigned char *) xmalloc (4);
1827 quick_reloc (abfd, 0, BFD_RELOC_RVA, 6);
1830 bfd_set_section_size (abfd, id5, 4);
1831 d5 = (unsigned char *) xmalloc (4);
1835 if (exp->flag_noname)
1837 d5[0] = exp->ordinal;
1838 d5[1] = exp->ordinal >> 8;
1843 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1847 bfd_set_section_size (abfd, id4, 4);
1848 d4 = (unsigned char *) xmalloc (4);
1852 if (exp->flag_noname)
1854 d4[0] = exp->ordinal;
1855 d4[1] = exp->ordinal >> 8;
1860 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1864 if (exp->flag_noname)
1867 bfd_set_section_size (abfd, id6, 0);
1871 len = strlen (exp->name) + 3;
1874 bfd_set_section_size (abfd, id6, len);
1875 d6 = (unsigned char *) xmalloc (len);
1877 memset (d6, 0, len);
1878 d6[0] = exp->hint & 0xff;
1879 d6[1] = exp->hint >> 8;
1880 strcpy (d6 + 2, exp->name);
1883 bfd_set_symtab (abfd, symtab, symptr);
1885 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
1886 bfd_set_section_contents (abfd, id7, d7, 0, 4);
1887 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1888 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1889 if (!exp->flag_noname)
1890 bfd_set_section_contents (abfd, id6, d6, 0, len);
1892 bfd_make_readable (abfd);
1897 make_singleton_name_thunk (import, parent)
1901 /* Name thunks go to idata$4. */
1907 oname = (char *) xmalloc (20);
1908 sprintf (oname, "nmth%06d.o", tmp_seq);
1911 abfd = bfd_create (oname, parent);
1912 bfd_find_target (pe_details->object_target, abfd);
1913 bfd_make_writable (abfd);
1915 bfd_set_format (abfd, bfd_object);
1916 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1919 symtab = (asymbol **) xmalloc (3 * sizeof (asymbol *));
1920 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1921 quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
1922 quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
1924 bfd_set_section_size (abfd, id4, 8);
1925 d4 = (unsigned char *) xmalloc (4);
1928 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1931 bfd_set_symtab (abfd, symtab, symptr);
1933 bfd_set_section_contents (abfd, id4, d4, 0, 8);
1935 bfd_make_readable (abfd);
1940 make_import_fixup_mark (rel)
1943 /* We convert reloc to symbol, for later reference. */
1945 static char *fixup_name = NULL;
1946 static size_t buffer_len = 0;
1948 struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
1950 bfd *abfd = bfd_asymbol_bfd (sym);
1951 struct coff_link_hash_entry *myh = NULL;
1955 fixup_name = (char *) xmalloc (384);
1959 if (strlen (sym->name) + 25 > buffer_len)
1960 /* Assume 25 chars for "__fu" + counter + "_". If counter is
1961 bigger than 20 digits long, we've got worse problems than
1962 overflowing this buffer... */
1965 /* New buffer size is length of symbol, plus 25, but then
1966 rounded up to the nearest multiple of 128. */
1967 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
1968 fixup_name = (char *) xmalloc (buffer_len);
1971 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
1973 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
1974 current_sec, /* sym->section, */
1975 rel->address, NULL, true, false,
1976 (struct bfd_link_hash_entry **) &myh);
1979 printf ("type:%d\n", myh->type);
1980 printf ("%s\n", myh->root.u.def.section->name);
1985 /* .section .idata$3
1986 .rva __nm_thnk_SYM (singleton thunk with name of func)
1989 .rva __my_dll_iname (name of dll)
1990 .rva __fuNN_SYM (pointer to reference (address) in text) */
1993 make_import_fixup_entry (name, fixup_name, dll_symname,parent)
1995 const char *fixup_name;
1996 const char *dll_symname;
2004 oname = (char *) xmalloc (20);
2005 sprintf (oname, "fu%06d.o", tmp_seq);
2008 abfd = bfd_create (oname, parent);
2009 bfd_find_target (pe_details->object_target, abfd);
2010 bfd_make_writable (abfd);
2012 bfd_set_format (abfd, bfd_object);
2013 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2016 symtab = (asymbol **) xmalloc (6 * sizeof (asymbol *));
2017 id3 = quick_section (abfd, ".idata$3", SEC_HAS_CONTENTS, 2);
2020 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
2022 quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2023 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2024 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2026 bfd_set_section_size (abfd, id3, 20);
2027 d3 = (unsigned char *) xmalloc (20);
2031 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2032 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2033 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2036 bfd_set_symtab (abfd, symtab, symptr);
2038 bfd_set_section_contents (abfd, id3, d3, 0, 20);
2040 bfd_make_readable (abfd);
2045 pe_create_import_fixup (rel)
2049 struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
2050 struct bfd_link_hash_entry *name_thunk_sym;
2051 const char *name = sym->name;
2052 char *fixup_name = make_import_fixup_mark (rel);
2054 sprintf (buf, U ("_nm_thnk_%s"), name);
2056 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2058 if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2060 bfd *b = make_singleton_name_thunk (name, output_bfd);
2061 add_bfd_to_link (b, b->filename, &link_info);
2063 /* If we ever use autoimport, we have to cast text section writable. */
2064 config.text_read_only = false;
2068 extern char * pe_data_import_dll;
2069 char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2071 bfd *b = make_import_fixup_entry (name, fixup_name, dll_symname,
2073 add_bfd_to_link (b, b->filename, &link_info);
2079 pe_dll_generate_implib (def, impfilename)
2081 const char *impfilename;
2089 dll_filename = (def->name) ? def->name : dll_name;
2090 dll_symname = xstrdup (dll_filename);
2091 for (i = 0; dll_symname[i]; i++)
2092 if (!ISALNUM (dll_symname[i]))
2093 dll_symname[i] = '_';
2095 unlink (impfilename);
2097 outarch = bfd_openw (impfilename, 0);
2101 /* xgettext:c-format */
2102 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2106 /* xgettext:c-format */
2107 einfo (_("Creating library file: %s\n"), impfilename);
2109 bfd_set_format (outarch, bfd_archive);
2110 outarch->has_armap = 1;
2112 /* Work out a reasonable size of things to put onto one line. */
2113 ar_head = make_head (outarch);
2115 for (i = 0; i < def->num_exports; i++)
2117 /* The import library doesn't know about the internal name. */
2118 char *internal = def->exports[i].internal_name;
2121 def->exports[i].internal_name = def->exports[i].name;
2122 n = make_one (def->exports + i, outarch);
2125 def->exports[i].internal_name = internal;
2128 ar_tail = make_tail (outarch);
2130 if (ar_head == NULL || ar_tail == NULL)
2133 /* Now stick them all into the archive. */
2134 ar_head->next = head;
2135 ar_tail->next = ar_head;
2138 if (! bfd_set_archive_head (outarch, head))
2139 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
2141 if (! bfd_close (outarch))
2142 einfo ("%Xbfd_close %s: %s\n", impfilename, bfd_errmsg (bfd_get_error ()));
2144 while (head != NULL)
2146 bfd *n = head->next;
2153 add_bfd_to_link (abfd, name, link_info)
2156 struct bfd_link_info *link_info;
2158 lang_input_statement_type *fake_file;
2160 fake_file = lang_add_input_file (name,
2161 lang_input_file_is_fake_enum,
2163 fake_file->the_bfd = abfd;
2164 ldlang_add_file (fake_file);
2166 if (!bfd_link_add_symbols (abfd, link_info))
2167 einfo ("%Xaddsym %s: %s\n", name, bfd_errmsg (bfd_get_error ()));
2171 pe_process_import_defs (output_bfd, link_info)
2173 struct bfd_link_info *link_info;
2175 def_file_module *module;
2177 pe_dll_id_target (bfd_get_target (output_bfd));
2182 for (module = pe_def_file->modules; module; module = module->next)
2186 dll_filename = module->name;
2187 dll_symname = xstrdup (module->name);
2188 for (i = 0; dll_symname[i]; i++)
2189 if (!ISALNUM (dll_symname[i]))
2190 dll_symname[i] = '_';
2194 for (i = 0; i < pe_def_file->num_imports; i++)
2195 if (pe_def_file->imports[i].module == module)
2197 def_file_export exp;
2198 struct bfd_link_hash_entry *blhe;
2200 /* See if we need this import. */
2201 char *name = (char *) xmalloc (strlen (pe_def_file->imports[i].internal_name) + 2 + 6);
2202 sprintf (name, "%s%s", U (""), pe_def_file->imports[i].internal_name);
2203 blhe = bfd_link_hash_lookup (link_info->hash, name,
2204 false, false, false);
2205 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2207 sprintf (name, "%s%s", U ("_imp__"),
2208 pe_def_file->imports[i].internal_name);
2209 blhe = bfd_link_hash_lookup (link_info->hash, name,
2210 false, false, false);
2213 if (blhe && blhe->type == bfd_link_hash_undefined)
2219 bfd *ar_head = make_head (output_bfd);
2220 add_bfd_to_link (ar_head, ar_head->filename, link_info);
2223 exp.internal_name = pe_def_file->imports[i].internal_name;
2224 exp.name = pe_def_file->imports[i].name;
2225 exp.ordinal = pe_def_file->imports[i].ordinal;
2226 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2227 exp.flag_private = 0;
2228 exp.flag_constant = 0;
2230 exp.flag_noname = exp.name ? 0 : 1;
2231 one = make_one (&exp, output_bfd);
2232 add_bfd_to_link (one, one->filename, link_info);
2237 bfd *ar_tail = make_tail (output_bfd);
2238 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2245 /* We were handed a *.DLL file. Parse it and turn it into a set of
2246 IMPORTS directives in the def file. Return true if the file was
2247 handled, false if not. */
2250 pe_get16 (abfd, where)
2256 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2257 bfd_bread (b, (bfd_size_type) 2, abfd);
2258 return b[0] + (b[1] << 8);
2262 pe_get32 (abfd, where)
2268 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2269 bfd_bread (b, (bfd_size_type) 4, abfd);
2270 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2273 #if 0 /* This is not currently used. */
2279 unsigned char *b = ptr;
2281 return b[0] + (b[1] << 8);
2290 unsigned char *b = ptr;
2292 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2296 pe_implied_import_dll (filename)
2297 const char *filename;
2300 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
2301 unsigned long export_rva, export_size, nsections, secptr, expptr;
2302 unsigned char *expdata, *erva;
2303 unsigned long name_rvas, ordinals, nexp, ordbase;
2304 const char *dll_name;
2306 /* No, I can't use bfd here. kernel32.dll puts its export table in
2307 the middle of the .rdata section. */
2308 dll = bfd_openr (filename, pe_details->target_name);
2311 einfo ("%Xopen %s: %s\n", filename, bfd_errmsg (bfd_get_error ()));
2315 /* PEI dlls seem to be bfd_objects. */
2316 if (!bfd_check_format (dll, bfd_object))
2318 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2322 dll_name = filename;
2323 for (i = 0; filename[i]; i++)
2324 if (filename[i] == '/' || filename[i] == '\\' || filename[i] == ':')
2325 dll_name = filename + i + 1;
2327 pe_header_offset = pe_get32 (dll, 0x3c);
2328 opthdr_ofs = pe_header_offset + 4 + 20;
2329 num_entries = pe_get32 (dll, opthdr_ofs + 92);
2331 if (num_entries < 1) /* No exports. */
2334 export_rva = pe_get32 (dll, opthdr_ofs + 96);
2335 export_size = pe_get32 (dll, opthdr_ofs + 100);
2336 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2337 secptr = (pe_header_offset + 4 + 20 +
2338 pe_get16 (dll, pe_header_offset + 4 + 16));
2341 for (i = 0; i < nsections; i++)
2344 unsigned long secptr1 = secptr + 40 * i;
2345 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2346 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
2347 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
2349 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2350 bfd_bread (sname, (bfd_size_type) 8, dll);
2352 if (vaddr <= export_rva && vaddr + vsize > export_rva)
2354 expptr = fptr + (export_rva - vaddr);
2355 if (export_rva + export_size > vaddr + vsize)
2356 export_size = vsize - (export_rva - vaddr);
2361 expdata = (unsigned char *) xmalloc (export_size);
2362 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2363 bfd_bread (expdata, (bfd_size_type) export_size, dll);
2364 erva = expdata - export_rva;
2366 if (pe_def_file == 0)
2367 pe_def_file = def_file_empty ();
2369 nexp = pe_as32 (expdata + 24);
2370 name_rvas = pe_as32 (expdata + 32);
2371 ordinals = pe_as32 (expdata + 36);
2372 ordbase = pe_as32 (expdata + 16);
2374 for (i = 0; i < nexp; i++)
2376 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
2377 def_file_import *imp;
2379 imp = def_file_add_import (pe_def_file, erva + name_rva, dll_name,
2386 /* These are the main functions, called from the emulation. The first
2387 is called after the bfds are read, so we can guess at how much space
2388 we need. The second is called after everything is placed, so we
2389 can put the right values in place. */
2392 pe_dll_build_sections (abfd, info)
2394 struct bfd_link_info *info;
2396 pe_dll_id_target (bfd_get_target (abfd));
2397 process_def_file (abfd, info);
2399 generate_edata (abfd, info);
2400 build_filler_bfd (1);
2404 pe_exe_build_sections (abfd, info)
2406 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2408 pe_dll_id_target (bfd_get_target (abfd));
2409 build_filler_bfd (0);
2413 pe_dll_fill_sections (abfd, info)
2415 struct bfd_link_info *info;
2417 pe_dll_id_target (bfd_get_target (abfd));
2418 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2420 generate_reloc (abfd, info);
2423 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2425 /* Resize the sections. */
2426 lang_size_sections (stat_ptr->head, abs_output_section,
2427 &stat_ptr->head, 0, (bfd_vma) 0, NULL);
2429 /* Redo special stuff. */
2430 ldemul_after_allocation ();
2432 /* Do the assignments again. */
2433 lang_do_assignments (stat_ptr->head,
2435 (fill_type) 0, (bfd_vma) 0);
2438 fill_edata (abfd, info);
2440 pe_data (abfd)->dll = 1;
2442 edata_s->contents = edata_d;
2443 reloc_s->contents = reloc_d;
2447 pe_exe_fill_sections (abfd, info)
2449 struct bfd_link_info *info;
2451 pe_dll_id_target (bfd_get_target (abfd));
2452 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2454 generate_reloc (abfd, info);
2457 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2459 /* Resize the sections. */
2460 lang_size_sections (stat_ptr->head, abs_output_section,
2461 &stat_ptr->head, 0, (bfd_vma) 0, NULL);
2463 /* Redo special stuff. */
2464 ldemul_after_allocation ();
2466 /* Do the assignments again. */
2467 lang_do_assignments (stat_ptr->head,
2469 (fill_type) 0, (bfd_vma) 0);
2471 reloc_s->contents = reloc_d;