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. */
300 /* Don't re-export auto-imported symbols. */
302 { "__builtin_", 10 },
303 /* Don't export symbols specifying internal DLL layout. */
308 static autofilter_entry_type autofilter_symbolsuffixlist[] =
314 #define U(str) (pe_details->underscored ? "_" str : str)
317 pe_dll_id_target (const char *target)
321 for (i = 0; pe_detail_list[i].target_name; i++)
322 if (strcmp (pe_detail_list[i].target_name, target) == 0
323 || strcmp (pe_detail_list[i].object_target, target) == 0)
325 pe_details = pe_detail_list + i;
328 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
332 /* Helper functions for qsort. Relocs must be sorted so that we can write
333 them out by pages. */
344 reloc_sort (const void *va, const void *vb)
346 bfd_vma a = ((const reloc_data_type *) va)->vma;
347 bfd_vma b = ((const reloc_data_type *) vb)->vma;
349 return (a > b) ? 1 : ((a < b) ? -1 : 0);
353 pe_export_sort (const void *va, const void *vb)
355 const def_file_export *a = va;
356 const def_file_export *b = vb;
358 return strcmp (a->name, b->name);
361 /* Read and process the .DEF file. */
363 /* These correspond to the entries in pe_def_file->exports[]. I use
364 exported_symbol_sections[i] to tag whether or not the symbol was
365 defined, since we can't export symbols we don't have. */
367 static bfd_vma *exported_symbol_offsets;
368 static struct bfd_section **exported_symbol_sections;
369 static int export_table_size;
370 static int count_exported;
371 static int count_exported_byname;
372 static int count_with_ordinals;
373 static const char *dll_name;
374 static int min_ordinal, max_ordinal;
375 static int *exported_symbols;
377 typedef struct exclude_list_struct
380 struct exclude_list_struct *next;
385 static struct exclude_list_struct *excludes = 0;
388 pe_dll_add_excludes (const char *new_excludes, const int type)
391 char *exclude_string;
393 local_copy = xstrdup (new_excludes);
395 exclude_string = strtok (local_copy, ",:");
396 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
398 struct exclude_list_struct *new_exclude;
400 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
401 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
402 strcpy (new_exclude->string, exclude_string);
403 new_exclude->type = type;
404 new_exclude->next = excludes;
405 excludes = new_exclude;
412 /* abfd is a bfd containing n (or NULL)
413 It can be used for contextual checks. */
416 auto_export (bfd *abfd, def_file *d, const char *n)
419 struct exclude_list_struct *ex;
420 autofilter_entry_type *afptr;
421 const char * libname = 0;
422 if (abfd && abfd->my_archive)
423 libname = lbasename (abfd->my_archive->filename);
425 /* We should not re-export imported stuff. */
426 if (strncmp (n, "_imp_", 5) == 0)
429 for (i = 0; i < d->num_exports; i++)
430 if (strcmp (d->exports[i].name, n) == 0)
433 if (pe_dll_do_default_excludes)
438 if (pe_dll_extra_pe_debug)
439 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
440 n, abfd, abfd->my_archive);
442 /* First of all, make context checks:
443 Don't export anything from standard libs. */
446 afptr = autofilter_liblist;
450 if (strncmp (libname, afptr->name, afptr->len) == 0 )
456 /* Next, exclude symbols from certain startup objects. */
458 if (abfd && (p = lbasename (abfd->filename)))
460 afptr = autofilter_objlist;
463 if (strcmp (p, afptr->name) == 0)
469 /* Don't try to blindly exclude all symbols
470 that begin with '__'; this was tried and
471 it is too restrictive. Instead we have
472 a target specific list to use: */
473 afptr = pe_details->autofilter_symbollist;
476 if (strcmp (n, afptr->name) == 0)
482 /* Next, exclude symbols starting with ... */
483 afptr = autofilter_symbolprefixlist;
486 if (strncmp (n, afptr->name, afptr->len) == 0)
492 /* Finally, exclude symbols ending with ... */
494 afptr = autofilter_symbolsuffixlist;
497 if ((len >= afptr->len)
498 /* Add 1 to insure match with trailing '\0'. */
499 && strncmp (n + len - afptr->len, afptr->name,
500 afptr->len + 1) == 0)
507 for (ex = excludes; ex; ex = ex->next)
509 if (ex->type == 1) /* exclude-libs */
512 && ((strcmp (libname, ex->string) == 0)
513 || (strcasecmp ("ALL", ex->string) == 0)))
516 else if (strcmp (n, ex->string) == 0)
524 process_def_file (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
527 struct bfd_link_hash_entry *blhe;
529 struct bfd_section *s;
530 def_file_export *e = 0;
533 pe_def_file = def_file_empty ();
535 /* First, run around to all the objects looking for the .drectve
536 sections, and push those into the def file too. */
537 for (b = info->input_bfds; b; b = b->link_next)
539 s = bfd_get_section_by_name (b, ".drectve");
543 char *buf = xmalloc (size);
545 bfd_get_section_contents (b, s, buf, 0, size);
546 def_file_add_directive (pe_def_file, buf, size);
551 /* If we are not building a DLL, when there are no exports
552 we do not build an export table at all. */
553 if (!pe_dll_export_everything && pe_def_file->num_exports == 0
557 /* Now, maybe export everything else the default way. */
558 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
560 for (b = info->input_bfds; b; b = b->link_next)
565 symsize = bfd_get_symtab_upper_bound (b);
566 symbols = xmalloc (symsize);
567 nsyms = bfd_canonicalize_symtab (b, symbols);
569 for (j = 0; j < nsyms; j++)
571 /* We should export symbols which are either global or not
572 anything at all. (.bss data is the latter)
573 We should not export undefined symbols. */
574 if (symbols[j]->section != &bfd_und_section
575 && ((symbols[j]->flags & BSF_GLOBAL)
576 || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
578 const char *sn = symbols[j]->name;
580 /* We should not re-export imported stuff. */
582 char *name = xmalloc (strlen (sn) + 2 + 6);
583 sprintf (name, "%s%s", U("_imp_"), sn);
585 blhe = bfd_link_hash_lookup (info->hash, name,
586 FALSE, FALSE, FALSE);
589 if (blhe && blhe->type == bfd_link_hash_defined)
596 if (auto_export (b, pe_def_file, sn))
599 p=def_file_add_export (pe_def_file, sn, 0, -1);
600 /* Fill data flag properly, from dlltool.c. */
601 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
609 #define NE pe_def_file->num_exports
611 /* Canonicalize the export list. */
614 for (i = 0; i < NE; i++)
616 if (strchr (pe_def_file->exports[i].name, '@'))
618 /* This will preserve internal_name, which may have been
619 pointing to the same memory as name, or might not
621 int lead_at = (*pe_def_file->exports[i].name == '@');
622 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
623 char *tmp_at = strchr (tmp, '@');
628 einfo (_("%XCannot export %s: invalid export name\n"),
629 pe_def_file->exports[i].name);
630 pe_def_file->exports[i].name = tmp;
635 if (pe_dll_stdcall_aliases)
637 for (i = 0; i < NE; i++)
639 if (strchr (pe_def_file->exports[i].name, '@'))
641 int lead_at = (*pe_def_file->exports[i].name == '@');
642 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
644 *(strchr (tmp, '@')) = 0;
645 if (auto_export (NULL, pe_def_file, tmp))
646 def_file_add_export (pe_def_file, tmp,
647 pe_def_file->exports[i].internal_name,
655 /* Convenience, but watch out for it changing. */
656 e = pe_def_file->exports;
658 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
659 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
661 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
665 count_exported_byname = 0;
666 count_with_ordinals = 0;
668 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
670 for (i = 0, j = 0; i < NE; i++)
672 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
674 /* This is a duplicate. */
675 if (e[j - 1].ordinal != -1
676 && e[i].ordinal != -1
677 && e[j - 1].ordinal != e[i].ordinal)
679 if (pe_dll_warn_dup_exports)
680 /* xgettext:c-format */
681 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
682 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
686 if (pe_dll_warn_dup_exports)
687 /* xgettext:c-format */
688 einfo (_("Warning, duplicate EXPORT: %s\n"),
692 if (e[i].ordinal != -1)
693 e[j - 1].ordinal = e[i].ordinal;
694 e[j - 1].flag_private |= e[i].flag_private;
695 e[j - 1].flag_constant |= e[i].flag_constant;
696 e[j - 1].flag_noname |= e[i].flag_noname;
697 e[j - 1].flag_data |= e[i].flag_data;
706 pe_def_file->num_exports = j; /* == NE */
708 for (i = 0; i < NE; i++)
712 /* Check for forward exports */
713 if (strchr (pe_def_file->exports[i].internal_name, '.'))
716 if (!pe_def_file->exports[i].flag_noname)
717 count_exported_byname++;
719 pe_def_file->exports[i].flag_forward = 1;
721 if (pe_def_file->exports[i].ordinal != -1)
723 if (max_ordinal < pe_def_file->exports[i].ordinal)
724 max_ordinal = pe_def_file->exports[i].ordinal;
725 if (min_ordinal > pe_def_file->exports[i].ordinal)
726 min_ordinal = pe_def_file->exports[i].ordinal;
727 count_with_ordinals++;
733 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
734 if (pe_details->underscored
735 && (*pe_def_file->exports[i].internal_name != '@'))
738 strcpy (name + 1, pe_def_file->exports[i].internal_name);
741 strcpy (name, pe_def_file->exports[i].internal_name);
743 blhe = bfd_link_hash_lookup (info->hash,
748 && (blhe->type == bfd_link_hash_defined
749 || (blhe->type == bfd_link_hash_common)))
752 if (!pe_def_file->exports[i].flag_noname)
753 count_exported_byname++;
755 /* Only fill in the sections. The actual offsets are computed
756 in fill_exported_offsets() after common symbols are laid
758 if (blhe->type == bfd_link_hash_defined)
759 exported_symbol_sections[i] = blhe->u.def.section;
761 exported_symbol_sections[i] = blhe->u.c.p->section;
763 if (pe_def_file->exports[i].ordinal != -1)
765 if (max_ordinal < pe_def_file->exports[i].ordinal)
766 max_ordinal = pe_def_file->exports[i].ordinal;
767 if (min_ordinal > pe_def_file->exports[i].ordinal)
768 min_ordinal = pe_def_file->exports[i].ordinal;
769 count_with_ordinals++;
772 else if (blhe && blhe->type == bfd_link_hash_undefined)
774 /* xgettext:c-format */
775 einfo (_("%XCannot export %s: symbol not defined\n"),
776 pe_def_file->exports[i].internal_name);
780 /* xgettext:c-format */
781 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
782 pe_def_file->exports[i].internal_name,
783 blhe->type, bfd_link_hash_defined);
787 /* xgettext:c-format */
788 einfo (_("%XCannot export %s: symbol not found\n"),
789 pe_def_file->exports[i].internal_name);
795 /* Build the bfd that will contain .edata and .reloc sections. */
798 build_filler_bfd (int include_edata)
800 lang_input_statement_type *filler_file;
801 filler_file = lang_add_input_file ("dll stuff",
802 lang_input_file_is_fake_enum,
804 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
805 if (filler_bfd == NULL
806 || !bfd_set_arch_mach (filler_bfd,
807 bfd_get_arch (output_bfd),
808 bfd_get_mach (output_bfd)))
810 einfo ("%X%P: can not create BFD: %E\n");
816 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
818 || !bfd_set_section_flags (filler_bfd, edata_s,
825 einfo ("%X%P: can not create .edata section: %E\n");
828 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
831 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
833 || !bfd_set_section_flags (filler_bfd, reloc_s,
840 einfo ("%X%P: can not create .reloc section: %E\n");
844 bfd_set_section_size (filler_bfd, reloc_s, 0);
846 ldlang_add_file (filler_file);
849 /* Gather all the exported symbols and build the .edata section. */
852 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
855 int name_table_size = 0;
858 /* First, we need to know how many exported symbols there are,
859 and what the range of ordinals is. */
860 if (pe_def_file->name)
861 dll_name = pe_def_file->name;
864 dll_name = abfd->filename;
866 for (dlnp = dll_name; *dlnp; dlnp++)
867 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
871 if (count_with_ordinals && max_ordinal > count_exported)
873 if (min_ordinal > max_ordinal - count_exported + 1)
874 min_ordinal = max_ordinal - count_exported + 1;
879 max_ordinal = count_exported;
882 export_table_size = max_ordinal - min_ordinal + 1;
883 exported_symbols = xmalloc (export_table_size * sizeof (int));
884 for (i = 0; i < export_table_size; i++)
885 exported_symbols[i] = -1;
887 /* Now we need to assign ordinals to those that don't have them. */
888 for (i = 0; i < NE; i++)
890 if (exported_symbol_sections[i] ||
891 pe_def_file->exports[i].flag_forward)
893 if (pe_def_file->exports[i].ordinal != -1)
895 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
896 int pi = exported_symbols[ei];
900 /* xgettext:c-format */
901 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
902 pe_def_file->exports[i].ordinal,
903 pe_def_file->exports[i].name,
904 pe_def_file->exports[pi].name);
906 exported_symbols[ei] = i;
908 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
911 /* Reserve space for the forward name. */
912 if (pe_def_file->exports[i].flag_forward)
914 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
918 next_ordinal = min_ordinal;
919 for (i = 0; i < NE; i++)
920 if ((exported_symbol_sections[i] ||
921 pe_def_file->exports[i].flag_forward) &&
922 pe_def_file->exports[i].ordinal == -1)
924 while (exported_symbols[next_ordinal - min_ordinal] != -1)
927 exported_symbols[next_ordinal - min_ordinal] = i;
928 pe_def_file->exports[i].ordinal = next_ordinal;
931 /* OK, now we can allocate some memory. */
932 edata_sz = (40 /* directory */
933 + 4 * export_table_size /* addresses */
934 + 4 * count_exported_byname /* name ptrs */
935 + 2 * count_exported_byname /* ordinals */
936 + name_table_size + strlen (dll_name) + 1);
939 /* Fill the exported symbol offsets. The preliminary work has already
940 been done in process_def_file(). */
943 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
946 struct bfd_link_hash_entry *blhe;
948 for (i = 0; i < pe_def_file->num_exports; i++)
952 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
953 if (pe_details->underscored
954 && *pe_def_file->exports[i].internal_name != '@')
957 strcpy (name + 1, pe_def_file->exports[i].internal_name);
960 strcpy (name, pe_def_file->exports[i].internal_name);
962 blhe = bfd_link_hash_lookup (info->hash,
966 if (blhe && blhe->type == bfd_link_hash_defined)
967 exported_symbol_offsets[i] = blhe->u.def.value;
974 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
977 unsigned char *edirectory;
978 unsigned char *eaddresses;
979 unsigned char *enameptrs;
980 unsigned char *eordinals;
986 edata_d = xmalloc (edata_sz);
988 /* Note use of array pointer math here. */
989 edirectory = edata_d;
990 eaddresses = edata_d + 40;
991 enameptrs = eaddresses + 4 * export_table_size;
992 eordinals = enameptrs + 4 * count_exported_byname;
993 enamestr = (char *) eordinals + 2 * count_exported_byname;
995 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
996 + edata_s->output_section->vma - image_base)
998 memset (edata_d, 0, edata_sz);
999 bfd_put_32 (abfd, now, edata_d + 4);
1000 if (pe_def_file->version_major != -1)
1002 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1003 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1006 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1007 strcpy (enamestr, dll_name);
1008 enamestr += strlen (enamestr) + 1;
1009 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1010 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1011 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1012 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1013 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1014 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1016 fill_exported_offsets (abfd, info);
1018 /* Ok, now for the filling in part.
1019 Scan alphabetically - ie the ordering in the exports[] table,
1020 rather than by ordinal - the ordering in the exported_symbol[]
1021 table. See dlltool.c and:
1022 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1023 for more information. */
1025 for (s = 0; s < NE; s++)
1027 struct bfd_section *ssec = exported_symbol_sections[s];
1028 if (pe_def_file->exports[s].ordinal != -1 &&
1029 (pe_def_file->exports[s].flag_forward || ssec != NULL))
1031 int ord = pe_def_file->exports[s].ordinal;
1033 if (pe_def_file->exports[s].flag_forward)
1035 bfd_put_32 (abfd, ERVA (enamestr),
1036 eaddresses + 4 * (ord - min_ordinal));
1038 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1039 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1043 unsigned long srva = (exported_symbol_offsets[s]
1044 + ssec->output_section->vma
1045 + ssec->output_offset);
1047 bfd_put_32 (abfd, srva - image_base,
1048 eaddresses + 4 * (ord - min_ordinal));
1051 if (!pe_def_file->exports[s].flag_noname)
1053 char *ename = pe_def_file->exports[s].name;
1055 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1057 strcpy (enamestr, ename);
1058 enamestr += strlen (enamestr) + 1;
1059 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1061 pe_def_file->exports[s].hint = hint++;
1068 static struct bfd_section *current_sec;
1071 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1073 int (*cb) (arelent *, asection *))
1078 for (b = info->input_bfds; b; b = b->link_next)
1083 symsize = bfd_get_symtab_upper_bound (b);
1084 symbols = xmalloc (symsize);
1085 nsyms = bfd_canonicalize_symtab (b, symbols);
1087 for (s = b->sections; s; s = s->next)
1090 int relsize, nrelocs, i;
1091 int flags = bfd_get_section_flags (b, s);
1093 /* Skip discarded linkonce sections. */
1094 if (flags & SEC_LINK_ONCE
1095 && s->output_section == bfd_abs_section_ptr)
1100 relsize = bfd_get_reloc_upper_bound (b, s);
1101 relocs = xmalloc (relsize);
1102 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1104 for (i = 0; i < nrelocs; i++)
1106 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1108 if (!strcmp (name, sym->name))
1114 /* Warning: the allocated symbols are remembered in BFD and reused
1115 later, so don't free them! */
1116 /* free (symbols); */
1121 /* Gather all the relocations and build the .reloc section. */
1124 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1127 /* For .reloc stuff. */
1128 reloc_data_type *reloc_data;
1129 int total_relocs = 0;
1131 unsigned long sec_page = (unsigned long) -1;
1132 unsigned long page_ptr, page_count;
1135 struct bfd_section *s;
1138 for (b = info->input_bfds; b; b = b->link_next)
1139 for (s = b->sections; s; s = s->next)
1140 total_relocs += s->reloc_count;
1142 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1146 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1149 int relsize, nrelocs, i;
1151 for (s = b->sections; s; s = s->next)
1153 unsigned long sec_vma = s->output_section->vma + s->output_offset;
1157 /* If it's not loaded, we don't need to relocate it this way. */
1158 #if 0 /* Some toolchains can generate .data sections without a SEC_LOAD flag but with relocs. */
1159 if (!(s->output_section->flags & SEC_LOAD))
1163 if (strncmp (bfd_get_section_name (abfd, s), ".idata",6) == 0)
1166 /* I don't know why there would be a reloc for these, but I've
1167 seen it happen - DJ */
1168 if (s->output_section == &bfd_abs_section)
1171 if (s->output_section->vma == 0)
1173 /* Huh? Shouldn't happen, but punt if it does. */
1174 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1175 s->output_section->name, s->output_section->index,
1176 s->output_section->flags);
1180 symsize = bfd_get_symtab_upper_bound (b);
1181 symbols = xmalloc (symsize);
1182 nsyms = bfd_canonicalize_symtab (b, symbols);
1184 relsize = bfd_get_reloc_upper_bound (b, s);
1185 relocs = xmalloc (relsize);
1186 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1188 for (i = 0; i < nrelocs; i++)
1190 if (pe_dll_extra_pe_debug)
1192 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1193 printf ("rel: %s\n", sym->name);
1195 if (!relocs[i]->howto->pc_relative
1196 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1199 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1201 sym_vma = (relocs[i]->addend
1204 + sym->section->output_offset
1205 + sym->section->output_section->vma);
1206 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1208 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1210 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1211 relocs[i]->howto->rightshift)
1213 case BITS_AND_SHIFT (32, 0):
1214 reloc_data[total_relocs].type = 3;
1217 case BITS_AND_SHIFT (16, 0):
1218 reloc_data[total_relocs].type = 2;
1221 case BITS_AND_SHIFT (16, 16):
1222 reloc_data[total_relocs].type = 4;
1223 /* FIXME: we can't know the symbol's right value
1224 yet, but we probably can safely assume that
1225 CE will relocate us in 64k blocks, so leaving
1227 reloc_data[total_relocs].extra = 0;
1230 case BITS_AND_SHIFT (26, 2):
1231 reloc_data[total_relocs].type = 5;
1234 case BITS_AND_SHIFT (24, 2):
1235 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1236 Those ARM_xxx definitions should go in proper
1238 if (relocs[i]->howto->type == 0
1239 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1240 || relocs[i]->howto->type == 5)
1241 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1242 that has already been fully processed during a
1243 previous link stage, so ignore it here. */
1247 /* xgettext:c-format */
1248 einfo (_("%XError: %d-bit reloc in dll\n"),
1249 relocs[i]->howto->bitsize);
1255 /* Warning: the allocated symbols are remembered in BFD and
1256 reused later, so don't free them! */
1260 /* At this point, we have total_relocs relocation addresses in
1261 reloc_addresses, which are all suitable for the .reloc section.
1262 We must now create the new sections. */
1263 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1265 for (i = 0; i < total_relocs; i++)
1267 unsigned long this_page = (reloc_data[i].vma >> 12);
1269 if (this_page != sec_page)
1271 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1273 sec_page = this_page;
1278 if (reloc_data[i].type == 4)
1282 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1283 reloc_d = xmalloc (reloc_sz);
1284 sec_page = (unsigned long) -1;
1286 page_ptr = (unsigned long) -1;
1289 for (i = 0; i < total_relocs; i++)
1291 unsigned long rva = reloc_data[i].vma - image_base;
1292 unsigned long this_page = (rva & ~0xfff);
1294 if (this_page != sec_page)
1296 while (reloc_sz & 3)
1297 reloc_d[reloc_sz++] = 0;
1299 if (page_ptr != (unsigned long) -1)
1300 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1302 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1303 page_ptr = reloc_sz;
1305 sec_page = this_page;
1309 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1310 reloc_d + reloc_sz);
1313 if (reloc_data[i].type == 4)
1315 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1322 while (reloc_sz & 3)
1323 reloc_d[reloc_sz++] = 0;
1325 if (page_ptr != (unsigned long) -1)
1326 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1328 while (reloc_sz < reloc_s->size)
1329 reloc_d[reloc_sz++] = 0;
1332 /* Given the exiting def_file structure, print out a .DEF file that
1333 corresponds to it. */
1336 quoteput (char *s, FILE *f, int needs_quotes)
1340 for (cp = s; *cp; cp++)
1355 if (*s == '"' || *s == '\\')
1369 pe_dll_generate_def_file (const char *pe_out_def_filename)
1372 FILE *out = fopen (pe_out_def_filename, "w");
1375 /* xgettext:c-format */
1376 einfo (_("%s: Can't open output def file %s\n"),
1377 program_name, pe_out_def_filename);
1381 if (pe_def_file->name)
1383 if (pe_def_file->is_dll)
1384 fprintf (out, "LIBRARY ");
1386 fprintf (out, "NAME ");
1388 quoteput (pe_def_file->name, out, 1);
1390 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
1391 fprintf (out, " BASE=0x%lx",
1392 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
1393 fprintf (out, "\n");
1396 if (pe_def_file->description)
1398 fprintf (out, "DESCRIPTION ");
1399 quoteput (pe_def_file->description, out, 1);
1400 fprintf (out, "\n");
1403 if (pe_def_file->version_minor != -1)
1404 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1405 pe_def_file->version_minor);
1406 else if (pe_def_file->version_major != -1)
1407 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1409 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1410 fprintf (out, "\n");
1412 if (pe_def_file->stack_commit != -1)
1413 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1414 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1415 else if (pe_def_file->stack_reserve != -1)
1416 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1418 if (pe_def_file->heap_commit != -1)
1419 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1420 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1421 else if (pe_def_file->heap_reserve != -1)
1422 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1424 if (pe_def_file->num_section_defs > 0)
1426 fprintf (out, "\nSECTIONS\n\n");
1428 for (i = 0; i < pe_def_file->num_section_defs; i++)
1431 quoteput (pe_def_file->section_defs[i].name, out, 0);
1433 if (pe_def_file->section_defs[i].class)
1435 fprintf (out, " CLASS ");
1436 quoteput (pe_def_file->section_defs[i].class, out, 0);
1439 if (pe_def_file->section_defs[i].flag_read)
1440 fprintf (out, " READ");
1442 if (pe_def_file->section_defs[i].flag_write)
1443 fprintf (out, " WRITE");
1445 if (pe_def_file->section_defs[i].flag_execute)
1446 fprintf (out, " EXECUTE");
1448 if (pe_def_file->section_defs[i].flag_shared)
1449 fprintf (out, " SHARED");
1451 fprintf (out, "\n");
1455 if (pe_def_file->num_exports > 0)
1457 fprintf (out, "EXPORTS\n");
1459 for (i = 0; i < pe_def_file->num_exports; i++)
1461 def_file_export *e = pe_def_file->exports + i;
1463 quoteput (e->name, out, 0);
1465 if (e->internal_name && strcmp (e->internal_name, e->name))
1467 fprintf (out, " = ");
1468 quoteput (e->internal_name, out, 0);
1471 if (e->ordinal != -1)
1472 fprintf (out, " @%d", e->ordinal);
1474 if (e->flag_private)
1475 fprintf (out, " PRIVATE");
1477 if (e->flag_constant)
1478 fprintf (out, " CONSTANT");
1481 fprintf (out, " NONAME");
1484 fprintf (out, " DATA");
1486 fprintf (out, "\n");
1490 if (pe_def_file->num_imports > 0)
1492 fprintf (out, "\nIMPORTS\n\n");
1494 for (i = 0; i < pe_def_file->num_imports; i++)
1496 def_file_import *im = pe_def_file->imports + i;
1499 if (im->internal_name
1500 && (!im->name || strcmp (im->internal_name, im->name)))
1502 quoteput (im->internal_name, out, 0);
1503 fprintf (out, " = ");
1506 quoteput (im->module->name, out, 0);
1510 quoteput (im->name, out, 0);
1512 fprintf (out, "%d", im->ordinal);
1514 fprintf (out, "\n");
1519 fprintf (out, _("; no contents available\n"));
1521 if (fclose (out) == EOF)
1522 /* xgettext:c-format */
1523 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1526 /* Generate the import library. */
1528 static asymbol **symtab;
1531 static const char *dll_filename;
1532 static char *dll_symname;
1534 #define UNDSEC (asection *) &bfd_und_section
1537 quick_section (bfd *abfd, const char *name, int flags, int align)
1542 sec = bfd_make_section_old_way (abfd, name);
1543 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1544 bfd_set_section_alignment (abfd, sec, align);
1545 /* Remember to undo this before trying to link internally! */
1546 sec->output_section = sec;
1548 sym = bfd_make_empty_symbol (abfd);
1549 symtab[symptr++] = sym;
1550 sym->name = sec->name;
1552 sym->flags = BSF_LOCAL;
1559 quick_symbol (bfd *abfd,
1568 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1573 sym = bfd_make_empty_symbol (abfd);
1578 symtab[symptr++] = sym;
1581 static arelent *reltab = 0;
1582 static int relcount = 0, relsize = 0;
1585 quick_reloc (bfd *abfd, int address, int which_howto, int symidx)
1587 if (relcount >= relsize - 1)
1591 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1593 reltab = xmalloc (relsize * sizeof (arelent));
1595 reltab[relcount].address = address;
1596 reltab[relcount].addend = 0;
1597 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1598 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1603 save_relocs (asection *sec)
1607 sec->relocation = reltab;
1608 sec->reloc_count = relcount;
1609 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1610 for (i = 0; i < relcount; i++)
1611 sec->orelocation[i] = sec->relocation + i;
1612 sec->orelocation[relcount] = 0;
1613 sec->flags |= SEC_RELOC;
1615 relcount = relsize = 0;
1618 /* .section .idata$2
1619 .global __head_my_dll
1636 make_head (bfd *parent)
1638 asection *id2, *id5, *id4;
1639 unsigned char *d2, *d5, *d4;
1643 oname = xmalloc (20);
1644 sprintf (oname, "d%06d.o", tmp_seq);
1647 abfd = bfd_create (oname, parent);
1648 bfd_find_target (pe_details->object_target, abfd);
1649 bfd_make_writable (abfd);
1651 bfd_set_format (abfd, bfd_object);
1652 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1655 symtab = xmalloc (6 * sizeof (asymbol *));
1656 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1657 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1658 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1659 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1660 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1662 /* OK, pay attention here. I got confused myself looking back at
1663 it. We create a four-byte section to mark the beginning of the
1664 list, and we include an offset of 4 in the section, so that the
1665 pointer to the list points to the *end* of this section, which is
1666 the start of the list of sections from other objects. */
1668 bfd_set_section_size (abfd, id2, 20);
1672 d2[0] = d2[16] = 4; /* Reloc addend. */
1673 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1674 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1675 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1678 bfd_set_section_size (abfd, id5, 4);
1683 bfd_set_section_size (abfd, id4, 4);
1688 bfd_set_symtab (abfd, symtab, symptr);
1690 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1691 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1692 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1694 bfd_make_readable (abfd);
1698 /* .section .idata$4
1703 .global __my_dll_iname
1708 make_tail (bfd *parent)
1710 asection *id4, *id5, *id7;
1711 unsigned char *d4, *d5, *d7;
1716 oname = xmalloc (20);
1717 sprintf (oname, "d%06d.o", tmp_seq);
1720 abfd = bfd_create (oname, parent);
1721 bfd_find_target (pe_details->object_target, abfd);
1722 bfd_make_writable (abfd);
1724 bfd_set_format (abfd, bfd_object);
1725 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1728 symtab = xmalloc (5 * sizeof (asymbol *));
1729 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1730 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1731 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1732 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1734 bfd_set_section_size (abfd, id4, 4);
1739 bfd_set_section_size (abfd, id5, 4);
1744 len = strlen (dll_filename) + 1;
1747 bfd_set_section_size (abfd, id7, len);
1750 strcpy ((char *) d7, dll_filename);
1752 bfd_set_symtab (abfd, symtab, symptr);
1754 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1755 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1756 bfd_set_section_contents (abfd, id7, d7, 0, len);
1758 bfd_make_readable (abfd);
1764 .global ___imp_function
1765 .global __imp__function
1767 jmp *__imp__function:
1781 .asciz "function" xlate? (add underscore, kill at) */
1783 static unsigned char jmp_ix86_bytes[] =
1785 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1793 .dw __imp_function */
1795 static unsigned char jmp_sh_bytes[] =
1797 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1801 lui $t0,<high:__imp_function>
1802 lw $t0,<low:__imp_function>
1806 static unsigned char jmp_mips_bytes[] =
1808 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1809 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1812 static unsigned char jmp_arm_bytes[] =
1814 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1815 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1821 make_one (def_file_export *exp, bfd *parent)
1823 asection *tx, *id7, *id5, *id4, *id6;
1824 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1828 unsigned char *jmp_bytes = NULL;
1829 int jmp_byte_count = 0;
1831 switch (pe_details->pe_arch)
1834 jmp_bytes = jmp_ix86_bytes;
1835 jmp_byte_count = sizeof (jmp_ix86_bytes);
1838 jmp_bytes = jmp_sh_bytes;
1839 jmp_byte_count = sizeof (jmp_sh_bytes);
1842 jmp_bytes = jmp_mips_bytes;
1843 jmp_byte_count = sizeof (jmp_mips_bytes);
1846 jmp_bytes = jmp_arm_bytes;
1847 jmp_byte_count = sizeof (jmp_arm_bytes);
1853 oname = xmalloc (20);
1854 sprintf (oname, "d%06d.o", tmp_seq);
1857 abfd = bfd_create (oname, parent);
1858 bfd_find_target (pe_details->object_target, abfd);
1859 bfd_make_writable (abfd);
1861 bfd_set_format (abfd, bfd_object);
1862 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1865 symtab = xmalloc (11 * sizeof (asymbol *));
1866 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1867 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1868 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1869 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1870 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1872 if (*exp->internal_name == '@')
1874 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1876 if (! exp->flag_data)
1877 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
1878 quick_symbol (abfd, U ("_imp_"), exp->internal_name, "", id5,
1880 /* Fastcall applies only to functions,
1881 so no need for auto-import symbol. */
1885 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1887 if (! exp->flag_data)
1888 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
1890 quick_symbol (abfd, U ("_imp__"), exp->internal_name, "", id5,
1892 /* Symbol to reference ord/name of imported
1893 data symbol, used to implement auto-import. */
1895 quick_symbol (abfd, U("_nm__"), exp->internal_name, "", id6,
1898 if (pe_dll_compat_implib)
1899 quick_symbol (abfd, U ("__imp_"), exp->internal_name, "", id5,
1902 if (! exp->flag_data)
1904 bfd_set_section_size (abfd, tx, jmp_byte_count);
1905 td = xmalloc (jmp_byte_count);
1907 memcpy (td, jmp_bytes, jmp_byte_count);
1909 switch (pe_details->pe_arch)
1912 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1915 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1918 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1919 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1920 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1923 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1931 bfd_set_section_size (abfd, id7, 4);
1935 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
1938 bfd_set_section_size (abfd, id5, 4);
1943 if (exp->flag_noname)
1945 d5[0] = exp->ordinal;
1946 d5[1] = exp->ordinal >> 8;
1951 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1955 bfd_set_section_size (abfd, id4, 4);
1960 if (exp->flag_noname)
1962 d4[0] = exp->ordinal;
1963 d4[1] = exp->ordinal >> 8;
1968 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1972 if (exp->flag_noname)
1975 bfd_set_section_size (abfd, id6, 0);
1979 len = strlen (exp->name) + 3;
1982 bfd_set_section_size (abfd, id6, len);
1985 memset (d6, 0, len);
1986 d6[0] = exp->hint & 0xff;
1987 d6[1] = exp->hint >> 8;
1988 strcpy ((char *) d6 + 2, exp->name);
1991 bfd_set_symtab (abfd, symtab, symptr);
1993 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
1994 bfd_set_section_contents (abfd, id7, d7, 0, 4);
1995 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1996 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1997 if (!exp->flag_noname)
1998 bfd_set_section_contents (abfd, id6, d6, 0, len);
2000 bfd_make_readable (abfd);
2005 make_singleton_name_thunk (const char *import, bfd *parent)
2007 /* Name thunks go to idata$4. */
2013 oname = xmalloc (20);
2014 sprintf (oname, "nmth%06d.o", tmp_seq);
2017 abfd = bfd_create (oname, parent);
2018 bfd_find_target (pe_details->object_target, abfd);
2019 bfd_make_writable (abfd);
2021 bfd_set_format (abfd, bfd_object);
2022 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2025 symtab = xmalloc (3 * sizeof (asymbol *));
2026 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2027 quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
2028 quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
2030 bfd_set_section_size (abfd, id4, 8);
2034 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2037 bfd_set_symtab (abfd, symtab, symptr);
2039 bfd_set_section_contents (abfd, id4, d4, 0, 8);
2041 bfd_make_readable (abfd);
2046 make_import_fixup_mark (arelent *rel)
2048 /* We convert reloc to symbol, for later reference. */
2050 static char *fixup_name = NULL;
2051 static size_t buffer_len = 0;
2053 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2055 bfd *abfd = bfd_asymbol_bfd (sym);
2056 struct bfd_link_hash_entry *bh;
2060 fixup_name = xmalloc (384);
2064 if (strlen (sym->name) + 25 > buffer_len)
2065 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2066 bigger than 20 digits long, we've got worse problems than
2067 overflowing this buffer... */
2070 /* New buffer size is length of symbol, plus 25, but
2071 then rounded up to the nearest multiple of 128. */
2072 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2073 fixup_name = xmalloc (buffer_len);
2076 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2079 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2080 current_sec, /* sym->section, */
2081 rel->address, NULL, TRUE, FALSE, &bh);
2085 struct coff_link_hash_entry *myh;
2087 myh = (struct coff_link_hash_entry *) bh;
2088 printf ("type:%d\n", myh->type);
2089 printf ("%s\n", myh->root.u.def.section->name);
2095 /* .section .idata$2
2096 .rva __nm_thnk_SYM (singleton thunk with name of func)
2099 .rva __my_dll_iname (name of dll)
2100 .rva __fuNN_SYM (pointer to reference (address) in text) */
2103 make_import_fixup_entry (const char *name,
2104 const char *fixup_name,
2105 const char *dll_symname,
2113 oname = xmalloc (20);
2114 sprintf (oname, "fu%06d.o", tmp_seq);
2117 abfd = bfd_create (oname, parent);
2118 bfd_find_target (pe_details->object_target, abfd);
2119 bfd_make_writable (abfd);
2121 bfd_set_format (abfd, bfd_object);
2122 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2125 symtab = xmalloc (6 * sizeof (asymbol *));
2126 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2128 quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2129 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2130 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2132 bfd_set_section_size (abfd, id2, 20);
2137 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2138 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2139 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2142 bfd_set_symtab (abfd, symtab, symptr);
2144 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2146 bfd_make_readable (abfd);
2150 /* .section .rdata_runtime_pseudo_reloc
2152 .rva __fuNN_SYM (pointer to reference (address) in text) */
2155 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2156 const char *fixup_name,
2161 unsigned char *rt_rel_d;
2165 oname = xmalloc (20);
2166 sprintf (oname, "rtr%06d.o", tmp_seq);
2169 abfd = bfd_create (oname, parent);
2170 bfd_find_target (pe_details->object_target, abfd);
2171 bfd_make_writable (abfd);
2173 bfd_set_format (abfd, bfd_object);
2174 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2177 symtab = xmalloc (2 * sizeof (asymbol *));
2178 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2179 SEC_HAS_CONTENTS, 2);
2181 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2183 bfd_set_section_size (abfd, rt_rel, 8);
2184 rt_rel_d = xmalloc (8);
2185 rt_rel->contents = rt_rel_d;
2186 memset (rt_rel_d, 0, 8);
2187 bfd_put_32 (abfd, addend, rt_rel_d);
2189 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2190 save_relocs (rt_rel);
2192 bfd_set_symtab (abfd, symtab, symptr);
2194 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2196 bfd_make_readable (abfd);
2201 .rva __pei386_runtime_relocator */
2204 pe_create_runtime_relocator_reference (bfd *parent)
2206 asection *extern_rt_rel;
2207 unsigned char *extern_rt_rel_d;
2211 oname = xmalloc (20);
2212 sprintf (oname, "ertr%06d.o", tmp_seq);
2215 abfd = bfd_create (oname, parent);
2216 bfd_find_target (pe_details->object_target, abfd);
2217 bfd_make_writable (abfd);
2219 bfd_set_format (abfd, bfd_object);
2220 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2223 symtab = xmalloc (2 * sizeof (asymbol *));
2224 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2226 quick_symbol (abfd, "", "__pei386_runtime_relocator", "", UNDSEC,
2229 bfd_set_section_size (abfd, extern_rt_rel, 4);
2230 extern_rt_rel_d = xmalloc (4);
2231 extern_rt_rel->contents = extern_rt_rel_d;
2233 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2234 save_relocs (extern_rt_rel);
2236 bfd_set_symtab (abfd, symtab, symptr);
2238 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
2240 bfd_make_readable (abfd);
2245 pe_create_import_fixup (arelent *rel, asection *s, int addend)
2248 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2249 struct bfd_link_hash_entry *name_thunk_sym;
2250 const char *name = sym->name;
2251 char *fixup_name = make_import_fixup_mark (rel);
2254 sprintf (buf, U ("_nm_thnk_%s"), name);
2256 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2258 if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2260 bfd *b = make_singleton_name_thunk (name, output_bfd);
2261 add_bfd_to_link (b, b->filename, &link_info);
2263 /* If we ever use autoimport, we have to cast text section writable. */
2264 config.text_read_only = FALSE;
2265 output_bfd->flags &= ~WP_TEXT;
2268 if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2270 extern char * pe_data_import_dll;
2271 char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2273 b = make_import_fixup_entry (name, fixup_name, dll_symname, output_bfd);
2274 add_bfd_to_link (b, b->filename, &link_info);
2279 if (link_info.pei386_runtime_pseudo_reloc)
2281 if (pe_dll_extra_pe_debug)
2282 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2283 fixup_name, addend);
2284 b = make_runtime_pseudo_reloc (name, fixup_name, addend, output_bfd);
2285 add_bfd_to_link (b, b->filename, &link_info);
2287 if (runtime_pseudo_relocs_created == 0)
2289 b = pe_create_runtime_relocator_reference (output_bfd);
2290 add_bfd_to_link (b, b->filename, &link_info);
2292 runtime_pseudo_relocs_created++;
2296 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2297 s->owner, s, rel->address, sym->name);
2305 pe_dll_generate_implib (def_file *def, const char *impfilename)
2313 dll_filename = (def->name) ? def->name : dll_name;
2314 dll_symname = xstrdup (dll_filename);
2315 for (i = 0; dll_symname[i]; i++)
2316 if (!ISALNUM (dll_symname[i]))
2317 dll_symname[i] = '_';
2319 unlink_if_ordinary (impfilename);
2321 outarch = bfd_openw (impfilename, 0);
2325 /* xgettext:c-format */
2326 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2330 /* xgettext:c-format */
2331 info_msg (_("Creating library file: %s\n"), impfilename);
2333 bfd_set_format (outarch, bfd_archive);
2334 outarch->has_armap = 1;
2336 /* Work out a reasonable size of things to put onto one line. */
2337 ar_head = make_head (outarch);
2339 for (i = 0; i < def->num_exports; i++)
2341 /* The import library doesn't know about the internal name. */
2342 char *internal = def->exports[i].internal_name;
2345 /* Don't add PRIVATE entries to import lib. */
2346 if (pe_def_file->exports[i].flag_private)
2348 def->exports[i].internal_name = def->exports[i].name;
2349 n = make_one (def->exports + i, outarch);
2352 def->exports[i].internal_name = internal;
2355 ar_tail = make_tail (outarch);
2357 if (ar_head == NULL || ar_tail == NULL)
2360 /* Now stick them all into the archive. */
2361 ar_head->next = head;
2362 ar_tail->next = ar_head;
2365 if (! bfd_set_archive_head (outarch, head))
2366 einfo ("%Xbfd_set_archive_head: %E\n");
2368 if (! bfd_close (outarch))
2369 einfo ("%Xbfd_close %s: %E\n", impfilename);
2371 while (head != NULL)
2373 bfd *n = head->next;
2380 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *link_info)
2382 lang_input_statement_type *fake_file;
2384 fake_file = lang_add_input_file (name,
2385 lang_input_file_is_fake_enum,
2387 fake_file->the_bfd = abfd;
2388 ldlang_add_file (fake_file);
2390 if (!bfd_link_add_symbols (abfd, link_info))
2391 einfo ("%Xaddsym %s: %E\n", name);
2395 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *link_info)
2397 def_file_module *module;
2399 pe_dll_id_target (bfd_get_target (output_bfd));
2404 for (module = pe_def_file->modules; module; module = module->next)
2408 dll_filename = module->name;
2409 dll_symname = xstrdup (module->name);
2410 for (i = 0; dll_symname[i]; i++)
2411 if (!ISALNUM (dll_symname[i]))
2412 dll_symname[i] = '_';
2416 for (i = 0; i < pe_def_file->num_imports; i++)
2417 if (pe_def_file->imports[i].module == module)
2419 def_file_export exp;
2420 struct bfd_link_hash_entry *blhe;
2421 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2422 /* See if we need this import. */
2423 size_t len = strlen (pe_def_file->imports[i].internal_name);
2424 char *name = xmalloc (len + 2 + 6);
2427 sprintf (name, "%s%s", "",
2428 pe_def_file->imports[i].internal_name);
2430 sprintf (name, "%s%s",U (""),
2431 pe_def_file->imports[i].internal_name);
2433 blhe = bfd_link_hash_lookup (link_info->hash, name,
2434 FALSE, FALSE, FALSE);
2436 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2439 sprintf (name, "%s%s", U ("_imp_"),
2440 pe_def_file->imports[i].internal_name);
2442 sprintf (name, "%s%s", U ("_imp__"),
2443 pe_def_file->imports[i].internal_name);
2445 blhe = bfd_link_hash_lookup (link_info->hash, name,
2446 FALSE, FALSE, FALSE);
2450 if (blhe && blhe->type == bfd_link_hash_undefined)
2456 bfd *ar_head = make_head (output_bfd);
2457 add_bfd_to_link (ar_head, ar_head->filename, link_info);
2460 exp.internal_name = pe_def_file->imports[i].internal_name;
2461 exp.name = pe_def_file->imports[i].name;
2462 exp.ordinal = pe_def_file->imports[i].ordinal;
2463 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2464 exp.flag_private = 0;
2465 exp.flag_constant = 0;
2466 exp.flag_data = pe_def_file->imports[i].data;
2467 exp.flag_noname = exp.name ? 0 : 1;
2468 one = make_one (&exp, output_bfd);
2469 add_bfd_to_link (one, one->filename, link_info);
2474 bfd *ar_tail = make_tail (output_bfd);
2475 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2482 /* We were handed a *.DLL file. Parse it and turn it into a set of
2483 IMPORTS directives in the def file. Return TRUE if the file was
2484 handled, FALSE if not. */
2487 pe_get16 (bfd *abfd, int where)
2491 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2492 bfd_bread (b, (bfd_size_type) 2, abfd);
2493 return b[0] + (b[1] << 8);
2497 pe_get32 (bfd *abfd, int where)
2501 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2502 bfd_bread (b, (bfd_size_type) 4, abfd);
2503 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2509 unsigned char *b = ptr;
2511 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2515 pe_implied_import_dll (const char *filename)
2518 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
2519 unsigned long export_rva, export_size, nsections, secptr, expptr;
2520 unsigned long exp_funcbase;
2521 unsigned char *expdata;
2523 unsigned long name_rvas, ordinals, nexp, ordbase;
2524 const char *dll_name;
2525 /* Initialization with start > end guarantees that is_data
2526 will not be set by mistake, and avoids compiler warning. */
2527 unsigned long data_start = 1;
2528 unsigned long data_end = 0;
2529 unsigned long rdata_start = 1;
2530 unsigned long rdata_end = 0;
2531 unsigned long bss_start = 1;
2532 unsigned long bss_end = 0;
2534 /* No, I can't use bfd here. kernel32.dll puts its export table in
2535 the middle of the .rdata section. */
2536 dll = bfd_openr (filename, pe_details->target_name);
2539 einfo ("%Xopen %s: %E\n", filename);
2543 /* PEI dlls seem to be bfd_objects. */
2544 if (!bfd_check_format (dll, bfd_object))
2546 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2550 /* Get pe_header, optional header and numbers of export entries. */
2551 pe_header_offset = pe_get32 (dll, 0x3c);
2552 opthdr_ofs = pe_header_offset + 4 + 20;
2553 num_entries = pe_get32 (dll, opthdr_ofs + 92);
2555 if (num_entries < 1) /* No exports. */
2558 export_rva = pe_get32 (dll, opthdr_ofs + 96);
2559 export_size = pe_get32 (dll, opthdr_ofs + 100);
2560 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2561 secptr = (pe_header_offset + 4 + 20 +
2562 pe_get16 (dll, pe_header_offset + 4 + 16));
2565 /* Get the rva and size of the export section. */
2566 for (i = 0; i < nsections; i++)
2569 unsigned long secptr1 = secptr + 40 * i;
2570 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2571 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
2572 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
2574 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2575 bfd_bread (sname, (bfd_size_type) 8, dll);
2577 if (vaddr <= export_rva && vaddr + vsize > export_rva)
2579 expptr = fptr + (export_rva - vaddr);
2580 if (export_rva + export_size > vaddr + vsize)
2581 export_size = vsize - (export_rva - vaddr);
2586 /* Scan sections and store the base and size of the
2587 data and bss segments in data/base_start/end. */
2588 for (i = 0; i < nsections; i++)
2590 unsigned long secptr1 = secptr + 40 * i;
2591 unsigned long vsize = pe_get32 (dll, secptr1 + 8);
2592 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2593 unsigned long flags = pe_get32 (dll, secptr1 + 36);
2597 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
2598 bfd_bread (sec_name, (bfd_size_type) 8, dll);
2600 if (strcmp(sec_name,".data") == 0)
2603 data_end = vaddr + vsize;
2605 if (pe_dll_extra_pe_debug)
2606 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2607 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2609 else if (strcmp(sec_name,".rdata") == 0)
2611 rdata_start = vaddr;
2612 rdata_end = vaddr + vsize;
2614 if (pe_dll_extra_pe_debug)
2615 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2616 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2618 else if (strcmp (sec_name,".bss") == 0)
2621 bss_end = vaddr + vsize;
2623 if (pe_dll_extra_pe_debug)
2624 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2625 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2629 expdata = xmalloc (export_size);
2630 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2631 bfd_bread (expdata, (bfd_size_type) export_size, dll);
2632 erva = (char *) expdata - export_rva;
2634 if (pe_def_file == 0)
2635 pe_def_file = def_file_empty ();
2637 nexp = pe_as32 (expdata + 24);
2638 name_rvas = pe_as32 (expdata + 32);
2639 ordinals = pe_as32 (expdata + 36);
2640 ordbase = pe_as32 (expdata + 16);
2641 exp_funcbase = pe_as32 (expdata + 28);
2643 /* Use internal dll name instead of filename
2644 to enable symbolic dll linking. */
2645 dll_name = erva + pe_as32 (expdata + 12);
2647 /* Check to see if the dll has already been added to
2648 the definition list and if so return without error.
2649 This avoids multiple symbol definitions. */
2650 if (def_get_module (pe_def_file, dll_name))
2652 if (pe_dll_extra_pe_debug)
2653 printf ("%s is already loaded\n", dll_name);
2657 /* Iterate through the list of symbols. */
2658 for (i = 0; i < nexp; i++)
2660 /* Pointer to the names vector. */
2661 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
2662 def_file_import *imp;
2663 /* Pointer to the function address vector. */
2664 unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
2667 /* Skip unwanted symbols, which are
2668 exported in buggy auto-import releases. */
2669 if (strncmp (erva + name_rva, "_nm_", 4) != 0)
2671 /* is_data is true if the address is in the data, rdata or bss
2674 (func_rva >= data_start && func_rva < data_end)
2675 || (func_rva >= rdata_start && func_rva < rdata_end)
2676 || (func_rva >= bss_start && func_rva < bss_end);
2678 imp = def_file_add_import (pe_def_file, erva + name_rva,
2680 /* Mark symbol type. */
2681 imp->data = is_data;
2683 if (pe_dll_extra_pe_debug)
2684 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2685 __FUNCTION__, dll_name, erva + name_rva,
2686 func_rva, is_data ? "(data)" : "");
2693 /* These are the main functions, called from the emulation. The first
2694 is called after the bfds are read, so we can guess at how much space
2695 we need. The second is called after everything is placed, so we
2696 can put the right values in place. */
2699 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
2701 pe_dll_id_target (bfd_get_target (abfd));
2702 process_def_file (abfd, info);
2704 if (pe_def_file->num_exports == 0 && !info->shared)
2707 generate_edata (abfd, info);
2708 build_filler_bfd (1);
2712 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2714 pe_dll_id_target (bfd_get_target (abfd));
2715 build_filler_bfd (0);
2719 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
2721 pe_dll_id_target (bfd_get_target (abfd));
2722 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2724 generate_reloc (abfd, info);
2727 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2729 /* Resize the sections. */
2730 lang_reset_memory_regions ();
2731 lang_size_sections (NULL, TRUE);
2733 /* Redo special stuff. */
2734 ldemul_after_allocation ();
2736 /* Do the assignments again. */
2737 lang_do_assignments ();
2740 fill_edata (abfd, info);
2742 if (info->shared && !info->pie)
2743 pe_data (abfd)->dll = 1;
2745 edata_s->contents = edata_d;
2746 reloc_s->contents = reloc_d;
2750 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
2752 pe_dll_id_target (bfd_get_target (abfd));
2753 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2755 generate_reloc (abfd, info);
2758 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2760 /* Resize the sections. */
2761 lang_reset_memory_regions ();
2762 lang_size_sections (NULL, TRUE);
2764 /* Redo special stuff. */
2765 ldemul_after_allocation ();
2767 /* Do the assignments again. */
2768 lang_do_assignments ();
2770 reloc_s->contents = reloc_d;