1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3 Written by DJ Delorie <dj@cygnus.com>
5 This file is part of GLD, the Gnu Linker.
7 GLD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GLD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GLD; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
39 #include "coff/internal.h"
40 #include "../bfd/libcoff.h"
44 /* This file turns a regular Windows PE image into a DLL. Because of
45 the complexity of this operation, it has been broken down into a
46 number of separate modules which are all called by the main function
47 at the end of this file. This function is not re-entrant and is
48 normally only called once, so static variables are used to reduce
49 the number of parameters and return values required.
51 See also: ld/emultempl/pe.em. */
53 /* Auto-import feature by Paul Sokolovsky
57 1. With this feature on, DLL clients can import variables from DLL
58 without any concern from their side (for example, without any source
61 2. This is done completely in bounds of the PE specification (to be fair,
62 there's a place where it pokes nose out of, but in practice it works).
63 So, resulting module can be used with any other PE compiler/linker.
65 3. Auto-import is fully compatible with standard import method and they
66 can be mixed together.
68 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
69 reference to it; load time: negligible; virtual/physical memory: should be
70 less than effect of DLL relocation, and I sincerely hope it doesn't affect
71 DLL sharability (too much).
75 The obvious and only way to get rid of dllimport insanity is to make client
76 access variable directly in the DLL, bypassing extra dereference. I.e.,
77 whenever client contains something like
81 address of dll_var in the command should be relocated to point into loaded
82 DLL. The aim is to make OS loader do so, and than make ld help with that.
83 Import section of PE made following way: there's a vector of structures
84 each describing imports from particular DLL. Each such structure points
85 to two other parallel vectors: one holding imported names, and one which
86 will hold address of corresponding imported name. So, the solution is
87 de-vectorize these structures, making import locations be sparse and
88 pointing directly into code. Before continuing, it is worth a note that,
89 while authors strives to make PE act ELF-like, there're some other people
90 make ELF act PE-like: elfvector, ;-) .
94 For each reference of data symbol to be imported from DLL (to set of which
95 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
96 import fixup entry is generated. That entry is of type
97 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$3 subsection. Each
98 fixup entry contains pointer to symbol's address within .text section
99 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
100 (so, DLL name is referenced by multiple entries), and pointer to symbol
101 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
102 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
103 containing imported name. Here comes that "om the edge" problem mentioned
104 above: PE specification rambles that name vector (OriginalFirstThunk)
105 should run in parallel with addresses vector (FirstThunk), i.e. that they
106 should have same number of elements and terminated with zero. We violate
107 this, since FirstThunk points directly into machine code. But in practice,
108 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
109 puts addresses to FirstThunk, not something else. It once again should be
110 noted that dll and symbol name structures are reused across fixup entries
111 and should be there anyway to support standard import stuff, so sustained
112 overhead is 20 bytes per reference. Other question is whether having several
113 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
114 done even by native compiler/linker (libth32's functions are in fact reside
115 in windows9x kernel32.dll, so if you use it, you have two
116 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
117 referencing the same PE structures several times is valid. The answer is why
118 not, prohibiting that (detecting violation) would require more work on
119 behalf of loader than not doing it.
121 See also: ld/emultempl/pe.em. */
123 static void add_bfd_to_link (bfd *, const char *, struct bfd_link_info *);
125 /* For emultempl/pe.em. */
127 def_file * pe_def_file = 0;
128 int pe_dll_export_everything = 0;
129 int pe_dll_do_default_excludes = 1;
130 int pe_dll_kill_ats = 0;
131 int pe_dll_stdcall_aliases = 0;
132 int pe_dll_warn_dup_exports = 0;
133 int pe_dll_compat_implib = 0;
134 int pe_dll_extra_pe_debug = 0;
136 /* Static variables and types. */
138 static bfd_vma image_base;
139 static bfd *filler_bfd;
140 static struct bfd_section *edata_s, *reloc_s;
141 static unsigned char *edata_d, *reloc_d;
142 static size_t edata_sz, reloc_sz;
143 static int runtime_pseudo_relocs_created = 0;
149 unsigned int imagebase_reloc;
161 autofilter_entry_type;
163 #define PE_ARCH_i386 1
165 #define PE_ARCH_mips 3
166 #define PE_ARCH_arm 4
167 #define PE_ARCH_arm_epoc 5
169 static pe_details_type pe_detail_list[] =
182 16 /* R_SH_IMAGEBASE */,
204 "epoc-pei-arm-little",
205 "epoc-pe-arm-little",
211 { NULL, NULL, 0, 0, 0, 0 }
214 static pe_details_type *pe_details;
216 static autofilter_entry_type autofilter_symbollist[] =
218 { "DllMain@12", 10 },
219 { "DllEntryPoint@0", 15 },
220 { "DllMainCRTStartup@12", 20 },
221 { "_cygwin_dll_entry@12", 20 },
222 { "_cygwin_crt0_common@8", 21 },
223 { "_cygwin_noncygwin_dll_entry@12", 30 },
224 { "impure_ptr", 10 },
225 { "_pei386_runtime_relocator", 25 },
226 { "do_pseudo_reloc", 15 },
227 { "cygwin_crt0", 11 },
231 /* Do not specify library suffix explicitly, to allow for dllized versions. */
232 static autofilter_entry_type autofilter_liblist[] =
237 { "libmingw32", 10 },
238 { "libmingwex", 10 },
246 static autofilter_entry_type autofilter_objlist[] =
256 { "crtbegin.o", 10 },
261 static autofilter_entry_type autofilter_symbolprefixlist[] =
263 /* { "__imp_", 6 }, */
264 /* Do __imp_ explicitly to save time. */
266 /* Don't re-export auto-imported symbols. */
268 { "__builtin_", 10 },
269 /* Don't export symbols specifying internal DLL layout. */
272 { "_impure_ptr", 11 },
273 { "cygwin_attach_dll", 17 },
274 { "cygwin_premain0", 15 },
275 { "cygwin_premain1", 15 },
276 { "cygwin_premain2", 15 },
277 { "cygwin_premain3", 15 },
282 static autofilter_entry_type autofilter_symbolsuffixlist[] =
288 #define U(str) (pe_details->underscored ? "_" str : str)
291 pe_dll_id_target (const char *target)
295 for (i = 0; pe_detail_list[i].target_name; i++)
296 if (strcmp (pe_detail_list[i].target_name, target) == 0
297 || strcmp (pe_detail_list[i].object_target, target) == 0)
299 pe_details = pe_detail_list + i;
302 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
306 /* Helper functions for qsort. Relocs must be sorted so that we can write
307 them out by pages. */
318 reloc_sort (const void *va, const void *vb)
320 bfd_vma a = ((const reloc_data_type *) va)->vma;
321 bfd_vma b = ((const reloc_data_type *) vb)->vma;
323 return (a > b) ? 1 : ((a < b) ? -1 : 0);
327 pe_export_sort (const void *va, const void *vb)
329 const def_file_export *a = va;
330 const def_file_export *b = vb;
332 return strcmp (a->name, b->name);
335 /* Read and process the .DEF file. */
337 /* These correspond to the entries in pe_def_file->exports[]. I use
338 exported_symbol_sections[i] to tag whether or not the symbol was
339 defined, since we can't export symbols we don't have. */
341 static bfd_vma *exported_symbol_offsets;
342 static struct bfd_section **exported_symbol_sections;
343 static int export_table_size;
344 static int count_exported;
345 static int count_exported_byname;
346 static int count_with_ordinals;
347 static const char *dll_name;
348 static int min_ordinal, max_ordinal;
349 static int *exported_symbols;
351 typedef struct exclude_list_struct
354 struct exclude_list_struct *next;
359 static struct exclude_list_struct *excludes = 0;
362 pe_dll_add_excludes (const char *new_excludes, const int type)
365 char *exclude_string;
367 local_copy = xstrdup (new_excludes);
369 exclude_string = strtok (local_copy, ",:");
370 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
372 struct exclude_list_struct *new_exclude;
374 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
375 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
376 strcpy (new_exclude->string, exclude_string);
377 new_exclude->type = type;
378 new_exclude->next = excludes;
379 excludes = new_exclude;
386 /* abfd is a bfd containing n (or NULL)
387 It can be used for contextual checks. */
390 auto_export (bfd *abfd, def_file *d, const char *n)
393 struct exclude_list_struct *ex;
394 autofilter_entry_type *afptr;
395 const char * libname = 0;
396 if (abfd && abfd->my_archive)
397 libname = lbasename (abfd->my_archive->filename);
399 /* We should not re-export imported stuff. */
400 if (strncmp (n, "_imp__", 6) == 0)
403 for (i = 0; i < d->num_exports; i++)
404 if (strcmp (d->exports[i].name, n) == 0)
407 if (pe_dll_do_default_excludes)
412 if (pe_dll_extra_pe_debug)
413 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
414 n, abfd, abfd->my_archive);
416 /* First of all, make context checks:
417 Don't export anything from standard libs. */
420 afptr = autofilter_liblist;
424 if (strncmp (libname, afptr->name, afptr->len) == 0 )
430 /* Next, exclude symbols from certain startup objects. */
432 if (abfd && (p = lbasename (abfd->filename)))
434 afptr = autofilter_objlist;
437 if (strcmp (p, afptr->name) == 0)
443 /* Don't try to blindly exclude all symbols
444 that begin with '__'; this was tried and
445 it is too restrictive. */
447 /* Then, exclude specific symbols. */
448 afptr = autofilter_symbollist;
451 if (strcmp (n, afptr->name) == 0)
457 /* Next, exclude symbols starting with ... */
458 afptr = autofilter_symbolprefixlist;
461 if (strncmp (n, afptr->name, afptr->len) == 0)
467 /* Finally, exclude symbols ending with ... */
469 afptr = autofilter_symbolsuffixlist;
472 if ((len >= afptr->len)
473 /* Add 1 to insure match with trailing '\0'. */
474 && strncmp (n + len - afptr->len, afptr->name,
475 afptr->len + 1) == 0)
482 for (ex = excludes; ex; ex = ex->next)
484 if (ex->type == 1) /* exclude-libs */
487 && ((strcmp (libname, ex->string) == 0)
488 || (strcasecmp ("ALL", ex->string) == 0)))
491 else if (strcmp (n, ex->string) == 0)
499 process_def_file (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
502 struct bfd_link_hash_entry *blhe;
504 struct bfd_section *s;
505 def_file_export *e = 0;
508 pe_def_file = def_file_empty ();
510 /* First, run around to all the objects looking for the .drectve
511 sections, and push those into the def file too. */
512 for (b = info->input_bfds; b; b = b->link_next)
514 s = bfd_get_section_by_name (b, ".drectve");
517 int size = bfd_get_section_size_before_reloc (s);
518 char *buf = xmalloc (size);
520 bfd_get_section_contents (b, s, buf, 0, size);
521 def_file_add_directive (pe_def_file, buf, size);
526 /* If we are not building a DLL, when there are no exports
527 we do not build an export table at all. */
528 if (!pe_dll_export_everything && pe_def_file->num_exports == 0
532 /* Now, maybe export everything else the default way. */
533 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
535 for (b = info->input_bfds; b; b = b->link_next)
540 symsize = bfd_get_symtab_upper_bound (b);
541 symbols = xmalloc (symsize);
542 nsyms = bfd_canonicalize_symtab (b, symbols);
544 for (j = 0; j < nsyms; j++)
546 /* We should export symbols which are either global or not
547 anything at all. (.bss data is the latter)
548 We should not export undefined symbols. */
549 if (symbols[j]->section != &bfd_und_section
550 && ((symbols[j]->flags & BSF_GLOBAL)
551 || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
553 const char *sn = symbols[j]->name;
555 /* We should not re-export imported stuff. */
557 char *name = xmalloc (strlen (sn) + 2 + 6);
558 sprintf (name, "%s%s", U("_imp_"), sn);
560 blhe = bfd_link_hash_lookup (info->hash, name,
561 FALSE, FALSE, FALSE);
564 if (blhe && blhe->type == bfd_link_hash_defined)
571 if (auto_export (b, pe_def_file, sn))
574 p=def_file_add_export (pe_def_file, sn, 0, -1);
575 /* Fill data flag properly, from dlltool.c. */
576 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
584 #define NE pe_def_file->num_exports
586 /* Canonicalize the export list. */
589 for (i = 0; i < NE; i++)
591 if (strchr (pe_def_file->exports[i].name, '@'))
593 /* This will preserve internal_name, which may have been
594 pointing to the same memory as name, or might not
596 int lead_at = (*pe_def_file->exports[i].name == '@');
597 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
599 *(strchr (tmp, '@')) = 0;
600 pe_def_file->exports[i].name = tmp;
605 if (pe_dll_stdcall_aliases)
607 for (i = 0; i < NE; i++)
609 if (strchr (pe_def_file->exports[i].name, '@'))
611 int lead_at = (*pe_def_file->exports[i].name == '@');
612 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
614 *(strchr (tmp, '@')) = 0;
615 if (auto_export (NULL, pe_def_file, tmp))
616 def_file_add_export (pe_def_file, tmp,
617 pe_def_file->exports[i].internal_name,
625 /* Convenience, but watch out for it changing. */
626 e = pe_def_file->exports;
628 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
629 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
631 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
635 count_exported_byname = 0;
636 count_with_ordinals = 0;
638 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
640 for (i = 0, j = 0; i < NE; i++)
642 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
644 /* This is a duplicate. */
645 if (e[j - 1].ordinal != -1
646 && e[i].ordinal != -1
647 && e[j - 1].ordinal != e[i].ordinal)
649 if (pe_dll_warn_dup_exports)
650 /* xgettext:c-format */
651 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
652 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
656 if (pe_dll_warn_dup_exports)
657 /* xgettext:c-format */
658 einfo (_("Warning, duplicate EXPORT: %s\n"),
662 if (e[i].ordinal != -1)
663 e[j - 1].ordinal = e[i].ordinal;
664 e[j - 1].flag_private |= e[i].flag_private;
665 e[j - 1].flag_constant |= e[i].flag_constant;
666 e[j - 1].flag_noname |= e[i].flag_noname;
667 e[j - 1].flag_data |= e[i].flag_data;
676 pe_def_file->num_exports = j; /* == NE */
678 for (i = 0; i < NE; i++)
682 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
683 if (pe_details->underscored
684 && (*pe_def_file->exports[i].internal_name != '@'))
687 strcpy (name + 1, pe_def_file->exports[i].internal_name);
690 strcpy (name, pe_def_file->exports[i].internal_name);
692 blhe = bfd_link_hash_lookup (info->hash,
697 && (blhe->type == bfd_link_hash_defined
698 || (blhe->type == bfd_link_hash_common)))
701 if (!pe_def_file->exports[i].flag_noname)
702 count_exported_byname++;
704 /* Only fill in the sections. The actual offsets are computed
705 in fill_exported_offsets() after common symbols are laid
707 if (blhe->type == bfd_link_hash_defined)
708 exported_symbol_sections[i] = blhe->u.def.section;
710 exported_symbol_sections[i] = blhe->u.c.p->section;
712 if (pe_def_file->exports[i].ordinal != -1)
714 if (max_ordinal < pe_def_file->exports[i].ordinal)
715 max_ordinal = pe_def_file->exports[i].ordinal;
716 if (min_ordinal > pe_def_file->exports[i].ordinal)
717 min_ordinal = pe_def_file->exports[i].ordinal;
718 count_with_ordinals++;
721 else if (blhe && blhe->type == bfd_link_hash_undefined)
723 /* xgettext:c-format */
724 einfo (_("%XCannot export %s: symbol not defined\n"),
725 pe_def_file->exports[i].internal_name);
729 /* xgettext:c-format */
730 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
731 pe_def_file->exports[i].internal_name,
732 blhe->type, bfd_link_hash_defined);
736 /* xgettext:c-format */
737 einfo (_("%XCannot export %s: symbol not found\n"),
738 pe_def_file->exports[i].internal_name);
744 /* Build the bfd that will contain .edata and .reloc sections. */
747 build_filler_bfd (int include_edata)
749 lang_input_statement_type *filler_file;
750 filler_file = lang_add_input_file ("dll stuff",
751 lang_input_file_is_fake_enum,
753 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
754 if (filler_bfd == NULL
755 || !bfd_set_arch_mach (filler_bfd,
756 bfd_get_arch (output_bfd),
757 bfd_get_mach (output_bfd)))
759 einfo ("%X%P: can not create BFD %E\n");
765 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
767 || !bfd_set_section_flags (filler_bfd, edata_s,
774 einfo ("%X%P: can not create .edata section: %E\n");
777 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
780 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
782 || !bfd_set_section_flags (filler_bfd, reloc_s,
789 einfo ("%X%P: can not create .reloc section: %E\n");
793 bfd_set_section_size (filler_bfd, reloc_s, 0);
795 ldlang_add_file (filler_file);
798 /* Gather all the exported symbols and build the .edata section. */
801 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
804 int name_table_size = 0;
807 /* First, we need to know how many exported symbols there are,
808 and what the range of ordinals is. */
809 if (pe_def_file->name)
810 dll_name = pe_def_file->name;
813 dll_name = abfd->filename;
815 for (dlnp = dll_name; *dlnp; dlnp++)
816 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
820 if (count_with_ordinals && max_ordinal > count_exported)
822 if (min_ordinal > max_ordinal - count_exported + 1)
823 min_ordinal = max_ordinal - count_exported + 1;
828 max_ordinal = count_exported;
831 export_table_size = max_ordinal - min_ordinal + 1;
832 exported_symbols = xmalloc (export_table_size * sizeof (int));
833 for (i = 0; i < export_table_size; i++)
834 exported_symbols[i] = -1;
836 /* Now we need to assign ordinals to those that don't have them. */
837 for (i = 0; i < NE; i++)
839 if (exported_symbol_sections[i])
841 if (pe_def_file->exports[i].ordinal != -1)
843 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
844 int pi = exported_symbols[ei];
848 /* xgettext:c-format */
849 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
850 pe_def_file->exports[i].ordinal,
851 pe_def_file->exports[i].name,
852 pe_def_file->exports[pi].name);
854 exported_symbols[ei] = i;
856 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
860 next_ordinal = min_ordinal;
861 for (i = 0; i < NE; i++)
862 if (exported_symbol_sections[i])
863 if (pe_def_file->exports[i].ordinal == -1)
865 while (exported_symbols[next_ordinal - min_ordinal] != -1)
868 exported_symbols[next_ordinal - min_ordinal] = i;
869 pe_def_file->exports[i].ordinal = next_ordinal;
872 /* OK, now we can allocate some memory. */
873 edata_sz = (40 /* directory */
874 + 4 * export_table_size /* addresses */
875 + 4 * count_exported_byname /* name ptrs */
876 + 2 * count_exported_byname /* ordinals */
877 + name_table_size + strlen (dll_name) + 1);
880 /* Fill the exported symbol offsets. The preliminary work has already
881 been done in process_def_file(). */
884 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
887 struct bfd_link_hash_entry *blhe;
889 for (i = 0; i < pe_def_file->num_exports; i++)
893 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
894 if (pe_details->underscored
895 && *pe_def_file->exports[i].internal_name != '@')
898 strcpy (name + 1, pe_def_file->exports[i].internal_name);
901 strcpy (name, pe_def_file->exports[i].internal_name);
903 blhe = bfd_link_hash_lookup (info->hash,
907 if (blhe && blhe->type == bfd_link_hash_defined)
908 exported_symbol_offsets[i] = blhe->u.def.value;
915 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
918 unsigned char *edirectory;
919 unsigned long *eaddresses;
920 unsigned long *enameptrs;
921 unsigned short *eordinals;
922 unsigned char *enamestr;
927 edata_d = xmalloc (edata_sz);
929 /* Note use of array pointer math here. */
930 edirectory = edata_d;
931 eaddresses = (unsigned long *) (edata_d + 40);
932 enameptrs = eaddresses + export_table_size;
933 eordinals = (unsigned short *) (enameptrs + count_exported_byname);
934 enamestr = (char *) (eordinals + count_exported_byname);
936 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
937 + edata_s->output_section->vma - image_base)
939 memset (edata_d, 0, edata_sz);
940 bfd_put_32 (abfd, now, edata_d + 4);
941 if (pe_def_file->version_major != -1)
943 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
944 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
947 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
948 strcpy (enamestr, dll_name);
949 enamestr += strlen (enamestr) + 1;
950 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
951 bfd_put_32 (abfd, export_table_size, edata_d + 20);
952 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
953 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
954 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
955 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
957 fill_exported_offsets (abfd, info);
959 /* Ok, now for the filling in part.
960 Scan alphabetically - ie the ordering in the exports[] table,
961 rather than by ordinal - the ordering in the exported_symbol[]
962 table. See dlltool.c and:
963 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
964 for more information. */
966 for (s = 0; s < NE; s++)
968 if (pe_def_file->exports[s].ordinal != -1)
970 struct bfd_section *ssec = exported_symbol_sections[s];
971 unsigned long srva = (exported_symbol_offsets[s]
972 + ssec->output_section->vma
973 + ssec->output_offset);
974 int ord = pe_def_file->exports[s].ordinal;
976 bfd_put_32 (abfd, srva - image_base,
977 (void *) (eaddresses + ord - min_ordinal));
979 if (!pe_def_file->exports[s].flag_noname)
981 char *ename = pe_def_file->exports[s].name;
983 bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs);
985 strcpy (enamestr, ename);
986 enamestr += strlen (enamestr) + 1;
987 bfd_put_16 (abfd, ord - min_ordinal, (void *) eordinals);
989 pe_def_file->exports[s].hint = hint++;
996 static struct bfd_section *current_sec;
999 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1001 int (*cb) (arelent *, asection *))
1006 for (b = info->input_bfds; b; b = b->link_next)
1011 symsize = bfd_get_symtab_upper_bound (b);
1012 symbols = xmalloc (symsize);
1013 nsyms = bfd_canonicalize_symtab (b, symbols);
1015 for (s = b->sections; s; s = s->next)
1018 int relsize, nrelocs, i;
1019 int flags = bfd_get_section_flags (b, s);
1021 /* Skip discarded linkonce sections. */
1022 if (flags & SEC_LINK_ONCE
1023 && s->output_section == bfd_abs_section_ptr)
1028 relsize = bfd_get_reloc_upper_bound (b, s);
1029 relocs = xmalloc (relsize);
1030 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1032 for (i = 0; i < nrelocs; i++)
1034 struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1036 if (!strcmp (name, sym->name))
1042 /* Warning: the allocated symbols are remembered in BFD and reused
1043 later, so don't free them! */
1044 /* free (symbols); */
1049 /* Gather all the relocations and build the .reloc section. */
1052 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1055 /* For .reloc stuff. */
1056 reloc_data_type *reloc_data;
1057 int total_relocs = 0;
1059 unsigned long sec_page = (unsigned long) -1;
1060 unsigned long page_ptr, page_count;
1063 struct bfd_section *s;
1066 for (b = info->input_bfds; b; b = b->link_next)
1067 for (s = b->sections; s; s = s->next)
1068 total_relocs += s->reloc_count;
1070 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1074 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1077 int relsize, nrelocs, i;
1079 for (s = b->sections; s; s = s->next)
1081 unsigned long sec_vma = s->output_section->vma + s->output_offset;
1085 /* If it's not loaded, we don't need to relocate it this way. */
1086 if (!(s->output_section->flags & SEC_LOAD))
1089 /* I don't know why there would be a reloc for these, but I've
1090 seen it happen - DJ */
1091 if (s->output_section == &bfd_abs_section)
1094 if (s->output_section->vma == 0)
1096 /* Huh? Shouldn't happen, but punt if it does. */
1097 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1098 s->output_section->name, s->output_section->index,
1099 s->output_section->flags);
1103 symsize = bfd_get_symtab_upper_bound (b);
1104 symbols = xmalloc (symsize);
1105 nsyms = bfd_canonicalize_symtab (b, symbols);
1107 relsize = bfd_get_reloc_upper_bound (b, s);
1108 relocs = xmalloc (relsize);
1109 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1111 for (i = 0; i < nrelocs; i++)
1113 if (pe_dll_extra_pe_debug)
1115 struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1116 printf ("rel: %s\n", sym->name);
1118 if (!relocs[i]->howto->pc_relative
1119 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1122 struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1124 sym_vma = (relocs[i]->addend
1127 + sym->section->output_offset
1128 + sym->section->output_section->vma);
1129 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1131 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1133 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1134 relocs[i]->howto->rightshift)
1136 case BITS_AND_SHIFT (32, 0):
1137 reloc_data[total_relocs].type = 3;
1140 case BITS_AND_SHIFT (16, 0):
1141 reloc_data[total_relocs].type = 2;
1144 case BITS_AND_SHIFT (16, 16):
1145 reloc_data[total_relocs].type = 4;
1146 /* FIXME: we can't know the symbol's right value
1147 yet, but we probably can safely assume that
1148 CE will relocate us in 64k blocks, so leaving
1150 reloc_data[total_relocs].extra = 0;
1153 case BITS_AND_SHIFT (26, 2):
1154 reloc_data[total_relocs].type = 5;
1157 case BITS_AND_SHIFT (24, 2):
1158 if (relocs[i]->howto->type == 5)
1159 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1160 that has already been fully processed during a
1161 previous link stage, so ignore it here. */
1165 /* xgettext:c-format */
1166 einfo (_("%XError: %d-bit reloc in dll\n"),
1167 relocs[i]->howto->bitsize);
1173 /* Warning: the allocated symbols are remembered in BFD and
1174 reused later, so don't free them! */
1181 /* At this point, we have total_relocs relocation addresses in
1182 reloc_addresses, which are all suitable for the .reloc section.
1183 We must now create the new sections. */
1184 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1186 for (i = 0; i < total_relocs; i++)
1188 unsigned long this_page = (reloc_data[i].vma >> 12);
1190 if (this_page != sec_page)
1192 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1194 sec_page = this_page;
1199 if (reloc_data[i].type == 4)
1203 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1204 reloc_d = xmalloc (reloc_sz);
1205 sec_page = (unsigned long) -1;
1207 page_ptr = (unsigned long) -1;
1210 for (i = 0; i < total_relocs; i++)
1212 unsigned long rva = reloc_data[i].vma - image_base;
1213 unsigned long this_page = (rva & ~0xfff);
1215 if (this_page != sec_page)
1217 while (reloc_sz & 3)
1218 reloc_d[reloc_sz++] = 0;
1220 if (page_ptr != (unsigned long) -1)
1221 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1223 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1224 page_ptr = reloc_sz;
1226 sec_page = this_page;
1230 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1231 reloc_d + reloc_sz);
1234 if (reloc_data[i].type == 4)
1236 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1243 while (reloc_sz & 3)
1244 reloc_d[reloc_sz++] = 0;
1246 if (page_ptr != (unsigned long) -1)
1247 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1249 while (reloc_sz < reloc_s->_raw_size)
1250 reloc_d[reloc_sz++] = 0;
1253 /* Given the exiting def_file structure, print out a .DEF file that
1254 corresponds to it. */
1257 quoteput (char *s, FILE *f, int needs_quotes)
1261 for (cp = s; *cp; cp++)
1276 if (*s == '"' || *s == '\\')
1290 pe_dll_generate_def_file (const char *pe_out_def_filename)
1293 FILE *out = fopen (pe_out_def_filename, "w");
1296 /* xgettext:c-format */
1297 einfo (_("%s: Can't open output def file %s\n"),
1298 program_name, pe_out_def_filename);
1302 if (pe_def_file->name)
1304 if (pe_def_file->is_dll)
1305 fprintf (out, "LIBRARY ");
1307 fprintf (out, "NAME ");
1309 quoteput (pe_def_file->name, out, 1);
1311 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
1312 fprintf (out, " BASE=0x%lx",
1313 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
1314 fprintf (out, "\n");
1317 if (pe_def_file->description)
1319 fprintf (out, "DESCRIPTION ");
1320 quoteput (pe_def_file->description, out, 1);
1321 fprintf (out, "\n");
1324 if (pe_def_file->version_minor != -1)
1325 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1326 pe_def_file->version_minor);
1327 else if (pe_def_file->version_major != -1)
1328 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1330 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1331 fprintf (out, "\n");
1333 if (pe_def_file->stack_commit != -1)
1334 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1335 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1336 else if (pe_def_file->stack_reserve != -1)
1337 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1339 if (pe_def_file->heap_commit != -1)
1340 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1341 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1342 else if (pe_def_file->heap_reserve != -1)
1343 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1345 if (pe_def_file->num_section_defs > 0)
1347 fprintf (out, "\nSECTIONS\n\n");
1349 for (i = 0; i < pe_def_file->num_section_defs; i++)
1352 quoteput (pe_def_file->section_defs[i].name, out, 0);
1354 if (pe_def_file->section_defs[i].class)
1356 fprintf (out, " CLASS ");
1357 quoteput (pe_def_file->section_defs[i].class, out, 0);
1360 if (pe_def_file->section_defs[i].flag_read)
1361 fprintf (out, " READ");
1363 if (pe_def_file->section_defs[i].flag_write)
1364 fprintf (out, " WRITE");
1366 if (pe_def_file->section_defs[i].flag_execute)
1367 fprintf (out, " EXECUTE");
1369 if (pe_def_file->section_defs[i].flag_shared)
1370 fprintf (out, " SHARED");
1372 fprintf (out, "\n");
1376 if (pe_def_file->num_exports > 0)
1378 fprintf (out, "EXPORTS\n");
1380 for (i = 0; i < pe_def_file->num_exports; i++)
1382 def_file_export *e = pe_def_file->exports + i;
1384 quoteput (e->name, out, 0);
1386 if (e->internal_name && strcmp (e->internal_name, e->name))
1388 fprintf (out, " = ");
1389 quoteput (e->internal_name, out, 0);
1392 if (e->ordinal != -1)
1393 fprintf (out, " @%d", e->ordinal);
1395 if (e->flag_private)
1396 fprintf (out, " PRIVATE");
1398 if (e->flag_constant)
1399 fprintf (out, " CONSTANT");
1402 fprintf (out, " NONAME");
1405 fprintf (out, " DATA");
1407 fprintf (out, "\n");
1411 if (pe_def_file->num_imports > 0)
1413 fprintf (out, "\nIMPORTS\n\n");
1415 for (i = 0; i < pe_def_file->num_imports; i++)
1417 def_file_import *im = pe_def_file->imports + i;
1420 if (im->internal_name
1421 && (!im->name || strcmp (im->internal_name, im->name)))
1423 quoteput (im->internal_name, out, 0);
1424 fprintf (out, " = ");
1427 quoteput (im->module->name, out, 0);
1431 quoteput (im->name, out, 0);
1433 fprintf (out, "%d", im->ordinal);
1435 fprintf (out, "\n");
1440 fprintf (out, _("; no contents available\n"));
1442 if (fclose (out) == EOF)
1443 /* xgettext:c-format */
1444 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1447 /* Generate the import library. */
1449 static asymbol **symtab;
1452 static const char *dll_filename;
1453 static char *dll_symname;
1455 #define UNDSEC (asection *) &bfd_und_section
1458 quick_section (bfd *abfd, const char *name, int flags, int align)
1463 sec = bfd_make_section_old_way (abfd, name);
1464 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1465 bfd_set_section_alignment (abfd, sec, align);
1466 /* Remember to undo this before trying to link internally! */
1467 sec->output_section = sec;
1469 sym = bfd_make_empty_symbol (abfd);
1470 symtab[symptr++] = sym;
1471 sym->name = sec->name;
1473 sym->flags = BSF_LOCAL;
1480 quick_symbol (bfd *abfd,
1489 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1494 sym = bfd_make_empty_symbol (abfd);
1499 symtab[symptr++] = sym;
1502 static arelent *reltab = 0;
1503 static int relcount = 0, relsize = 0;
1506 quick_reloc (bfd *abfd, int address, int which_howto, int symidx)
1508 if (relcount >= relsize - 1)
1512 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1514 reltab = xmalloc (relsize * sizeof (arelent));
1516 reltab[relcount].address = address;
1517 reltab[relcount].addend = 0;
1518 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1519 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1524 save_relocs (asection *sec)
1528 sec->relocation = reltab;
1529 sec->reloc_count = relcount;
1530 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1531 for (i = 0; i < relcount; i++)
1532 sec->orelocation[i] = sec->relocation + i;
1533 sec->orelocation[relcount] = 0;
1534 sec->flags |= SEC_RELOC;
1536 relcount = relsize = 0;
1539 /* .section .idata$2
1540 .global __head_my_dll
1557 make_head (bfd *parent)
1559 asection *id2, *id5, *id4;
1560 unsigned char *d2, *d5, *d4;
1564 oname = xmalloc (20);
1565 sprintf (oname, "d%06d.o", tmp_seq);
1568 abfd = bfd_create (oname, parent);
1569 bfd_find_target (pe_details->object_target, abfd);
1570 bfd_make_writable (abfd);
1572 bfd_set_format (abfd, bfd_object);
1573 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1576 symtab = xmalloc (6 * sizeof (asymbol *));
1577 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1578 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1579 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1580 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1581 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1583 /* OK, pay attention here. I got confused myself looking back at
1584 it. We create a four-byte section to mark the beginning of the
1585 list, and we include an offset of 4 in the section, so that the
1586 pointer to the list points to the *end* of this section, which is
1587 the start of the list of sections from other objects. */
1589 bfd_set_section_size (abfd, id2, 20);
1593 d2[0] = d2[16] = 4; /* Reloc addend. */
1594 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1595 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1596 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1599 bfd_set_section_size (abfd, id5, 4);
1604 bfd_set_section_size (abfd, id4, 4);
1609 bfd_set_symtab (abfd, symtab, symptr);
1611 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1612 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1613 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1615 bfd_make_readable (abfd);
1619 /* .section .idata$4
1624 .global __my_dll_iname
1629 make_tail (bfd *parent)
1631 asection *id4, *id5, *id7;
1632 unsigned char *d4, *d5, *d7;
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 (5 * sizeof (asymbol *));
1650 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1651 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1652 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1653 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1655 bfd_set_section_size (abfd, id4, 4);
1660 bfd_set_section_size (abfd, id5, 4);
1665 len = strlen (dll_filename) + 1;
1668 bfd_set_section_size (abfd, id7, len);
1671 strcpy (d7, dll_filename);
1673 bfd_set_symtab (abfd, symtab, symptr);
1675 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1676 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1677 bfd_set_section_contents (abfd, id7, d7, 0, len);
1679 bfd_make_readable (abfd);
1685 .global ___imp_function
1686 .global __imp__function
1688 jmp *__imp__function:
1702 .asciz "function" xlate? (add underscore, kill at) */
1704 static unsigned char jmp_ix86_bytes[] =
1706 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1714 .dw __imp_function */
1716 static unsigned char jmp_sh_bytes[] =
1718 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1722 lui $t0,<high:__imp_function>
1723 lw $t0,<low:__imp_function>
1727 static unsigned char jmp_mips_bytes[] =
1729 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1730 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1734 make_one (def_file_export *exp, bfd *parent)
1736 asection *tx, *id7, *id5, *id4, *id6;
1737 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1741 unsigned char *jmp_bytes = NULL;
1742 int jmp_byte_count = 0;
1744 switch (pe_details->pe_arch)
1747 jmp_bytes = jmp_ix86_bytes;
1748 jmp_byte_count = sizeof (jmp_ix86_bytes);
1751 jmp_bytes = jmp_sh_bytes;
1752 jmp_byte_count = sizeof (jmp_sh_bytes);
1755 jmp_bytes = jmp_mips_bytes;
1756 jmp_byte_count = sizeof (jmp_mips_bytes);
1762 oname = xmalloc (20);
1763 sprintf (oname, "d%06d.o", tmp_seq);
1766 abfd = bfd_create (oname, parent);
1767 bfd_find_target (pe_details->object_target, abfd);
1768 bfd_make_writable (abfd);
1770 bfd_set_format (abfd, bfd_object);
1771 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1774 symtab = xmalloc (11 * sizeof (asymbol *));
1775 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1776 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1777 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1778 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1779 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1781 if (*exp->internal_name == '@')
1783 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1785 if (! exp->flag_data)
1786 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
1787 quick_symbol (abfd, U ("_imp_"), exp->internal_name, "", id5,
1789 /* Fastcall applies only to functions,
1790 so no need for auto-import symbol. */
1794 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1796 if (! exp->flag_data)
1797 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
1799 quick_symbol (abfd, U ("_imp__"), exp->internal_name, "", id5,
1801 /* Symbol to reference ord/name of imported
1802 data symbol, used to implement auto-import. */
1804 quick_symbol (abfd, U("_nm__"), exp->internal_name, "", id6,
1807 if (pe_dll_compat_implib)
1808 quick_symbol (abfd, U ("__imp_"), exp->internal_name, "", id5,
1811 if (! exp->flag_data)
1813 bfd_set_section_size (abfd, tx, jmp_byte_count);
1814 td = xmalloc (jmp_byte_count);
1816 memcpy (td, jmp_bytes, jmp_byte_count);
1818 switch (pe_details->pe_arch)
1821 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1824 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1827 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1828 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1829 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1837 bfd_set_section_size (abfd, id7, 4);
1841 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
1844 bfd_set_section_size (abfd, id5, 4);
1849 if (exp->flag_noname)
1851 d5[0] = exp->ordinal;
1852 d5[1] = exp->ordinal >> 8;
1857 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1861 bfd_set_section_size (abfd, id4, 4);
1866 if (exp->flag_noname)
1868 d4[0] = exp->ordinal;
1869 d4[1] = exp->ordinal >> 8;
1874 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1878 if (exp->flag_noname)
1881 bfd_set_section_size (abfd, id6, 0);
1885 len = strlen (exp->name) + 3;
1888 bfd_set_section_size (abfd, id6, len);
1891 memset (d6, 0, len);
1892 d6[0] = exp->hint & 0xff;
1893 d6[1] = exp->hint >> 8;
1894 strcpy (d6 + 2, exp->name);
1897 bfd_set_symtab (abfd, symtab, symptr);
1899 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
1900 bfd_set_section_contents (abfd, id7, d7, 0, 4);
1901 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1902 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1903 if (!exp->flag_noname)
1904 bfd_set_section_contents (abfd, id6, d6, 0, len);
1906 bfd_make_readable (abfd);
1911 make_singleton_name_thunk (const char *import, bfd *parent)
1913 /* Name thunks go to idata$4. */
1919 oname = xmalloc (20);
1920 sprintf (oname, "nmth%06d.o", tmp_seq);
1923 abfd = bfd_create (oname, parent);
1924 bfd_find_target (pe_details->object_target, abfd);
1925 bfd_make_writable (abfd);
1927 bfd_set_format (abfd, bfd_object);
1928 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1931 symtab = xmalloc (3 * sizeof (asymbol *));
1932 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1933 quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
1934 quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
1936 bfd_set_section_size (abfd, id4, 8);
1940 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1943 bfd_set_symtab (abfd, symtab, symptr);
1945 bfd_set_section_contents (abfd, id4, d4, 0, 8);
1947 bfd_make_readable (abfd);
1952 make_import_fixup_mark (arelent *rel)
1954 /* We convert reloc to symbol, for later reference. */
1956 static char *fixup_name = NULL;
1957 static size_t buffer_len = 0;
1959 struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
1961 bfd *abfd = bfd_asymbol_bfd (sym);
1962 struct bfd_link_hash_entry *bh;
1966 fixup_name = xmalloc (384);
1970 if (strlen (sym->name) + 25 > buffer_len)
1971 /* Assume 25 chars for "__fu" + counter + "_". If counter is
1972 bigger than 20 digits long, we've got worse problems than
1973 overflowing this buffer... */
1976 /* New buffer size is length of symbol, plus 25, but
1977 then rounded up to the nearest multiple of 128. */
1978 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
1979 fixup_name = xmalloc (buffer_len);
1982 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
1985 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
1986 current_sec, /* sym->section, */
1987 rel->address, NULL, TRUE, FALSE, &bh);
1991 struct coff_link_hash_entry *myh;
1993 myh = (struct coff_link_hash_entry *) bh;
1994 printf ("type:%d\n", myh->type);
1995 printf ("%s\n", myh->root.u.def.section->name);
2001 /* .section .idata$3
2002 .rva __nm_thnk_SYM (singleton thunk with name of func)
2005 .rva __my_dll_iname (name of dll)
2006 .rva __fuNN_SYM (pointer to reference (address) in text) */
2009 make_import_fixup_entry (const char *name,
2010 const char *fixup_name,
2011 const char *dll_symname,
2019 oname = xmalloc (20);
2020 sprintf (oname, "fu%06d.o", tmp_seq);
2023 abfd = bfd_create (oname, parent);
2024 bfd_find_target (pe_details->object_target, abfd);
2025 bfd_make_writable (abfd);
2027 bfd_set_format (abfd, bfd_object);
2028 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2031 symtab = xmalloc (6 * sizeof (asymbol *));
2032 id3 = quick_section (abfd, ".idata$3", SEC_HAS_CONTENTS, 2);
2035 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
2037 quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2038 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2039 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2041 bfd_set_section_size (abfd, id3, 20);
2046 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2047 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2048 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2051 bfd_set_symtab (abfd, symtab, symptr);
2053 bfd_set_section_contents (abfd, id3, d3, 0, 20);
2055 bfd_make_readable (abfd);
2059 /* .section .rdata_runtime_pseudo_reloc
2061 .rva __fuNN_SYM (pointer to reference (address) in text) */
2064 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2065 const char *fixup_name,
2070 unsigned char *rt_rel_d;
2074 oname = xmalloc (20);
2075 sprintf (oname, "rtr%06d.o", tmp_seq);
2078 abfd = bfd_create (oname, parent);
2079 bfd_find_target (pe_details->object_target, abfd);
2080 bfd_make_writable (abfd);
2082 bfd_set_format (abfd, bfd_object);
2083 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2086 symtab = xmalloc (2 * sizeof (asymbol *));
2087 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2088 SEC_HAS_CONTENTS, 2);
2090 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2092 bfd_set_section_size (abfd, rt_rel, 8);
2093 rt_rel_d = xmalloc (8);
2094 rt_rel->contents = rt_rel_d;
2095 memset (rt_rel_d, 0, 8);
2096 bfd_put_32 (abfd, addend, rt_rel_d);
2098 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2099 save_relocs (rt_rel);
2101 bfd_set_symtab (abfd, symtab, symptr);
2103 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2105 bfd_make_readable (abfd);
2110 .rva __pei386_runtime_relocator */
2113 pe_create_runtime_relocator_reference (bfd *parent)
2115 asection *extern_rt_rel;
2116 unsigned char *extern_rt_rel_d;
2120 oname = xmalloc (20);
2121 sprintf (oname, "ertr%06d.o", tmp_seq);
2124 abfd = bfd_create (oname, parent);
2125 bfd_find_target (pe_details->object_target, abfd);
2126 bfd_make_writable (abfd);
2128 bfd_set_format (abfd, bfd_object);
2129 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2132 symtab = xmalloc (2 * sizeof (asymbol *));
2133 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2135 quick_symbol (abfd, "", "__pei386_runtime_relocator", "", UNDSEC,
2138 bfd_set_section_size (abfd, extern_rt_rel, 4);
2139 extern_rt_rel_d = xmalloc (4);
2140 extern_rt_rel->contents = extern_rt_rel_d;
2142 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2143 save_relocs (extern_rt_rel);
2145 bfd_set_symtab (abfd, symtab, symptr);
2147 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
2149 bfd_make_readable (abfd);
2154 pe_create_import_fixup (arelent *rel, asection *s, int addend)
2157 struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
2158 struct bfd_link_hash_entry *name_thunk_sym;
2159 const char *name = sym->name;
2160 char *fixup_name = make_import_fixup_mark (rel);
2163 sprintf (buf, U ("_nm_thnk_%s"), name);
2165 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2167 if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2169 bfd *b = make_singleton_name_thunk (name, output_bfd);
2170 add_bfd_to_link (b, b->filename, &link_info);
2172 /* If we ever use autoimport, we have to cast text section writable. */
2173 config.text_read_only = FALSE;
2176 if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2178 extern char * pe_data_import_dll;
2179 char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2181 b = make_import_fixup_entry (name, fixup_name, dll_symname, output_bfd);
2182 add_bfd_to_link (b, b->filename, &link_info);
2187 if (link_info.pei386_runtime_pseudo_reloc)
2189 if (pe_dll_extra_pe_debug)
2190 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2191 fixup_name, addend);
2192 b = make_runtime_pseudo_reloc (name, fixup_name, addend, output_bfd);
2193 add_bfd_to_link (b, b->filename, &link_info);
2195 if (runtime_pseudo_relocs_created == 0)
2197 b = pe_create_runtime_relocator_reference (output_bfd);
2198 add_bfd_to_link (b, b->filename, &link_info);
2200 runtime_pseudo_relocs_created++;
2204 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2205 s->owner, s, rel->address, sym->name);
2213 pe_dll_generate_implib (def_file *def, const char *impfilename)
2221 dll_filename = (def->name) ? def->name : dll_name;
2222 dll_symname = xstrdup (dll_filename);
2223 for (i = 0; dll_symname[i]; i++)
2224 if (!ISALNUM (dll_symname[i]))
2225 dll_symname[i] = '_';
2227 unlink (impfilename);
2229 outarch = bfd_openw (impfilename, 0);
2233 /* xgettext:c-format */
2234 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2238 /* xgettext:c-format */
2239 einfo (_("Creating library file: %s\n"), impfilename);
2241 bfd_set_format (outarch, bfd_archive);
2242 outarch->has_armap = 1;
2244 /* Work out a reasonable size of things to put onto one line. */
2245 ar_head = make_head (outarch);
2247 for (i = 0; i < def->num_exports; i++)
2249 /* The import library doesn't know about the internal name. */
2250 char *internal = def->exports[i].internal_name;
2253 def->exports[i].internal_name = def->exports[i].name;
2254 n = make_one (def->exports + i, outarch);
2257 def->exports[i].internal_name = internal;
2260 ar_tail = make_tail (outarch);
2262 if (ar_head == NULL || ar_tail == NULL)
2265 /* Now stick them all into the archive. */
2266 ar_head->next = head;
2267 ar_tail->next = ar_head;
2270 if (! bfd_set_archive_head (outarch, head))
2271 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
2273 if (! bfd_close (outarch))
2274 einfo ("%Xbfd_close %s: %s\n", impfilename, bfd_errmsg (bfd_get_error ()));
2276 while (head != NULL)
2278 bfd *n = head->next;
2285 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *link_info)
2287 lang_input_statement_type *fake_file;
2289 fake_file = lang_add_input_file (name,
2290 lang_input_file_is_fake_enum,
2292 fake_file->the_bfd = abfd;
2293 ldlang_add_file (fake_file);
2295 if (!bfd_link_add_symbols (abfd, link_info))
2296 einfo ("%Xaddsym %s: %s\n", name, bfd_errmsg (bfd_get_error ()));
2300 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *link_info)
2302 def_file_module *module;
2304 pe_dll_id_target (bfd_get_target (output_bfd));
2309 for (module = pe_def_file->modules; module; module = module->next)
2313 dll_filename = module->name;
2314 dll_symname = xstrdup (module->name);
2315 for (i = 0; dll_symname[i]; i++)
2316 if (!ISALNUM (dll_symname[i]))
2317 dll_symname[i] = '_';
2321 for (i = 0; i < pe_def_file->num_imports; i++)
2322 if (pe_def_file->imports[i].module == module)
2324 def_file_export exp;
2325 struct bfd_link_hash_entry *blhe;
2326 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2327 /* See if we need this import. */
2328 size_t len = strlen (pe_def_file->imports[i].internal_name);
2329 char *name = xmalloc (len + 2 + 6);
2332 sprintf (name, "%s%s", "",
2333 pe_def_file->imports[i].internal_name);
2335 sprintf (name, "%s%s",U (""),
2336 pe_def_file->imports[i].internal_name);
2338 blhe = bfd_link_hash_lookup (link_info->hash, name,
2339 FALSE, FALSE, FALSE);
2341 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2344 sprintf (name, "%s%s", U ("_imp_"),
2345 pe_def_file->imports[i].internal_name);
2347 sprintf (name, "%s%s", U ("_imp__"),
2348 pe_def_file->imports[i].internal_name);
2350 blhe = bfd_link_hash_lookup (link_info->hash, name,
2351 FALSE, FALSE, FALSE);
2355 if (blhe && blhe->type == bfd_link_hash_undefined)
2361 bfd *ar_head = make_head (output_bfd);
2362 add_bfd_to_link (ar_head, ar_head->filename, link_info);
2365 exp.internal_name = pe_def_file->imports[i].internal_name;
2366 exp.name = pe_def_file->imports[i].name;
2367 exp.ordinal = pe_def_file->imports[i].ordinal;
2368 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2369 exp.flag_private = 0;
2370 exp.flag_constant = 0;
2371 exp.flag_data = pe_def_file->imports[i].data;
2372 exp.flag_noname = exp.name ? 0 : 1;
2373 one = make_one (&exp, output_bfd);
2374 add_bfd_to_link (one, one->filename, link_info);
2379 bfd *ar_tail = make_tail (output_bfd);
2380 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2387 /* We were handed a *.DLL file. Parse it and turn it into a set of
2388 IMPORTS directives in the def file. Return TRUE if the file was
2389 handled, FALSE if not. */
2392 pe_get16 (bfd *abfd, int where)
2396 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2397 bfd_bread (b, (bfd_size_type) 2, abfd);
2398 return b[0] + (b[1] << 8);
2402 pe_get32 (bfd *abfd, int where)
2406 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2407 bfd_bread (b, (bfd_size_type) 4, abfd);
2408 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2411 #if 0 /* This is not currently used. */
2416 unsigned char *b = ptr;
2418 return b[0] + (b[1] << 8);
2426 unsigned char *b = ptr;
2428 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2432 pe_implied_import_dll (const char *filename)
2435 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
2436 unsigned long export_rva, export_size, nsections, secptr, expptr;
2437 unsigned long exp_funcbase;
2438 unsigned char *expdata, *erva;
2439 unsigned long name_rvas, ordinals, nexp, ordbase;
2440 const char *dll_name;
2441 /* Initialization with start > end guarantees that is_data
2442 will not be set by mistake, and avoids compiler warning. */
2443 unsigned long data_start = 1;
2444 unsigned long data_end = 0;
2445 unsigned long rdata_start = 1;
2446 unsigned long rdata_end = 0;
2447 unsigned long bss_start = 1;
2448 unsigned long bss_end = 0;
2450 /* No, I can't use bfd here. kernel32.dll puts its export table in
2451 the middle of the .rdata section. */
2452 dll = bfd_openr (filename, pe_details->target_name);
2455 einfo ("%Xopen %s: %s\n", filename, bfd_errmsg (bfd_get_error ()));
2459 /* PEI dlls seem to be bfd_objects. */
2460 if (!bfd_check_format (dll, bfd_object))
2462 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2466 /* Get pe_header, optional header and numbers of export entries. */
2467 pe_header_offset = pe_get32 (dll, 0x3c);
2468 opthdr_ofs = pe_header_offset + 4 + 20;
2469 num_entries = pe_get32 (dll, opthdr_ofs + 92);
2471 if (num_entries < 1) /* No exports. */
2474 export_rva = pe_get32 (dll, opthdr_ofs + 96);
2475 export_size = pe_get32 (dll, opthdr_ofs + 100);
2476 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2477 secptr = (pe_header_offset + 4 + 20 +
2478 pe_get16 (dll, pe_header_offset + 4 + 16));
2481 /* Get the rva and size of the export section. */
2482 for (i = 0; i < nsections; i++)
2485 unsigned long secptr1 = secptr + 40 * i;
2486 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2487 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
2488 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
2490 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2491 bfd_bread (sname, (bfd_size_type) 8, dll);
2493 if (vaddr <= export_rva && vaddr + vsize > export_rva)
2495 expptr = fptr + (export_rva - vaddr);
2496 if (export_rva + export_size > vaddr + vsize)
2497 export_size = vsize - (export_rva - vaddr);
2502 /* Scan sections and store the base and size of the
2503 data and bss segments in data/base_start/end. */
2504 for (i = 0; i < nsections; i++)
2506 unsigned long secptr1 = secptr + 40 * i;
2507 unsigned long vsize = pe_get32 (dll, secptr1 + 8);
2508 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2509 unsigned long flags = pe_get32 (dll, secptr1 + 36);
2513 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
2514 bfd_bread (sec_name, (bfd_size_type) 8, dll);
2516 if (strcmp(sec_name,".data") == 0)
2519 data_end = vaddr + vsize;
2521 if (pe_dll_extra_pe_debug)
2522 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2523 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2525 else if (strcmp(sec_name,".rdata") == 0)
2527 rdata_start = vaddr;
2528 rdata_end = vaddr + vsize;
2530 if (pe_dll_extra_pe_debug)
2531 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2532 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2534 else if (strcmp (sec_name,".bss") == 0)
2537 bss_end = vaddr + vsize;
2539 if (pe_dll_extra_pe_debug)
2540 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2541 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2545 expdata = xmalloc (export_size);
2546 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2547 bfd_bread (expdata, (bfd_size_type) export_size, dll);
2548 erva = expdata - export_rva;
2550 if (pe_def_file == 0)
2551 pe_def_file = def_file_empty ();
2553 nexp = pe_as32 (expdata + 24);
2554 name_rvas = pe_as32 (expdata + 32);
2555 ordinals = pe_as32 (expdata + 36);
2556 ordbase = pe_as32 (expdata + 16);
2557 exp_funcbase = pe_as32 (expdata + 28);
2559 /* Use internal dll name instead of filename
2560 to enable symbolic dll linking. */
2561 dll_name = pe_as32 (expdata + 12) + erva;
2563 /* Check to see if the dll has already been added to
2564 the definition list and if so return without error.
2565 This avoids multiple symbol definitions. */
2566 if (def_get_module (pe_def_file, dll_name))
2568 if (pe_dll_extra_pe_debug)
2569 printf ("%s is already loaded\n", dll_name);
2573 /* Iterate through the list of symbols. */
2574 for (i = 0; i < nexp; i++)
2576 /* Pointer to the names vector. */
2577 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
2578 def_file_import *imp;
2579 /* Pointer to the function address vector. */
2580 unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
2583 /* Skip unwanted symbols, which are
2584 exported in buggy auto-import releases. */
2585 if (strncmp (erva + name_rva, "_nm_", 4) != 0)
2587 /* is_data is true if the address is in the data, rdata or bss
2590 (func_rva >= data_start && func_rva < data_end)
2591 || (func_rva >= rdata_start && func_rva < rdata_end)
2592 || (func_rva >= bss_start && func_rva < bss_end);
2594 imp = def_file_add_import (pe_def_file, erva + name_rva,
2596 /* Mark symbol type. */
2597 imp->data = is_data;
2599 if (pe_dll_extra_pe_debug)
2600 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2601 __FUNCTION__, dll_name, erva + name_rva,
2602 func_rva, is_data ? "(data)" : "");
2609 /* These are the main functions, called from the emulation. The first
2610 is called after the bfds are read, so we can guess at how much space
2611 we need. The second is called after everything is placed, so we
2612 can put the right values in place. */
2615 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
2617 pe_dll_id_target (bfd_get_target (abfd));
2618 process_def_file (abfd, info);
2620 if (pe_def_file->num_exports == 0 && !info->shared)
2623 generate_edata (abfd, info);
2624 build_filler_bfd (1);
2628 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2630 pe_dll_id_target (bfd_get_target (abfd));
2631 build_filler_bfd (0);
2635 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
2637 pe_dll_id_target (bfd_get_target (abfd));
2638 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2640 generate_reloc (abfd, info);
2643 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2645 /* Resize the sections. */
2646 lang_size_sections (stat_ptr->head, abs_output_section,
2647 &stat_ptr->head, 0, 0, NULL, TRUE);
2649 /* Redo special stuff. */
2650 ldemul_after_allocation ();
2652 /* Do the assignments again. */
2653 lang_do_assignments (stat_ptr->head, abs_output_section, NULL, 0);
2656 fill_edata (abfd, info);
2659 pe_data (abfd)->dll = 1;
2661 edata_s->contents = edata_d;
2662 reloc_s->contents = reloc_d;
2666 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
2668 pe_dll_id_target (bfd_get_target (abfd));
2669 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2671 generate_reloc (abfd, info);
2674 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2676 /* Resize the sections. */
2677 lang_size_sections (stat_ptr->head, abs_output_section,
2678 &stat_ptr->head, 0, 0, NULL, TRUE);
2680 /* Redo special stuff. */
2681 ldemul_after_allocation ();
2683 /* Do the assignments again. */
2684 lang_do_assignments (stat_ptr->head, abs_output_section, NULL, 0);
2686 reloc_s->contents = reloc_d;