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"
45 /* This file turns a regular Windows PE image into a DLL. Because of
46 the complexity of this operation, it has been broken down into a
47 number of separate modules which are all called by the main function
48 at the end of this file. This function is not re-entrant and is
49 normally only called once, so static variables are used to reduce
50 the number of parameters and return values required.
52 See also: ld/emultempl/pe.em. */
54 /* Auto-import feature by Paul Sokolovsky
58 1. With this feature on, DLL clients can import variables from DLL
59 without any concern from their side (for example, without any source
62 2. This is done completely in bounds of the PE specification (to be fair,
63 there's a place where it pokes nose out of, but in practice it works).
64 So, resulting module can be used with any other PE compiler/linker.
66 3. Auto-import is fully compatible with standard import method and they
67 can be mixed together.
69 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
70 reference to it; load time: negligible; virtual/physical memory: should be
71 less than effect of DLL relocation, and I sincerely hope it doesn't affect
72 DLL sharability (too much).
76 The obvious and only way to get rid of dllimport insanity is to make client
77 access variable directly in the DLL, bypassing extra dereference. I.e.,
78 whenever client contains something like
82 address of dll_var in the command should be relocated to point into loaded
83 DLL. The aim is to make OS loader do so, and than make ld help with that.
84 Import section of PE made following way: there's a vector of structures
85 each describing imports from particular DLL. Each such structure points
86 to two other parallel vectors: one holding imported names, and one which
87 will hold address of corresponding imported name. So, the solution is
88 de-vectorize these structures, making import locations be sparse and
89 pointing directly into code. Before continuing, it is worth a note that,
90 while authors strives to make PE act ELF-like, there're some other people
91 make ELF act PE-like: elfvector, ;-) .
95 For each reference of data symbol to be imported from DLL (to set of which
96 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
97 import fixup entry is generated. That entry is of type
98 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
99 fixup entry contains pointer to symbol's address within .text section
100 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
101 (so, DLL name is referenced by multiple entries), and pointer to symbol
102 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
103 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
104 containing imported name. Here comes that "om the edge" problem mentioned
105 above: PE specification rambles that name vector (OriginalFirstThunk)
106 should run in parallel with addresses vector (FirstThunk), i.e. that they
107 should have same number of elements and terminated with zero. We violate
108 this, since FirstThunk points directly into machine code. But in practice,
109 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
110 puts addresses to FirstThunk, not something else. It once again should be
111 noted that dll and symbol name structures are reused across fixup entries
112 and should be there anyway to support standard import stuff, so sustained
113 overhead is 20 bytes per reference. Other question is whether having several
114 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
115 done even by native compiler/linker (libth32's functions are in fact reside
116 in windows9x kernel32.dll, so if you use it, you have two
117 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
118 referencing the same PE structures several times is valid. The answer is why
119 not, prohibiting that (detecting violation) would require more work on
120 behalf of loader than not doing it.
122 See also: ld/emultempl/pe.em. */
124 static void add_bfd_to_link (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 bfd_section *edata_s, *reloc_s;
142 static unsigned char *edata_d, *reloc_d;
143 static size_t edata_sz, reloc_sz;
144 static int runtime_pseudo_relocs_created = 0;
151 autofilter_entry_type;
157 unsigned int imagebase_reloc;
160 bfd_boolean underscored;
161 autofilter_entry_type* autofilter_symbollist;
165 static autofilter_entry_type autofilter_symbollist_generic[] =
168 /* Entry point symbols. */
170 { "DllMainCRTStartup", 17 },
171 { "_DllMainCRTStartup", 18 },
172 /* Runtime pseudo-reloc. */
173 { "_pei386_runtime_relocator", 25 },
174 { "do_pseudo_reloc", 15 },
178 static autofilter_entry_type autofilter_symbollist_i386[] =
181 /* Entry point symbols, and entry hooks. */
182 { "cygwin_crt0", 11 },
183 { "DllMain@12", 10 },
184 { "DllEntryPoint@0", 15 },
185 { "DllMainCRTStartup@12", 20 },
186 { "_cygwin_dll_entry@12", 20 },
187 { "_cygwin_crt0_common@8", 21 },
188 { "_cygwin_noncygwin_dll_entry@12", 30 },
189 { "cygwin_attach_dll", 17 },
190 { "cygwin_premain0", 15 },
191 { "cygwin_premain1", 15 },
192 { "cygwin_premain2", 15 },
193 { "cygwin_premain3", 15 },
194 /* Runtime pseudo-reloc. */
195 { "_pei386_runtime_relocator", 25 },
196 { "do_pseudo_reloc", 15 },
197 /* Global vars that should not be exported. */
198 { "impure_ptr", 10 },
199 { "_impure_ptr", 11 },
205 #define PE_ARCH_i386 1
207 #define PE_ARCH_mips 3
208 #define PE_ARCH_arm 4
209 #define PE_ARCH_arm_epoc 5
211 static pe_details_type pe_detail_list[] =
220 autofilter_symbollist_i386
225 16 /* R_SH_IMAGEBASE */,
229 autofilter_symbollist_generic
238 autofilter_symbollist_generic
247 autofilter_symbollist_generic
250 "epoc-pei-arm-little",
251 "epoc-pe-arm-little",
256 autofilter_symbollist_generic
258 { NULL, NULL, 0, 0, 0, FALSE, NULL }
261 static pe_details_type *pe_details;
263 /* Do not specify library suffix explicitly, to allow for dllized versions. */
264 static autofilter_entry_type autofilter_liblist[] =
270 { "libmingw32", 10 },
271 { "libmingwex", 10 },
279 static autofilter_entry_type autofilter_objlist[] =
289 { "crtbegin.o", 10 },
294 static autofilter_entry_type autofilter_symbolprefixlist[] =
297 /* Do __imp_ explicitly to save time. */
299 /* Don't re-export auto-imported symbols. */
301 { "__builtin_", 10 },
302 /* Don't export symbols specifying internal DLL layout. */
307 static autofilter_entry_type autofilter_symbolsuffixlist[] =
313 #define U(str) (pe_details->underscored ? "_" str : str)
316 pe_dll_id_target (const char *target)
320 for (i = 0; pe_detail_list[i].target_name; i++)
321 if (strcmp (pe_detail_list[i].target_name, target) == 0
322 || strcmp (pe_detail_list[i].object_target, target) == 0)
324 pe_details = pe_detail_list + i;
327 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
331 /* Helper functions for qsort. Relocs must be sorted so that we can write
332 them out by pages. */
343 reloc_sort (const void *va, const void *vb)
345 bfd_vma a = ((const reloc_data_type *) va)->vma;
346 bfd_vma b = ((const reloc_data_type *) vb)->vma;
348 return (a > b) ? 1 : ((a < b) ? -1 : 0);
352 pe_export_sort (const void *va, const void *vb)
354 const def_file_export *a = va;
355 const def_file_export *b = vb;
357 return strcmp (a->name, b->name);
360 /* Read and process the .DEF file. */
362 /* These correspond to the entries in pe_def_file->exports[]. I use
363 exported_symbol_sections[i] to tag whether or not the symbol was
364 defined, since we can't export symbols we don't have. */
366 static bfd_vma *exported_symbol_offsets;
367 static struct bfd_section **exported_symbol_sections;
368 static int export_table_size;
369 static int count_exported;
370 static int count_exported_byname;
371 static int count_with_ordinals;
372 static const char *dll_name;
373 static int min_ordinal, max_ordinal;
374 static int *exported_symbols;
376 typedef struct exclude_list_struct
379 struct exclude_list_struct *next;
384 static struct exclude_list_struct *excludes = 0;
387 pe_dll_add_excludes (const char *new_excludes, const int type)
390 char *exclude_string;
392 local_copy = xstrdup (new_excludes);
394 exclude_string = strtok (local_copy, ",:");
395 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
397 struct exclude_list_struct *new_exclude;
399 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
400 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
401 strcpy (new_exclude->string, exclude_string);
402 new_exclude->type = type;
403 new_exclude->next = excludes;
404 excludes = new_exclude;
411 /* abfd is a bfd containing n (or NULL)
412 It can be used for contextual checks. */
415 auto_export (bfd *abfd, def_file *d, const char *n)
418 struct exclude_list_struct *ex;
419 autofilter_entry_type *afptr;
420 const char * libname = 0;
421 if (abfd && abfd->my_archive)
422 libname = lbasename (abfd->my_archive->filename);
424 /* We should not re-export imported stuff. */
425 if (strncmp (n, "_imp_", 5) == 0)
428 for (i = 0; i < d->num_exports; i++)
429 if (strcmp (d->exports[i].name, n) == 0)
432 if (pe_dll_do_default_excludes)
437 if (pe_dll_extra_pe_debug)
438 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
439 n, abfd, abfd->my_archive);
441 /* First of all, make context checks:
442 Don't export anything from standard libs. */
445 afptr = autofilter_liblist;
449 if (strncmp (libname, afptr->name, afptr->len) == 0 )
455 /* Next, exclude symbols from certain startup objects. */
457 if (abfd && (p = lbasename (abfd->filename)))
459 afptr = autofilter_objlist;
462 if (strcmp (p, afptr->name) == 0)
468 /* Don't try to blindly exclude all symbols
469 that begin with '__'; this was tried and
470 it is too restrictive. Instead we have
471 a target specific list to use: */
472 afptr = pe_details->autofilter_symbollist;
475 if (strcmp (n, afptr->name) == 0)
481 /* Next, exclude symbols starting with ... */
482 afptr = autofilter_symbolprefixlist;
485 if (strncmp (n, afptr->name, afptr->len) == 0)
491 /* Finally, exclude symbols ending with ... */
493 afptr = autofilter_symbolsuffixlist;
496 if ((len >= afptr->len)
497 /* Add 1 to insure match with trailing '\0'. */
498 && strncmp (n + len - afptr->len, afptr->name,
499 afptr->len + 1) == 0)
506 for (ex = excludes; ex; ex = ex->next)
508 if (ex->type == 1) /* exclude-libs */
511 && ((strcmp (libname, ex->string) == 0)
512 || (strcasecmp ("ALL", ex->string) == 0)))
515 else if (strcmp (n, ex->string) == 0)
523 process_def_file (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
526 struct bfd_link_hash_entry *blhe;
528 struct bfd_section *s;
529 def_file_export *e = 0;
532 pe_def_file = def_file_empty ();
534 /* First, run around to all the objects looking for the .drectve
535 sections, and push those into the def file too. */
536 for (b = info->input_bfds; b; b = b->link_next)
538 s = bfd_get_section_by_name (b, ".drectve");
542 char *buf = xmalloc (size);
544 bfd_get_section_contents (b, s, buf, 0, size);
545 def_file_add_directive (pe_def_file, buf, size);
550 /* If we are not building a DLL, when there are no exports
551 we do not build an export table at all. */
552 if (!pe_dll_export_everything && pe_def_file->num_exports == 0
556 /* Now, maybe export everything else the default way. */
557 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
559 for (b = info->input_bfds; b; b = b->link_next)
564 symsize = bfd_get_symtab_upper_bound (b);
565 symbols = xmalloc (symsize);
566 nsyms = bfd_canonicalize_symtab (b, symbols);
568 for (j = 0; j < nsyms; j++)
570 /* We should export symbols which are either global or not
571 anything at all. (.bss data is the latter)
572 We should not export undefined symbols. */
573 if (symbols[j]->section != &bfd_und_section
574 && ((symbols[j]->flags & BSF_GLOBAL)
575 || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
577 const char *sn = symbols[j]->name;
579 /* We should not re-export imported stuff. */
581 char *name = xmalloc (strlen (sn) + 2 + 6);
582 sprintf (name, "%s%s", U("_imp_"), sn);
584 blhe = bfd_link_hash_lookup (info->hash, name,
585 FALSE, FALSE, FALSE);
588 if (blhe && blhe->type == bfd_link_hash_defined)
595 if (auto_export (b, pe_def_file, sn))
598 p=def_file_add_export (pe_def_file, sn, 0, -1);
599 /* Fill data flag properly, from dlltool.c. */
600 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
608 #define NE pe_def_file->num_exports
610 /* Canonicalize the export list. */
613 for (i = 0; i < NE; i++)
615 if (strchr (pe_def_file->exports[i].name, '@'))
617 /* This will preserve internal_name, which may have been
618 pointing to the same memory as name, or might not
620 int lead_at = (*pe_def_file->exports[i].name == '@');
621 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
622 char *tmp_at = strchr (tmp, '@');
627 einfo (_("%XCannot export %s: invalid export name\n"),
628 pe_def_file->exports[i].name);
629 pe_def_file->exports[i].name = tmp;
634 if (pe_dll_stdcall_aliases)
636 for (i = 0; i < NE; i++)
638 if (strchr (pe_def_file->exports[i].name, '@'))
640 int lead_at = (*pe_def_file->exports[i].name == '@');
641 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
643 *(strchr (tmp, '@')) = 0;
644 if (auto_export (NULL, pe_def_file, tmp))
645 def_file_add_export (pe_def_file, tmp,
646 pe_def_file->exports[i].internal_name,
654 /* Convenience, but watch out for it changing. */
655 e = pe_def_file->exports;
657 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
658 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
660 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
664 count_exported_byname = 0;
665 count_with_ordinals = 0;
667 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
669 for (i = 0, j = 0; i < NE; i++)
671 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
673 /* This is a duplicate. */
674 if (e[j - 1].ordinal != -1
675 && e[i].ordinal != -1
676 && e[j - 1].ordinal != e[i].ordinal)
678 if (pe_dll_warn_dup_exports)
679 /* xgettext:c-format */
680 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
681 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
685 if (pe_dll_warn_dup_exports)
686 /* xgettext:c-format */
687 einfo (_("Warning, duplicate EXPORT: %s\n"),
691 if (e[i].ordinal != -1)
692 e[j - 1].ordinal = e[i].ordinal;
693 e[j - 1].flag_private |= e[i].flag_private;
694 e[j - 1].flag_constant |= e[i].flag_constant;
695 e[j - 1].flag_noname |= e[i].flag_noname;
696 e[j - 1].flag_data |= e[i].flag_data;
705 pe_def_file->num_exports = j; /* == NE */
707 for (i = 0; i < NE; i++)
711 /* Check for forward exports */
712 if (strchr (pe_def_file->exports[i].internal_name, '.'))
715 if (!pe_def_file->exports[i].flag_noname)
716 count_exported_byname++;
718 pe_def_file->exports[i].flag_forward = 1;
720 if (pe_def_file->exports[i].ordinal != -1)
722 if (max_ordinal < pe_def_file->exports[i].ordinal)
723 max_ordinal = pe_def_file->exports[i].ordinal;
724 if (min_ordinal > pe_def_file->exports[i].ordinal)
725 min_ordinal = pe_def_file->exports[i].ordinal;
726 count_with_ordinals++;
732 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
733 if (pe_details->underscored
734 && (*pe_def_file->exports[i].internal_name != '@'))
737 strcpy (name + 1, pe_def_file->exports[i].internal_name);
740 strcpy (name, pe_def_file->exports[i].internal_name);
742 blhe = bfd_link_hash_lookup (info->hash,
747 && (blhe->type == bfd_link_hash_defined
748 || (blhe->type == bfd_link_hash_common)))
751 if (!pe_def_file->exports[i].flag_noname)
752 count_exported_byname++;
754 /* Only fill in the sections. The actual offsets are computed
755 in fill_exported_offsets() after common symbols are laid
757 if (blhe->type == bfd_link_hash_defined)
758 exported_symbol_sections[i] = blhe->u.def.section;
760 exported_symbol_sections[i] = blhe->u.c.p->section;
762 if (pe_def_file->exports[i].ordinal != -1)
764 if (max_ordinal < pe_def_file->exports[i].ordinal)
765 max_ordinal = pe_def_file->exports[i].ordinal;
766 if (min_ordinal > pe_def_file->exports[i].ordinal)
767 min_ordinal = pe_def_file->exports[i].ordinal;
768 count_with_ordinals++;
771 else if (blhe && blhe->type == bfd_link_hash_undefined)
773 /* xgettext:c-format */
774 einfo (_("%XCannot export %s: symbol not defined\n"),
775 pe_def_file->exports[i].internal_name);
779 /* xgettext:c-format */
780 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
781 pe_def_file->exports[i].internal_name,
782 blhe->type, bfd_link_hash_defined);
786 /* xgettext:c-format */
787 einfo (_("%XCannot export %s: symbol not found\n"),
788 pe_def_file->exports[i].internal_name);
794 /* Build the bfd that will contain .edata and .reloc sections. */
797 build_filler_bfd (int include_edata)
799 lang_input_statement_type *filler_file;
800 filler_file = lang_add_input_file ("dll stuff",
801 lang_input_file_is_fake_enum,
803 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
804 if (filler_bfd == NULL
805 || !bfd_set_arch_mach (filler_bfd,
806 bfd_get_arch (output_bfd),
807 bfd_get_mach (output_bfd)))
809 einfo ("%X%P: can not create BFD: %E\n");
815 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
817 || !bfd_set_section_flags (filler_bfd, edata_s,
824 einfo ("%X%P: can not create .edata section: %E\n");
827 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
830 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
832 || !bfd_set_section_flags (filler_bfd, reloc_s,
839 einfo ("%X%P: can not create .reloc section: %E\n");
843 bfd_set_section_size (filler_bfd, reloc_s, 0);
845 ldlang_add_file (filler_file);
848 /* Gather all the exported symbols and build the .edata section. */
851 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
854 int name_table_size = 0;
857 /* First, we need to know how many exported symbols there are,
858 and what the range of ordinals is. */
859 if (pe_def_file->name)
860 dll_name = pe_def_file->name;
863 dll_name = abfd->filename;
865 for (dlnp = dll_name; *dlnp; dlnp++)
866 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
870 if (count_with_ordinals && max_ordinal > count_exported)
872 if (min_ordinal > max_ordinal - count_exported + 1)
873 min_ordinal = max_ordinal - count_exported + 1;
878 max_ordinal = count_exported;
881 export_table_size = max_ordinal - min_ordinal + 1;
882 exported_symbols = xmalloc (export_table_size * sizeof (int));
883 for (i = 0; i < export_table_size; i++)
884 exported_symbols[i] = -1;
886 /* Now we need to assign ordinals to those that don't have them. */
887 for (i = 0; i < NE; i++)
889 if (exported_symbol_sections[i] ||
890 pe_def_file->exports[i].flag_forward)
892 if (pe_def_file->exports[i].ordinal != -1)
894 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
895 int pi = exported_symbols[ei];
899 /* xgettext:c-format */
900 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
901 pe_def_file->exports[i].ordinal,
902 pe_def_file->exports[i].name,
903 pe_def_file->exports[pi].name);
905 exported_symbols[ei] = i;
907 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
910 /* Reserve space for the forward name. */
911 if (pe_def_file->exports[i].flag_forward)
913 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
917 next_ordinal = min_ordinal;
918 for (i = 0; i < NE; i++)
919 if ((exported_symbol_sections[i] ||
920 pe_def_file->exports[i].flag_forward) &&
921 pe_def_file->exports[i].ordinal == -1)
923 while (exported_symbols[next_ordinal - min_ordinal] != -1)
926 exported_symbols[next_ordinal - min_ordinal] = i;
927 pe_def_file->exports[i].ordinal = next_ordinal;
930 /* OK, now we can allocate some memory. */
931 edata_sz = (40 /* directory */
932 + 4 * export_table_size /* addresses */
933 + 4 * count_exported_byname /* name ptrs */
934 + 2 * count_exported_byname /* ordinals */
935 + name_table_size + strlen (dll_name) + 1);
938 /* Fill the exported symbol offsets. The preliminary work has already
939 been done in process_def_file(). */
942 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
945 struct bfd_link_hash_entry *blhe;
947 for (i = 0; i < pe_def_file->num_exports; i++)
951 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
952 if (pe_details->underscored
953 && *pe_def_file->exports[i].internal_name != '@')
956 strcpy (name + 1, pe_def_file->exports[i].internal_name);
959 strcpy (name, pe_def_file->exports[i].internal_name);
961 blhe = bfd_link_hash_lookup (info->hash,
965 if (blhe && blhe->type == bfd_link_hash_defined)
966 exported_symbol_offsets[i] = blhe->u.def.value;
973 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
976 unsigned char *edirectory;
977 unsigned char *eaddresses;
978 unsigned char *enameptrs;
979 unsigned char *eordinals;
985 edata_d = xmalloc (edata_sz);
987 /* Note use of array pointer math here. */
988 edirectory = edata_d;
989 eaddresses = edata_d + 40;
990 enameptrs = eaddresses + 4 * export_table_size;
991 eordinals = enameptrs + 4 * count_exported_byname;
992 enamestr = (char *) eordinals + 2 * count_exported_byname;
994 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
995 + edata_s->output_section->vma - image_base)
997 memset (edata_d, 0, edata_sz);
998 bfd_put_32 (abfd, now, edata_d + 4);
999 if (pe_def_file->version_major != -1)
1001 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1002 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1005 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1006 strcpy (enamestr, dll_name);
1007 enamestr += strlen (enamestr) + 1;
1008 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1009 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1010 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1011 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1012 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1013 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1015 fill_exported_offsets (abfd, info);
1017 /* Ok, now for the filling in part.
1018 Scan alphabetically - ie the ordering in the exports[] table,
1019 rather than by ordinal - the ordering in the exported_symbol[]
1020 table. See dlltool.c and:
1021 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1022 for more information. */
1024 for (s = 0; s < NE; s++)
1026 struct bfd_section *ssec = exported_symbol_sections[s];
1027 if (pe_def_file->exports[s].ordinal != -1 &&
1028 (pe_def_file->exports[s].flag_forward || ssec != NULL))
1030 int ord = pe_def_file->exports[s].ordinal;
1032 if (pe_def_file->exports[s].flag_forward)
1034 bfd_put_32 (abfd, ERVA (enamestr),
1035 eaddresses + 4 * (ord - min_ordinal));
1037 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1038 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1042 unsigned long srva = (exported_symbol_offsets[s]
1043 + ssec->output_section->vma
1044 + ssec->output_offset);
1046 bfd_put_32 (abfd, srva - image_base,
1047 eaddresses + 4 * (ord - min_ordinal));
1050 if (!pe_def_file->exports[s].flag_noname)
1052 char *ename = pe_def_file->exports[s].name;
1054 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1056 strcpy (enamestr, ename);
1057 enamestr += strlen (enamestr) + 1;
1058 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1060 pe_def_file->exports[s].hint = hint++;
1067 static struct bfd_section *current_sec;
1070 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1072 int (*cb) (arelent *, asection *))
1077 for (b = info->input_bfds; b; b = b->link_next)
1082 symsize = bfd_get_symtab_upper_bound (b);
1083 symbols = xmalloc (symsize);
1084 nsyms = bfd_canonicalize_symtab (b, symbols);
1086 for (s = b->sections; s; s = s->next)
1089 int relsize, nrelocs, i;
1090 int flags = bfd_get_section_flags (b, s);
1092 /* Skip discarded linkonce sections. */
1093 if (flags & SEC_LINK_ONCE
1094 && s->output_section == bfd_abs_section_ptr)
1099 relsize = bfd_get_reloc_upper_bound (b, s);
1100 relocs = xmalloc (relsize);
1101 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1103 for (i = 0; i < nrelocs; i++)
1105 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1107 if (!strcmp (name, sym->name))
1113 /* Warning: the allocated symbols are remembered in BFD and reused
1114 later, so don't free them! */
1115 /* free (symbols); */
1120 /* Gather all the relocations and build the .reloc section. */
1123 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1126 /* For .reloc stuff. */
1127 reloc_data_type *reloc_data;
1128 int total_relocs = 0;
1130 unsigned long sec_page = (unsigned long) -1;
1131 unsigned long page_ptr, page_count;
1134 struct bfd_section *s;
1137 for (b = info->input_bfds; b; b = b->link_next)
1138 for (s = b->sections; s; s = s->next)
1139 total_relocs += s->reloc_count;
1141 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1145 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1148 int relsize, nrelocs, i;
1150 for (s = b->sections; s; s = s->next)
1152 unsigned long sec_vma = s->output_section->vma + s->output_offset;
1156 /* If it's not loaded, we don't need to relocate it this way. */
1157 if (!(s->output_section->flags & SEC_LOAD))
1160 /* I don't know why there would be a reloc for these, but I've
1161 seen it happen - DJ */
1162 if (s->output_section == &bfd_abs_section)
1165 if (s->output_section->vma == 0)
1167 /* Huh? Shouldn't happen, but punt if it does. */
1168 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1169 s->output_section->name, s->output_section->index,
1170 s->output_section->flags);
1174 symsize = bfd_get_symtab_upper_bound (b);
1175 symbols = xmalloc (symsize);
1176 nsyms = bfd_canonicalize_symtab (b, symbols);
1178 relsize = bfd_get_reloc_upper_bound (b, s);
1179 relocs = xmalloc (relsize);
1180 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1182 for (i = 0; i < nrelocs; i++)
1184 if (pe_dll_extra_pe_debug)
1186 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1187 printf ("rel: %s\n", sym->name);
1189 if (!relocs[i]->howto->pc_relative
1190 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1193 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1195 sym_vma = (relocs[i]->addend
1198 + sym->section->output_offset
1199 + sym->section->output_section->vma);
1200 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1202 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1204 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1205 relocs[i]->howto->rightshift)
1207 case BITS_AND_SHIFT (32, 0):
1208 reloc_data[total_relocs].type = 3;
1211 case BITS_AND_SHIFT (16, 0):
1212 reloc_data[total_relocs].type = 2;
1215 case BITS_AND_SHIFT (16, 16):
1216 reloc_data[total_relocs].type = 4;
1217 /* FIXME: we can't know the symbol's right value
1218 yet, but we probably can safely assume that
1219 CE will relocate us in 64k blocks, so leaving
1221 reloc_data[total_relocs].extra = 0;
1224 case BITS_AND_SHIFT (26, 2):
1225 reloc_data[total_relocs].type = 5;
1228 case BITS_AND_SHIFT (24, 2):
1229 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1230 Those ARM_xxx definitions should go in proper
1232 if (relocs[i]->howto->type == 0
1233 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1234 || relocs[i]->howto->type == 5)
1235 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1236 that has already been fully processed during a
1237 previous link stage, so ignore it here. */
1241 /* xgettext:c-format */
1242 einfo (_("%XError: %d-bit reloc in dll\n"),
1243 relocs[i]->howto->bitsize);
1249 /* Warning: the allocated symbols are remembered in BFD and
1250 reused later, so don't free them! */
1254 /* At this point, we have total_relocs relocation addresses in
1255 reloc_addresses, which are all suitable for the .reloc section.
1256 We must now create the new sections. */
1257 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1259 for (i = 0; i < total_relocs; i++)
1261 unsigned long this_page = (reloc_data[i].vma >> 12);
1263 if (this_page != sec_page)
1265 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1267 sec_page = this_page;
1272 if (reloc_data[i].type == 4)
1276 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1277 reloc_d = xmalloc (reloc_sz);
1278 sec_page = (unsigned long) -1;
1280 page_ptr = (unsigned long) -1;
1283 for (i = 0; i < total_relocs; i++)
1285 unsigned long rva = reloc_data[i].vma - image_base;
1286 unsigned long this_page = (rva & ~0xfff);
1288 if (this_page != sec_page)
1290 while (reloc_sz & 3)
1291 reloc_d[reloc_sz++] = 0;
1293 if (page_ptr != (unsigned long) -1)
1294 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1296 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1297 page_ptr = reloc_sz;
1299 sec_page = this_page;
1303 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1304 reloc_d + reloc_sz);
1307 if (reloc_data[i].type == 4)
1309 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1316 while (reloc_sz & 3)
1317 reloc_d[reloc_sz++] = 0;
1319 if (page_ptr != (unsigned long) -1)
1320 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1322 while (reloc_sz < reloc_s->size)
1323 reloc_d[reloc_sz++] = 0;
1326 /* Given the exiting def_file structure, print out a .DEF file that
1327 corresponds to it. */
1330 quoteput (char *s, FILE *f, int needs_quotes)
1334 for (cp = s; *cp; cp++)
1349 if (*s == '"' || *s == '\\')
1363 pe_dll_generate_def_file (const char *pe_out_def_filename)
1366 FILE *out = fopen (pe_out_def_filename, "w");
1369 /* xgettext:c-format */
1370 einfo (_("%s: Can't open output def file %s\n"),
1371 program_name, pe_out_def_filename);
1375 if (pe_def_file->name)
1377 if (pe_def_file->is_dll)
1378 fprintf (out, "LIBRARY ");
1380 fprintf (out, "NAME ");
1382 quoteput (pe_def_file->name, out, 1);
1384 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
1385 fprintf (out, " BASE=0x%lx",
1386 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
1387 fprintf (out, "\n");
1390 if (pe_def_file->description)
1392 fprintf (out, "DESCRIPTION ");
1393 quoteput (pe_def_file->description, out, 1);
1394 fprintf (out, "\n");
1397 if (pe_def_file->version_minor != -1)
1398 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1399 pe_def_file->version_minor);
1400 else if (pe_def_file->version_major != -1)
1401 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1403 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1404 fprintf (out, "\n");
1406 if (pe_def_file->stack_commit != -1)
1407 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1408 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1409 else if (pe_def_file->stack_reserve != -1)
1410 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1412 if (pe_def_file->heap_commit != -1)
1413 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1414 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1415 else if (pe_def_file->heap_reserve != -1)
1416 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1418 if (pe_def_file->num_section_defs > 0)
1420 fprintf (out, "\nSECTIONS\n\n");
1422 for (i = 0; i < pe_def_file->num_section_defs; i++)
1425 quoteput (pe_def_file->section_defs[i].name, out, 0);
1427 if (pe_def_file->section_defs[i].class)
1429 fprintf (out, " CLASS ");
1430 quoteput (pe_def_file->section_defs[i].class, out, 0);
1433 if (pe_def_file->section_defs[i].flag_read)
1434 fprintf (out, " READ");
1436 if (pe_def_file->section_defs[i].flag_write)
1437 fprintf (out, " WRITE");
1439 if (pe_def_file->section_defs[i].flag_execute)
1440 fprintf (out, " EXECUTE");
1442 if (pe_def_file->section_defs[i].flag_shared)
1443 fprintf (out, " SHARED");
1445 fprintf (out, "\n");
1449 if (pe_def_file->num_exports > 0)
1451 fprintf (out, "EXPORTS\n");
1453 for (i = 0; i < pe_def_file->num_exports; i++)
1455 def_file_export *e = pe_def_file->exports + i;
1457 quoteput (e->name, out, 0);
1459 if (e->internal_name && strcmp (e->internal_name, e->name))
1461 fprintf (out, " = ");
1462 quoteput (e->internal_name, out, 0);
1465 if (e->ordinal != -1)
1466 fprintf (out, " @%d", e->ordinal);
1468 if (e->flag_private)
1469 fprintf (out, " PRIVATE");
1471 if (e->flag_constant)
1472 fprintf (out, " CONSTANT");
1475 fprintf (out, " NONAME");
1478 fprintf (out, " DATA");
1480 fprintf (out, "\n");
1484 if (pe_def_file->num_imports > 0)
1486 fprintf (out, "\nIMPORTS\n\n");
1488 for (i = 0; i < pe_def_file->num_imports; i++)
1490 def_file_import *im = pe_def_file->imports + i;
1493 if (im->internal_name
1494 && (!im->name || strcmp (im->internal_name, im->name)))
1496 quoteput (im->internal_name, out, 0);
1497 fprintf (out, " = ");
1500 quoteput (im->module->name, out, 0);
1504 quoteput (im->name, out, 0);
1506 fprintf (out, "%d", im->ordinal);
1508 fprintf (out, "\n");
1513 fprintf (out, _("; no contents available\n"));
1515 if (fclose (out) == EOF)
1516 /* xgettext:c-format */
1517 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1520 /* Generate the import library. */
1522 static asymbol **symtab;
1525 static const char *dll_filename;
1526 static char *dll_symname;
1528 #define UNDSEC (asection *) &bfd_und_section
1531 quick_section (bfd *abfd, const char *name, int flags, int align)
1536 sec = bfd_make_section_old_way (abfd, name);
1537 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1538 bfd_set_section_alignment (abfd, sec, align);
1539 /* Remember to undo this before trying to link internally! */
1540 sec->output_section = sec;
1542 sym = bfd_make_empty_symbol (abfd);
1543 symtab[symptr++] = sym;
1544 sym->name = sec->name;
1546 sym->flags = BSF_LOCAL;
1553 quick_symbol (bfd *abfd,
1562 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1567 sym = bfd_make_empty_symbol (abfd);
1572 symtab[symptr++] = sym;
1575 static arelent *reltab = 0;
1576 static int relcount = 0, relsize = 0;
1579 quick_reloc (bfd *abfd, int address, int which_howto, int symidx)
1581 if (relcount >= relsize - 1)
1585 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1587 reltab = xmalloc (relsize * sizeof (arelent));
1589 reltab[relcount].address = address;
1590 reltab[relcount].addend = 0;
1591 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1592 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1597 save_relocs (asection *sec)
1601 sec->relocation = reltab;
1602 sec->reloc_count = relcount;
1603 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1604 for (i = 0; i < relcount; i++)
1605 sec->orelocation[i] = sec->relocation + i;
1606 sec->orelocation[relcount] = 0;
1607 sec->flags |= SEC_RELOC;
1609 relcount = relsize = 0;
1612 /* .section .idata$2
1613 .global __head_my_dll
1630 make_head (bfd *parent)
1632 asection *id2, *id5, *id4;
1633 unsigned char *d2, *d5, *d4;
1637 oname = xmalloc (20);
1638 sprintf (oname, "d%06d.o", tmp_seq);
1641 abfd = bfd_create (oname, parent);
1642 bfd_find_target (pe_details->object_target, abfd);
1643 bfd_make_writable (abfd);
1645 bfd_set_format (abfd, bfd_object);
1646 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1649 symtab = xmalloc (6 * sizeof (asymbol *));
1650 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1651 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1652 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1653 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1654 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1656 /* OK, pay attention here. I got confused myself looking back at
1657 it. We create a four-byte section to mark the beginning of the
1658 list, and we include an offset of 4 in the section, so that the
1659 pointer to the list points to the *end* of this section, which is
1660 the start of the list of sections from other objects. */
1662 bfd_set_section_size (abfd, id2, 20);
1666 d2[0] = d2[16] = 4; /* Reloc addend. */
1667 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1668 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1669 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1672 bfd_set_section_size (abfd, id5, 4);
1677 bfd_set_section_size (abfd, id4, 4);
1682 bfd_set_symtab (abfd, symtab, symptr);
1684 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1685 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1686 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1688 bfd_make_readable (abfd);
1692 /* .section .idata$4
1697 .global __my_dll_iname
1702 make_tail (bfd *parent)
1704 asection *id4, *id5, *id7;
1705 unsigned char *d4, *d5, *d7;
1710 oname = xmalloc (20);
1711 sprintf (oname, "d%06d.o", tmp_seq);
1714 abfd = bfd_create (oname, parent);
1715 bfd_find_target (pe_details->object_target, abfd);
1716 bfd_make_writable (abfd);
1718 bfd_set_format (abfd, bfd_object);
1719 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1722 symtab = xmalloc (5 * sizeof (asymbol *));
1723 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1724 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1725 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1726 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1728 bfd_set_section_size (abfd, id4, 4);
1733 bfd_set_section_size (abfd, id5, 4);
1738 len = strlen (dll_filename) + 1;
1741 bfd_set_section_size (abfd, id7, len);
1744 strcpy ((char *) d7, dll_filename);
1746 bfd_set_symtab (abfd, symtab, symptr);
1748 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1749 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1750 bfd_set_section_contents (abfd, id7, d7, 0, len);
1752 bfd_make_readable (abfd);
1758 .global ___imp_function
1759 .global __imp__function
1761 jmp *__imp__function:
1775 .asciz "function" xlate? (add underscore, kill at) */
1777 static unsigned char jmp_ix86_bytes[] =
1779 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1787 .dw __imp_function */
1789 static unsigned char jmp_sh_bytes[] =
1791 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1795 lui $t0,<high:__imp_function>
1796 lw $t0,<low:__imp_function>
1800 static unsigned char jmp_mips_bytes[] =
1802 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1803 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1806 static unsigned char jmp_arm_bytes[] =
1808 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1809 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1815 make_one (def_file_export *exp, bfd *parent)
1817 asection *tx, *id7, *id5, *id4, *id6;
1818 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1822 unsigned char *jmp_bytes = NULL;
1823 int jmp_byte_count = 0;
1825 switch (pe_details->pe_arch)
1828 jmp_bytes = jmp_ix86_bytes;
1829 jmp_byte_count = sizeof (jmp_ix86_bytes);
1832 jmp_bytes = jmp_sh_bytes;
1833 jmp_byte_count = sizeof (jmp_sh_bytes);
1836 jmp_bytes = jmp_mips_bytes;
1837 jmp_byte_count = sizeof (jmp_mips_bytes);
1840 jmp_bytes = jmp_arm_bytes;
1841 jmp_byte_count = sizeof (jmp_arm_bytes);
1847 oname = xmalloc (20);
1848 sprintf (oname, "d%06d.o", tmp_seq);
1851 abfd = bfd_create (oname, parent);
1852 bfd_find_target (pe_details->object_target, abfd);
1853 bfd_make_writable (abfd);
1855 bfd_set_format (abfd, bfd_object);
1856 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1859 symtab = xmalloc (11 * sizeof (asymbol *));
1860 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1861 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1862 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1863 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1864 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1866 if (*exp->internal_name == '@')
1868 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1870 if (! exp->flag_data)
1871 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
1872 quick_symbol (abfd, U ("_imp_"), exp->internal_name, "", id5,
1874 /* Fastcall applies only to functions,
1875 so no need for auto-import symbol. */
1879 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1881 if (! exp->flag_data)
1882 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
1884 quick_symbol (abfd, U ("_imp__"), exp->internal_name, "", id5,
1886 /* Symbol to reference ord/name of imported
1887 data symbol, used to implement auto-import. */
1889 quick_symbol (abfd, U("_nm__"), exp->internal_name, "", id6,
1892 if (pe_dll_compat_implib)
1893 quick_symbol (abfd, U ("__imp_"), exp->internal_name, "", id5,
1896 if (! exp->flag_data)
1898 bfd_set_section_size (abfd, tx, jmp_byte_count);
1899 td = xmalloc (jmp_byte_count);
1901 memcpy (td, jmp_bytes, jmp_byte_count);
1903 switch (pe_details->pe_arch)
1906 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1909 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1912 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1913 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1914 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1917 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1925 bfd_set_section_size (abfd, id7, 4);
1929 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
1932 bfd_set_section_size (abfd, id5, 4);
1937 if (exp->flag_noname)
1939 d5[0] = exp->ordinal;
1940 d5[1] = exp->ordinal >> 8;
1945 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1949 bfd_set_section_size (abfd, id4, 4);
1954 if (exp->flag_noname)
1956 d4[0] = exp->ordinal;
1957 d4[1] = exp->ordinal >> 8;
1962 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1966 if (exp->flag_noname)
1969 bfd_set_section_size (abfd, id6, 0);
1973 len = strlen (exp->name) + 3;
1976 bfd_set_section_size (abfd, id6, len);
1979 memset (d6, 0, len);
1980 d6[0] = exp->hint & 0xff;
1981 d6[1] = exp->hint >> 8;
1982 strcpy ((char *) d6 + 2, exp->name);
1985 bfd_set_symtab (abfd, symtab, symptr);
1987 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
1988 bfd_set_section_contents (abfd, id7, d7, 0, 4);
1989 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1990 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1991 if (!exp->flag_noname)
1992 bfd_set_section_contents (abfd, id6, d6, 0, len);
1994 bfd_make_readable (abfd);
1999 make_singleton_name_thunk (const char *import, bfd *parent)
2001 /* Name thunks go to idata$4. */
2007 oname = xmalloc (20);
2008 sprintf (oname, "nmth%06d.o", tmp_seq);
2011 abfd = bfd_create (oname, parent);
2012 bfd_find_target (pe_details->object_target, abfd);
2013 bfd_make_writable (abfd);
2015 bfd_set_format (abfd, bfd_object);
2016 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2019 symtab = xmalloc (3 * sizeof (asymbol *));
2020 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2021 quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
2022 quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
2024 bfd_set_section_size (abfd, id4, 8);
2028 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2031 bfd_set_symtab (abfd, symtab, symptr);
2033 bfd_set_section_contents (abfd, id4, d4, 0, 8);
2035 bfd_make_readable (abfd);
2040 make_import_fixup_mark (arelent *rel)
2042 /* We convert reloc to symbol, for later reference. */
2044 static char *fixup_name = NULL;
2045 static size_t buffer_len = 0;
2047 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2049 bfd *abfd = bfd_asymbol_bfd (sym);
2050 struct bfd_link_hash_entry *bh;
2054 fixup_name = xmalloc (384);
2058 if (strlen (sym->name) + 25 > buffer_len)
2059 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2060 bigger than 20 digits long, we've got worse problems than
2061 overflowing this buffer... */
2064 /* New buffer size is length of symbol, plus 25, but
2065 then rounded up to the nearest multiple of 128. */
2066 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2067 fixup_name = xmalloc (buffer_len);
2070 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2073 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2074 current_sec, /* sym->section, */
2075 rel->address, NULL, TRUE, FALSE, &bh);
2079 struct coff_link_hash_entry *myh;
2081 myh = (struct coff_link_hash_entry *) bh;
2082 printf ("type:%d\n", myh->type);
2083 printf ("%s\n", myh->root.u.def.section->name);
2089 /* .section .idata$2
2090 .rva __nm_thnk_SYM (singleton thunk with name of func)
2093 .rva __my_dll_iname (name of dll)
2094 .rva __fuNN_SYM (pointer to reference (address) in text) */
2097 make_import_fixup_entry (const char *name,
2098 const char *fixup_name,
2099 const char *dll_symname,
2107 oname = xmalloc (20);
2108 sprintf (oname, "fu%06d.o", tmp_seq);
2111 abfd = bfd_create (oname, parent);
2112 bfd_find_target (pe_details->object_target, abfd);
2113 bfd_make_writable (abfd);
2115 bfd_set_format (abfd, bfd_object);
2116 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2119 symtab = xmalloc (6 * sizeof (asymbol *));
2120 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2122 quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2123 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2124 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2126 bfd_set_section_size (abfd, id2, 20);
2131 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2132 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2133 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2136 bfd_set_symtab (abfd, symtab, symptr);
2138 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2140 bfd_make_readable (abfd);
2144 /* .section .rdata_runtime_pseudo_reloc
2146 .rva __fuNN_SYM (pointer to reference (address) in text) */
2149 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2150 const char *fixup_name,
2155 unsigned char *rt_rel_d;
2159 oname = xmalloc (20);
2160 sprintf (oname, "rtr%06d.o", tmp_seq);
2163 abfd = bfd_create (oname, parent);
2164 bfd_find_target (pe_details->object_target, abfd);
2165 bfd_make_writable (abfd);
2167 bfd_set_format (abfd, bfd_object);
2168 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2171 symtab = xmalloc (2 * sizeof (asymbol *));
2172 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2173 SEC_HAS_CONTENTS, 2);
2175 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2177 bfd_set_section_size (abfd, rt_rel, 8);
2178 rt_rel_d = xmalloc (8);
2179 rt_rel->contents = rt_rel_d;
2180 memset (rt_rel_d, 0, 8);
2181 bfd_put_32 (abfd, addend, rt_rel_d);
2183 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2184 save_relocs (rt_rel);
2186 bfd_set_symtab (abfd, symtab, symptr);
2188 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2190 bfd_make_readable (abfd);
2195 .rva __pei386_runtime_relocator */
2198 pe_create_runtime_relocator_reference (bfd *parent)
2200 asection *extern_rt_rel;
2201 unsigned char *extern_rt_rel_d;
2205 oname = xmalloc (20);
2206 sprintf (oname, "ertr%06d.o", tmp_seq);
2209 abfd = bfd_create (oname, parent);
2210 bfd_find_target (pe_details->object_target, abfd);
2211 bfd_make_writable (abfd);
2213 bfd_set_format (abfd, bfd_object);
2214 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2217 symtab = xmalloc (2 * sizeof (asymbol *));
2218 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2220 quick_symbol (abfd, "", "__pei386_runtime_relocator", "", UNDSEC,
2223 bfd_set_section_size (abfd, extern_rt_rel, 4);
2224 extern_rt_rel_d = xmalloc (4);
2225 extern_rt_rel->contents = extern_rt_rel_d;
2227 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2228 save_relocs (extern_rt_rel);
2230 bfd_set_symtab (abfd, symtab, symptr);
2232 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
2234 bfd_make_readable (abfd);
2239 pe_create_import_fixup (arelent *rel, asection *s, int addend)
2242 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2243 struct bfd_link_hash_entry *name_thunk_sym;
2244 const char *name = sym->name;
2245 char *fixup_name = make_import_fixup_mark (rel);
2248 sprintf (buf, U ("_nm_thnk_%s"), name);
2250 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2252 if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2254 bfd *b = make_singleton_name_thunk (name, output_bfd);
2255 add_bfd_to_link (b, b->filename, &link_info);
2257 /* If we ever use autoimport, we have to cast text section writable. */
2258 config.text_read_only = FALSE;
2259 output_bfd->flags &= ~WP_TEXT;
2262 if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2264 extern char * pe_data_import_dll;
2265 char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2267 b = make_import_fixup_entry (name, fixup_name, dll_symname, output_bfd);
2268 add_bfd_to_link (b, b->filename, &link_info);
2273 if (link_info.pei386_runtime_pseudo_reloc)
2275 if (pe_dll_extra_pe_debug)
2276 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2277 fixup_name, addend);
2278 b = make_runtime_pseudo_reloc (name, fixup_name, addend, output_bfd);
2279 add_bfd_to_link (b, b->filename, &link_info);
2281 if (runtime_pseudo_relocs_created == 0)
2283 b = pe_create_runtime_relocator_reference (output_bfd);
2284 add_bfd_to_link (b, b->filename, &link_info);
2286 runtime_pseudo_relocs_created++;
2290 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2291 s->owner, s, rel->address, sym->name);
2299 pe_dll_generate_implib (def_file *def, const char *impfilename)
2307 dll_filename = (def->name) ? def->name : dll_name;
2308 dll_symname = xstrdup (dll_filename);
2309 for (i = 0; dll_symname[i]; i++)
2310 if (!ISALNUM (dll_symname[i]))
2311 dll_symname[i] = '_';
2313 unlink_if_ordinary (impfilename);
2315 outarch = bfd_openw (impfilename, 0);
2319 /* xgettext:c-format */
2320 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2324 /* xgettext:c-format */
2325 info_msg (_("Creating library file: %s\n"), impfilename);
2327 bfd_set_format (outarch, bfd_archive);
2328 outarch->has_armap = 1;
2330 /* Work out a reasonable size of things to put onto one line. */
2331 ar_head = make_head (outarch);
2333 for (i = 0; i < def->num_exports; i++)
2335 /* The import library doesn't know about the internal name. */
2336 char *internal = def->exports[i].internal_name;
2339 /* Don't add PRIVATE entries to import lib. */
2340 if (pe_def_file->exports[i].flag_private)
2342 def->exports[i].internal_name = def->exports[i].name;
2343 n = make_one (def->exports + i, outarch);
2346 def->exports[i].internal_name = internal;
2349 ar_tail = make_tail (outarch);
2351 if (ar_head == NULL || ar_tail == NULL)
2354 /* Now stick them all into the archive. */
2355 ar_head->next = head;
2356 ar_tail->next = ar_head;
2359 if (! bfd_set_archive_head (outarch, head))
2360 einfo ("%Xbfd_set_archive_head: %E\n");
2362 if (! bfd_close (outarch))
2363 einfo ("%Xbfd_close %s: %E\n", impfilename);
2365 while (head != NULL)
2367 bfd *n = head->next;
2374 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *link_info)
2376 lang_input_statement_type *fake_file;
2378 fake_file = lang_add_input_file (name,
2379 lang_input_file_is_fake_enum,
2381 fake_file->the_bfd = abfd;
2382 ldlang_add_file (fake_file);
2384 if (!bfd_link_add_symbols (abfd, link_info))
2385 einfo ("%Xaddsym %s: %E\n", name);
2389 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *link_info)
2391 def_file_module *module;
2393 pe_dll_id_target (bfd_get_target (output_bfd));
2398 for (module = pe_def_file->modules; module; module = module->next)
2402 dll_filename = module->name;
2403 dll_symname = xstrdup (module->name);
2404 for (i = 0; dll_symname[i]; i++)
2405 if (!ISALNUM (dll_symname[i]))
2406 dll_symname[i] = '_';
2410 for (i = 0; i < pe_def_file->num_imports; i++)
2411 if (pe_def_file->imports[i].module == module)
2413 def_file_export exp;
2414 struct bfd_link_hash_entry *blhe;
2415 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2416 /* See if we need this import. */
2417 size_t len = strlen (pe_def_file->imports[i].internal_name);
2418 char *name = xmalloc (len + 2 + 6);
2421 sprintf (name, "%s%s", "",
2422 pe_def_file->imports[i].internal_name);
2424 sprintf (name, "%s%s",U (""),
2425 pe_def_file->imports[i].internal_name);
2427 blhe = bfd_link_hash_lookup (link_info->hash, name,
2428 FALSE, FALSE, FALSE);
2430 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2433 sprintf (name, "%s%s", U ("_imp_"),
2434 pe_def_file->imports[i].internal_name);
2436 sprintf (name, "%s%s", U ("_imp__"),
2437 pe_def_file->imports[i].internal_name);
2439 blhe = bfd_link_hash_lookup (link_info->hash, name,
2440 FALSE, FALSE, FALSE);
2444 if (blhe && blhe->type == bfd_link_hash_undefined)
2450 bfd *ar_head = make_head (output_bfd);
2451 add_bfd_to_link (ar_head, ar_head->filename, link_info);
2454 exp.internal_name = pe_def_file->imports[i].internal_name;
2455 exp.name = pe_def_file->imports[i].name;
2456 exp.ordinal = pe_def_file->imports[i].ordinal;
2457 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2458 exp.flag_private = 0;
2459 exp.flag_constant = 0;
2460 exp.flag_data = pe_def_file->imports[i].data;
2461 exp.flag_noname = exp.name ? 0 : 1;
2462 one = make_one (&exp, output_bfd);
2463 add_bfd_to_link (one, one->filename, link_info);
2468 bfd *ar_tail = make_tail (output_bfd);
2469 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2476 /* We were handed a *.DLL file. Parse it and turn it into a set of
2477 IMPORTS directives in the def file. Return TRUE if the file was
2478 handled, FALSE if not. */
2481 pe_get16 (bfd *abfd, int where)
2485 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2486 bfd_bread (b, (bfd_size_type) 2, abfd);
2487 return b[0] + (b[1] << 8);
2491 pe_get32 (bfd *abfd, int where)
2495 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2496 bfd_bread (b, (bfd_size_type) 4, abfd);
2497 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2503 unsigned char *b = ptr;
2505 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2509 pe_implied_import_dll (const char *filename)
2512 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
2513 unsigned long export_rva, export_size, nsections, secptr, expptr;
2514 unsigned long exp_funcbase;
2515 unsigned char *expdata;
2517 unsigned long name_rvas, ordinals, nexp, ordbase;
2518 const char *dll_name;
2519 /* Initialization with start > end guarantees that is_data
2520 will not be set by mistake, and avoids compiler warning. */
2521 unsigned long data_start = 1;
2522 unsigned long data_end = 0;
2523 unsigned long rdata_start = 1;
2524 unsigned long rdata_end = 0;
2525 unsigned long bss_start = 1;
2526 unsigned long bss_end = 0;
2528 /* No, I can't use bfd here. kernel32.dll puts its export table in
2529 the middle of the .rdata section. */
2530 dll = bfd_openr (filename, pe_details->target_name);
2533 einfo ("%Xopen %s: %E\n", filename);
2537 /* PEI dlls seem to be bfd_objects. */
2538 if (!bfd_check_format (dll, bfd_object))
2540 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2544 /* Get pe_header, optional header and numbers of export entries. */
2545 pe_header_offset = pe_get32 (dll, 0x3c);
2546 opthdr_ofs = pe_header_offset + 4 + 20;
2547 num_entries = pe_get32 (dll, opthdr_ofs + 92);
2549 if (num_entries < 1) /* No exports. */
2552 export_rva = pe_get32 (dll, opthdr_ofs + 96);
2553 export_size = pe_get32 (dll, opthdr_ofs + 100);
2554 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2555 secptr = (pe_header_offset + 4 + 20 +
2556 pe_get16 (dll, pe_header_offset + 4 + 16));
2559 /* Get the rva and size of the export section. */
2560 for (i = 0; i < nsections; i++)
2563 unsigned long secptr1 = secptr + 40 * i;
2564 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2565 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
2566 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
2568 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2569 bfd_bread (sname, (bfd_size_type) 8, dll);
2571 if (vaddr <= export_rva && vaddr + vsize > export_rva)
2573 expptr = fptr + (export_rva - vaddr);
2574 if (export_rva + export_size > vaddr + vsize)
2575 export_size = vsize - (export_rva - vaddr);
2580 /* Scan sections and store the base and size of the
2581 data and bss segments in data/base_start/end. */
2582 for (i = 0; i < nsections; i++)
2584 unsigned long secptr1 = secptr + 40 * i;
2585 unsigned long vsize = pe_get32 (dll, secptr1 + 8);
2586 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2587 unsigned long flags = pe_get32 (dll, secptr1 + 36);
2591 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
2592 bfd_bread (sec_name, (bfd_size_type) 8, dll);
2594 if (strcmp(sec_name,".data") == 0)
2597 data_end = vaddr + vsize;
2599 if (pe_dll_extra_pe_debug)
2600 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2601 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2603 else if (strcmp(sec_name,".rdata") == 0)
2605 rdata_start = vaddr;
2606 rdata_end = vaddr + vsize;
2608 if (pe_dll_extra_pe_debug)
2609 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2610 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2612 else if (strcmp (sec_name,".bss") == 0)
2615 bss_end = vaddr + vsize;
2617 if (pe_dll_extra_pe_debug)
2618 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2619 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2623 expdata = xmalloc (export_size);
2624 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2625 bfd_bread (expdata, (bfd_size_type) export_size, dll);
2626 erva = (char *) expdata - export_rva;
2628 if (pe_def_file == 0)
2629 pe_def_file = def_file_empty ();
2631 nexp = pe_as32 (expdata + 24);
2632 name_rvas = pe_as32 (expdata + 32);
2633 ordinals = pe_as32 (expdata + 36);
2634 ordbase = pe_as32 (expdata + 16);
2635 exp_funcbase = pe_as32 (expdata + 28);
2637 /* Use internal dll name instead of filename
2638 to enable symbolic dll linking. */
2639 dll_name = erva + pe_as32 (expdata + 12);
2641 /* Check to see if the dll has already been added to
2642 the definition list and if so return without error.
2643 This avoids multiple symbol definitions. */
2644 if (def_get_module (pe_def_file, dll_name))
2646 if (pe_dll_extra_pe_debug)
2647 printf ("%s is already loaded\n", dll_name);
2651 /* Iterate through the list of symbols. */
2652 for (i = 0; i < nexp; i++)
2654 /* Pointer to the names vector. */
2655 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
2656 def_file_import *imp;
2657 /* Pointer to the function address vector. */
2658 unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
2661 /* Skip unwanted symbols, which are
2662 exported in buggy auto-import releases. */
2663 if (strncmp (erva + name_rva, "_nm_", 4) != 0)
2665 /* is_data is true if the address is in the data, rdata or bss
2668 (func_rva >= data_start && func_rva < data_end)
2669 || (func_rva >= rdata_start && func_rva < rdata_end)
2670 || (func_rva >= bss_start && func_rva < bss_end);
2672 imp = def_file_add_import (pe_def_file, erva + name_rva,
2674 /* Mark symbol type. */
2675 imp->data = is_data;
2677 if (pe_dll_extra_pe_debug)
2678 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2679 __FUNCTION__, dll_name, erva + name_rva,
2680 func_rva, is_data ? "(data)" : "");
2687 /* These are the main functions, called from the emulation. The first
2688 is called after the bfds are read, so we can guess at how much space
2689 we need. The second is called after everything is placed, so we
2690 can put the right values in place. */
2693 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
2695 pe_dll_id_target (bfd_get_target (abfd));
2696 process_def_file (abfd, info);
2698 if (pe_def_file->num_exports == 0 && !info->shared)
2701 generate_edata (abfd, info);
2702 build_filler_bfd (1);
2706 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2708 pe_dll_id_target (bfd_get_target (abfd));
2709 build_filler_bfd (0);
2713 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
2715 pe_dll_id_target (bfd_get_target (abfd));
2716 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2718 generate_reloc (abfd, info);
2721 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2723 /* Resize the sections. */
2724 lang_reset_memory_regions ();
2725 lang_size_sections (NULL, TRUE);
2727 /* Redo special stuff. */
2728 ldemul_after_allocation ();
2730 /* Do the assignments again. */
2731 lang_do_assignments ();
2734 fill_edata (abfd, info);
2736 if (info->shared && !info->pie)
2737 pe_data (abfd)->dll = 1;
2739 edata_s->contents = edata_d;
2740 reloc_s->contents = reloc_d;
2744 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
2746 pe_dll_id_target (bfd_get_target (abfd));
2747 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2749 generate_reloc (abfd, info);
2752 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2754 /* Resize the sections. */
2755 lang_reset_memory_regions ();
2756 lang_size_sections (NULL, TRUE);
2758 /* Redo special stuff. */
2759 ldemul_after_allocation ();
2761 /* Do the assignments again. */
2762 lang_do_assignments ();
2764 reloc_s->contents = reloc_d;