1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
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, 59 Temple Place - Suite 330, 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$3 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;
150 unsigned int imagebase_reloc;
162 autofilter_entry_type;
164 #define PE_ARCH_i386 1
166 #define PE_ARCH_mips 3
167 #define PE_ARCH_arm 4
168 #define PE_ARCH_arm_epoc 5
170 static pe_details_type pe_detail_list[] =
183 16 /* R_SH_IMAGEBASE */,
205 "epoc-pei-arm-little",
206 "epoc-pe-arm-little",
212 { NULL, NULL, 0, 0, 0, 0 }
215 static pe_details_type *pe_details;
217 static autofilter_entry_type autofilter_symbollist[] =
219 { "DllMain@12", 10 },
220 { "DllEntryPoint@0", 15 },
221 { "DllMainCRTStartup@12", 20 },
222 { "_cygwin_dll_entry@12", 20 },
223 { "_cygwin_crt0_common@8", 21 },
224 { "_cygwin_noncygwin_dll_entry@12", 30 },
225 { "impure_ptr", 10 },
226 { "_pei386_runtime_relocator", 25 },
227 { "do_pseudo_reloc", 15 },
228 { "cygwin_crt0", 11 },
232 /* Do not specify library suffix explicitly, to allow for dllized versions. */
233 static autofilter_entry_type autofilter_liblist[] =
238 { "libmingw32", 10 },
239 { "libmingwex", 10 },
247 static autofilter_entry_type autofilter_objlist[] =
257 { "crtbegin.o", 10 },
262 static autofilter_entry_type autofilter_symbolprefixlist[] =
264 /* { "__imp_", 6 }, */
265 /* Do __imp_ explicitly to save time. */
267 /* Don't re-export auto-imported symbols. */
269 { "__builtin_", 10 },
270 /* Don't export symbols specifying internal DLL layout. */
273 { "_impure_ptr", 11 },
274 { "cygwin_attach_dll", 17 },
275 { "cygwin_premain0", 15 },
276 { "cygwin_premain1", 15 },
277 { "cygwin_premain2", 15 },
278 { "cygwin_premain3", 15 },
283 static autofilter_entry_type autofilter_symbolsuffixlist[] =
289 #define U(str) (pe_details->underscored ? "_" str : str)
292 pe_dll_id_target (const char *target)
296 for (i = 0; pe_detail_list[i].target_name; i++)
297 if (strcmp (pe_detail_list[i].target_name, target) == 0
298 || strcmp (pe_detail_list[i].object_target, target) == 0)
300 pe_details = pe_detail_list + i;
303 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
307 /* Helper functions for qsort. Relocs must be sorted so that we can write
308 them out by pages. */
319 reloc_sort (const void *va, const void *vb)
321 bfd_vma a = ((const reloc_data_type *) va)->vma;
322 bfd_vma b = ((const reloc_data_type *) vb)->vma;
324 return (a > b) ? 1 : ((a < b) ? -1 : 0);
328 pe_export_sort (const void *va, const void *vb)
330 const def_file_export *a = va;
331 const def_file_export *b = vb;
333 return strcmp (a->name, b->name);
336 /* Read and process the .DEF file. */
338 /* These correspond to the entries in pe_def_file->exports[]. I use
339 exported_symbol_sections[i] to tag whether or not the symbol was
340 defined, since we can't export symbols we don't have. */
342 static bfd_vma *exported_symbol_offsets;
343 static struct bfd_section **exported_symbol_sections;
344 static int export_table_size;
345 static int count_exported;
346 static int count_exported_byname;
347 static int count_with_ordinals;
348 static const char *dll_name;
349 static int min_ordinal, max_ordinal;
350 static int *exported_symbols;
352 typedef struct exclude_list_struct
355 struct exclude_list_struct *next;
360 static struct exclude_list_struct *excludes = 0;
363 pe_dll_add_excludes (const char *new_excludes, const int type)
366 char *exclude_string;
368 local_copy = xstrdup (new_excludes);
370 exclude_string = strtok (local_copy, ",:");
371 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
373 struct exclude_list_struct *new_exclude;
375 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
376 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
377 strcpy (new_exclude->string, exclude_string);
378 new_exclude->type = type;
379 new_exclude->next = excludes;
380 excludes = new_exclude;
387 /* abfd is a bfd containing n (or NULL)
388 It can be used for contextual checks. */
391 auto_export (bfd *abfd, def_file *d, const char *n)
394 struct exclude_list_struct *ex;
395 autofilter_entry_type *afptr;
396 const char * libname = 0;
397 if (abfd && abfd->my_archive)
398 libname = lbasename (abfd->my_archive->filename);
400 /* We should not re-export imported stuff. */
401 if (strncmp (n, "_imp__", 6) == 0)
404 for (i = 0; i < d->num_exports; i++)
405 if (strcmp (d->exports[i].name, n) == 0)
408 if (pe_dll_do_default_excludes)
413 if (pe_dll_extra_pe_debug)
414 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
415 n, abfd, abfd->my_archive);
417 /* First of all, make context checks:
418 Don't export anything from standard libs. */
421 afptr = autofilter_liblist;
425 if (strncmp (libname, afptr->name, afptr->len) == 0 )
431 /* Next, exclude symbols from certain startup objects. */
433 if (abfd && (p = lbasename (abfd->filename)))
435 afptr = autofilter_objlist;
438 if (strcmp (p, afptr->name) == 0)
444 /* Don't try to blindly exclude all symbols
445 that begin with '__'; this was tried and
446 it is too restrictive. */
448 /* Then, exclude specific symbols. */
449 afptr = autofilter_symbollist;
452 if (strcmp (n, afptr->name) == 0)
458 /* Next, exclude symbols starting with ... */
459 afptr = autofilter_symbolprefixlist;
462 if (strncmp (n, afptr->name, afptr->len) == 0)
468 /* Finally, exclude symbols ending with ... */
470 afptr = autofilter_symbolsuffixlist;
473 if ((len >= afptr->len)
474 /* Add 1 to insure match with trailing '\0'. */
475 && strncmp (n + len - afptr->len, afptr->name,
476 afptr->len + 1) == 0)
483 for (ex = excludes; ex; ex = ex->next)
485 if (ex->type == 1) /* exclude-libs */
488 && ((strcmp (libname, ex->string) == 0)
489 || (strcasecmp ("ALL", ex->string) == 0)))
492 else if (strcmp (n, ex->string) == 0)
500 process_def_file (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
503 struct bfd_link_hash_entry *blhe;
505 struct bfd_section *s;
506 def_file_export *e = 0;
509 pe_def_file = def_file_empty ();
511 /* First, run around to all the objects looking for the .drectve
512 sections, and push those into the def file too. */
513 for (b = info->input_bfds; b; b = b->link_next)
515 s = bfd_get_section_by_name (b, ".drectve");
519 char *buf = xmalloc (size);
521 bfd_get_section_contents (b, s, buf, 0, size);
522 def_file_add_directive (pe_def_file, buf, size);
527 /* If we are not building a DLL, when there are no exports
528 we do not build an export table at all. */
529 if (!pe_dll_export_everything && pe_def_file->num_exports == 0
533 /* Now, maybe export everything else the default way. */
534 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
536 for (b = info->input_bfds; b; b = b->link_next)
541 symsize = bfd_get_symtab_upper_bound (b);
542 symbols = xmalloc (symsize);
543 nsyms = bfd_canonicalize_symtab (b, symbols);
545 for (j = 0; j < nsyms; j++)
547 /* We should export symbols which are either global or not
548 anything at all. (.bss data is the latter)
549 We should not export undefined symbols. */
550 if (symbols[j]->section != &bfd_und_section
551 && ((symbols[j]->flags & BSF_GLOBAL)
552 || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
554 const char *sn = symbols[j]->name;
556 /* We should not re-export imported stuff. */
558 char *name = xmalloc (strlen (sn) + 2 + 6);
559 sprintf (name, "%s%s", U("_imp_"), sn);
561 blhe = bfd_link_hash_lookup (info->hash, name,
562 FALSE, FALSE, FALSE);
565 if (blhe && blhe->type == bfd_link_hash_defined)
572 if (auto_export (b, pe_def_file, sn))
575 p=def_file_add_export (pe_def_file, sn, 0, -1);
576 /* Fill data flag properly, from dlltool.c. */
577 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
585 #define NE pe_def_file->num_exports
587 /* Canonicalize the export list. */
590 for (i = 0; i < NE; i++)
592 if (strchr (pe_def_file->exports[i].name, '@'))
594 /* This will preserve internal_name, which may have been
595 pointing to the same memory as name, or might not
597 int lead_at = (*pe_def_file->exports[i].name == '@');
598 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
600 *(strchr (tmp, '@')) = 0;
601 pe_def_file->exports[i].name = tmp;
606 if (pe_dll_stdcall_aliases)
608 for (i = 0; i < NE; i++)
610 if (strchr (pe_def_file->exports[i].name, '@'))
612 int lead_at = (*pe_def_file->exports[i].name == '@');
613 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
615 *(strchr (tmp, '@')) = 0;
616 if (auto_export (NULL, pe_def_file, tmp))
617 def_file_add_export (pe_def_file, tmp,
618 pe_def_file->exports[i].internal_name,
626 /* Convenience, but watch out for it changing. */
627 e = pe_def_file->exports;
629 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
630 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
632 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
636 count_exported_byname = 0;
637 count_with_ordinals = 0;
639 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
641 for (i = 0, j = 0; i < NE; i++)
643 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
645 /* This is a duplicate. */
646 if (e[j - 1].ordinal != -1
647 && e[i].ordinal != -1
648 && e[j - 1].ordinal != e[i].ordinal)
650 if (pe_dll_warn_dup_exports)
651 /* xgettext:c-format */
652 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
653 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
657 if (pe_dll_warn_dup_exports)
658 /* xgettext:c-format */
659 einfo (_("Warning, duplicate EXPORT: %s\n"),
663 if (e[i].ordinal != -1)
664 e[j - 1].ordinal = e[i].ordinal;
665 e[j - 1].flag_private |= e[i].flag_private;
666 e[j - 1].flag_constant |= e[i].flag_constant;
667 e[j - 1].flag_noname |= e[i].flag_noname;
668 e[j - 1].flag_data |= e[i].flag_data;
677 pe_def_file->num_exports = j; /* == NE */
679 for (i = 0; i < NE; i++)
683 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
684 if (pe_details->underscored
685 && (*pe_def_file->exports[i].internal_name != '@'))
688 strcpy (name + 1, pe_def_file->exports[i].internal_name);
691 strcpy (name, pe_def_file->exports[i].internal_name);
693 blhe = bfd_link_hash_lookup (info->hash,
698 && (blhe->type == bfd_link_hash_defined
699 || (blhe->type == bfd_link_hash_common)))
702 if (!pe_def_file->exports[i].flag_noname)
703 count_exported_byname++;
705 /* Only fill in the sections. The actual offsets are computed
706 in fill_exported_offsets() after common symbols are laid
708 if (blhe->type == bfd_link_hash_defined)
709 exported_symbol_sections[i] = blhe->u.def.section;
711 exported_symbol_sections[i] = blhe->u.c.p->section;
713 if (pe_def_file->exports[i].ordinal != -1)
715 if (max_ordinal < pe_def_file->exports[i].ordinal)
716 max_ordinal = pe_def_file->exports[i].ordinal;
717 if (min_ordinal > pe_def_file->exports[i].ordinal)
718 min_ordinal = pe_def_file->exports[i].ordinal;
719 count_with_ordinals++;
722 else if (blhe && blhe->type == bfd_link_hash_undefined)
724 /* xgettext:c-format */
725 einfo (_("%XCannot export %s: symbol not defined\n"),
726 pe_def_file->exports[i].internal_name);
730 /* xgettext:c-format */
731 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
732 pe_def_file->exports[i].internal_name,
733 blhe->type, bfd_link_hash_defined);
737 /* xgettext:c-format */
738 einfo (_("%XCannot export %s: symbol not found\n"),
739 pe_def_file->exports[i].internal_name);
745 /* Build the bfd that will contain .edata and .reloc sections. */
748 build_filler_bfd (int include_edata)
750 lang_input_statement_type *filler_file;
751 filler_file = lang_add_input_file ("dll stuff",
752 lang_input_file_is_fake_enum,
754 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
755 if (filler_bfd == NULL
756 || !bfd_set_arch_mach (filler_bfd,
757 bfd_get_arch (output_bfd),
758 bfd_get_mach (output_bfd)))
760 einfo ("%X%P: can not create BFD %E\n");
766 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
768 || !bfd_set_section_flags (filler_bfd, edata_s,
775 einfo ("%X%P: can not create .edata section: %E\n");
778 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
781 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
783 || !bfd_set_section_flags (filler_bfd, reloc_s,
790 einfo ("%X%P: can not create .reloc section: %E\n");
794 bfd_set_section_size (filler_bfd, reloc_s, 0);
796 ldlang_add_file (filler_file);
799 /* Gather all the exported symbols and build the .edata section. */
802 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
805 int name_table_size = 0;
808 /* First, we need to know how many exported symbols there are,
809 and what the range of ordinals is. */
810 if (pe_def_file->name)
811 dll_name = pe_def_file->name;
814 dll_name = abfd->filename;
816 for (dlnp = dll_name; *dlnp; dlnp++)
817 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
821 if (count_with_ordinals && max_ordinal > count_exported)
823 if (min_ordinal > max_ordinal - count_exported + 1)
824 min_ordinal = max_ordinal - count_exported + 1;
829 max_ordinal = count_exported;
832 export_table_size = max_ordinal - min_ordinal + 1;
833 exported_symbols = xmalloc (export_table_size * sizeof (int));
834 for (i = 0; i < export_table_size; i++)
835 exported_symbols[i] = -1;
837 /* Now we need to assign ordinals to those that don't have them. */
838 for (i = 0; i < NE; i++)
840 if (exported_symbol_sections[i])
842 if (pe_def_file->exports[i].ordinal != -1)
844 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
845 int pi = exported_symbols[ei];
849 /* xgettext:c-format */
850 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
851 pe_def_file->exports[i].ordinal,
852 pe_def_file->exports[i].name,
853 pe_def_file->exports[pi].name);
855 exported_symbols[ei] = i;
857 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
861 next_ordinal = min_ordinal;
862 for (i = 0; i < NE; i++)
863 if (exported_symbol_sections[i])
864 if (pe_def_file->exports[i].ordinal == -1)
866 while (exported_symbols[next_ordinal - min_ordinal] != -1)
869 exported_symbols[next_ordinal - min_ordinal] = i;
870 pe_def_file->exports[i].ordinal = next_ordinal;
873 /* OK, now we can allocate some memory. */
874 edata_sz = (40 /* directory */
875 + 4 * export_table_size /* addresses */
876 + 4 * count_exported_byname /* name ptrs */
877 + 2 * count_exported_byname /* ordinals */
878 + name_table_size + strlen (dll_name) + 1);
881 /* Fill the exported symbol offsets. The preliminary work has already
882 been done in process_def_file(). */
885 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
888 struct bfd_link_hash_entry *blhe;
890 for (i = 0; i < pe_def_file->num_exports; i++)
894 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
895 if (pe_details->underscored
896 && *pe_def_file->exports[i].internal_name != '@')
899 strcpy (name + 1, pe_def_file->exports[i].internal_name);
902 strcpy (name, pe_def_file->exports[i].internal_name);
904 blhe = bfd_link_hash_lookup (info->hash,
908 if (blhe && blhe->type == bfd_link_hash_defined)
909 exported_symbol_offsets[i] = blhe->u.def.value;
916 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
919 unsigned char *edirectory;
920 unsigned char *eaddresses;
921 unsigned char *enameptrs;
922 unsigned char *eordinals;
923 unsigned char *enamestr;
928 edata_d = xmalloc (edata_sz);
930 /* Note use of array pointer math here. */
931 edirectory = edata_d;
932 eaddresses = edata_d + 40;
933 enameptrs = eaddresses + 4 * export_table_size;
934 eordinals = enameptrs + 4 * count_exported_byname;
935 enamestr = eordinals + 2 * count_exported_byname;
937 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
938 + edata_s->output_section->vma - image_base)
940 memset (edata_d, 0, edata_sz);
941 bfd_put_32 (abfd, now, edata_d + 4);
942 if (pe_def_file->version_major != -1)
944 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
945 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
948 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
949 strcpy (enamestr, dll_name);
950 enamestr += strlen (enamestr) + 1;
951 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
952 bfd_put_32 (abfd, export_table_size, edata_d + 20);
953 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
954 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
955 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
956 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
958 fill_exported_offsets (abfd, info);
960 /* Ok, now for the filling in part.
961 Scan alphabetically - ie the ordering in the exports[] table,
962 rather than by ordinal - the ordering in the exported_symbol[]
963 table. See dlltool.c and:
964 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
965 for more information. */
967 for (s = 0; s < NE; s++)
969 struct bfd_section *ssec = exported_symbol_sections[s];
970 if (ssec && pe_def_file->exports[s].ordinal != -1)
972 unsigned long srva = (exported_symbol_offsets[s]
973 + ssec->output_section->vma
974 + ssec->output_offset);
975 int ord = pe_def_file->exports[s].ordinal;
977 bfd_put_32 (abfd, srva - image_base,
978 eaddresses + 4 * (ord - min_ordinal));
980 if (!pe_def_file->exports[s].flag_noname)
982 char *ename = pe_def_file->exports[s].name;
984 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
986 strcpy (enamestr, ename);
987 enamestr += strlen (enamestr) + 1;
988 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
990 pe_def_file->exports[s].hint = hint++;
997 static struct bfd_section *current_sec;
1000 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1002 int (*cb) (arelent *, asection *))
1007 for (b = info->input_bfds; b; b = b->link_next)
1012 symsize = bfd_get_symtab_upper_bound (b);
1013 symbols = xmalloc (symsize);
1014 nsyms = bfd_canonicalize_symtab (b, symbols);
1016 for (s = b->sections; s; s = s->next)
1019 int relsize, nrelocs, i;
1020 int flags = bfd_get_section_flags (b, s);
1022 /* Skip discarded linkonce sections. */
1023 if (flags & SEC_LINK_ONCE
1024 && s->output_section == bfd_abs_section_ptr)
1029 relsize = bfd_get_reloc_upper_bound (b, s);
1030 relocs = xmalloc (relsize);
1031 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1033 for (i = 0; i < nrelocs; i++)
1035 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1037 if (!strcmp (name, sym->name))
1043 /* Warning: the allocated symbols are remembered in BFD and reused
1044 later, so don't free them! */
1045 /* free (symbols); */
1050 /* Gather all the relocations and build the .reloc section. */
1053 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1056 /* For .reloc stuff. */
1057 reloc_data_type *reloc_data;
1058 int total_relocs = 0;
1060 unsigned long sec_page = (unsigned long) -1;
1061 unsigned long page_ptr, page_count;
1064 struct bfd_section *s;
1067 for (b = info->input_bfds; b; b = b->link_next)
1068 for (s = b->sections; s; s = s->next)
1069 total_relocs += s->reloc_count;
1071 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1075 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1078 int relsize, nrelocs, i;
1080 for (s = b->sections; s; s = s->next)
1082 unsigned long sec_vma = s->output_section->vma + s->output_offset;
1086 /* If it's not loaded, we don't need to relocate it this way. */
1087 if (!(s->output_section->flags & SEC_LOAD))
1090 /* I don't know why there would be a reloc for these, but I've
1091 seen it happen - DJ */
1092 if (s->output_section == &bfd_abs_section)
1095 if (s->output_section->vma == 0)
1097 /* Huh? Shouldn't happen, but punt if it does. */
1098 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1099 s->output_section->name, s->output_section->index,
1100 s->output_section->flags);
1104 symsize = bfd_get_symtab_upper_bound (b);
1105 symbols = xmalloc (symsize);
1106 nsyms = bfd_canonicalize_symtab (b, symbols);
1108 relsize = bfd_get_reloc_upper_bound (b, s);
1109 relocs = xmalloc (relsize);
1110 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1112 for (i = 0; i < nrelocs; i++)
1114 if (pe_dll_extra_pe_debug)
1116 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1117 printf ("rel: %s\n", sym->name);
1119 if (!relocs[i]->howto->pc_relative
1120 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1123 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1125 sym_vma = (relocs[i]->addend
1128 + sym->section->output_offset
1129 + sym->section->output_section->vma);
1130 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1132 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1134 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1135 relocs[i]->howto->rightshift)
1137 case BITS_AND_SHIFT (32, 0):
1138 reloc_data[total_relocs].type = 3;
1141 case BITS_AND_SHIFT (16, 0):
1142 reloc_data[total_relocs].type = 2;
1145 case BITS_AND_SHIFT (16, 16):
1146 reloc_data[total_relocs].type = 4;
1147 /* FIXME: we can't know the symbol's right value
1148 yet, but we probably can safely assume that
1149 CE will relocate us in 64k blocks, so leaving
1151 reloc_data[total_relocs].extra = 0;
1154 case BITS_AND_SHIFT (26, 2):
1155 reloc_data[total_relocs].type = 5;
1158 case BITS_AND_SHIFT (24, 2):
1159 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1160 Those ARM_xxx definitions should go in proper
1162 if (relocs[i]->howto->type == 0
1163 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1164 || relocs[i]->howto->type == 5)
1165 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1166 that has already been fully processed during a
1167 previous link stage, so ignore it here. */
1171 /* xgettext:c-format */
1172 einfo (_("%XError: %d-bit reloc in dll\n"),
1173 relocs[i]->howto->bitsize);
1179 /* Warning: the allocated symbols are remembered in BFD and
1180 reused later, so don't free them! */
1187 /* At this point, we have total_relocs relocation addresses in
1188 reloc_addresses, which are all suitable for the .reloc section.
1189 We must now create the new sections. */
1190 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1192 for (i = 0; i < total_relocs; i++)
1194 unsigned long this_page = (reloc_data[i].vma >> 12);
1196 if (this_page != sec_page)
1198 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1200 sec_page = this_page;
1205 if (reloc_data[i].type == 4)
1209 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1210 reloc_d = xmalloc (reloc_sz);
1211 sec_page = (unsigned long) -1;
1213 page_ptr = (unsigned long) -1;
1216 for (i = 0; i < total_relocs; i++)
1218 unsigned long rva = reloc_data[i].vma - image_base;
1219 unsigned long this_page = (rva & ~0xfff);
1221 if (this_page != sec_page)
1223 while (reloc_sz & 3)
1224 reloc_d[reloc_sz++] = 0;
1226 if (page_ptr != (unsigned long) -1)
1227 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1229 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1230 page_ptr = reloc_sz;
1232 sec_page = this_page;
1236 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1237 reloc_d + reloc_sz);
1240 if (reloc_data[i].type == 4)
1242 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1249 while (reloc_sz & 3)
1250 reloc_d[reloc_sz++] = 0;
1252 if (page_ptr != (unsigned long) -1)
1253 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1255 while (reloc_sz < reloc_s->size)
1256 reloc_d[reloc_sz++] = 0;
1259 /* Given the exiting def_file structure, print out a .DEF file that
1260 corresponds to it. */
1263 quoteput (char *s, FILE *f, int needs_quotes)
1267 for (cp = s; *cp; cp++)
1282 if (*s == '"' || *s == '\\')
1296 pe_dll_generate_def_file (const char *pe_out_def_filename)
1299 FILE *out = fopen (pe_out_def_filename, "w");
1302 /* xgettext:c-format */
1303 einfo (_("%s: Can't open output def file %s\n"),
1304 program_name, pe_out_def_filename);
1308 if (pe_def_file->name)
1310 if (pe_def_file->is_dll)
1311 fprintf (out, "LIBRARY ");
1313 fprintf (out, "NAME ");
1315 quoteput (pe_def_file->name, out, 1);
1317 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
1318 fprintf (out, " BASE=0x%lx",
1319 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
1320 fprintf (out, "\n");
1323 if (pe_def_file->description)
1325 fprintf (out, "DESCRIPTION ");
1326 quoteput (pe_def_file->description, out, 1);
1327 fprintf (out, "\n");
1330 if (pe_def_file->version_minor != -1)
1331 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1332 pe_def_file->version_minor);
1333 else if (pe_def_file->version_major != -1)
1334 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1336 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1337 fprintf (out, "\n");
1339 if (pe_def_file->stack_commit != -1)
1340 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1341 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1342 else if (pe_def_file->stack_reserve != -1)
1343 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1345 if (pe_def_file->heap_commit != -1)
1346 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1347 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1348 else if (pe_def_file->heap_reserve != -1)
1349 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1351 if (pe_def_file->num_section_defs > 0)
1353 fprintf (out, "\nSECTIONS\n\n");
1355 for (i = 0; i < pe_def_file->num_section_defs; i++)
1358 quoteput (pe_def_file->section_defs[i].name, out, 0);
1360 if (pe_def_file->section_defs[i].class)
1362 fprintf (out, " CLASS ");
1363 quoteput (pe_def_file->section_defs[i].class, out, 0);
1366 if (pe_def_file->section_defs[i].flag_read)
1367 fprintf (out, " READ");
1369 if (pe_def_file->section_defs[i].flag_write)
1370 fprintf (out, " WRITE");
1372 if (pe_def_file->section_defs[i].flag_execute)
1373 fprintf (out, " EXECUTE");
1375 if (pe_def_file->section_defs[i].flag_shared)
1376 fprintf (out, " SHARED");
1378 fprintf (out, "\n");
1382 if (pe_def_file->num_exports > 0)
1384 fprintf (out, "EXPORTS\n");
1386 for (i = 0; i < pe_def_file->num_exports; i++)
1388 def_file_export *e = pe_def_file->exports + i;
1390 quoteput (e->name, out, 0);
1392 if (e->internal_name && strcmp (e->internal_name, e->name))
1394 fprintf (out, " = ");
1395 quoteput (e->internal_name, out, 0);
1398 if (e->ordinal != -1)
1399 fprintf (out, " @%d", e->ordinal);
1401 if (e->flag_private)
1402 fprintf (out, " PRIVATE");
1404 if (e->flag_constant)
1405 fprintf (out, " CONSTANT");
1408 fprintf (out, " NONAME");
1411 fprintf (out, " DATA");
1413 fprintf (out, "\n");
1417 if (pe_def_file->num_imports > 0)
1419 fprintf (out, "\nIMPORTS\n\n");
1421 for (i = 0; i < pe_def_file->num_imports; i++)
1423 def_file_import *im = pe_def_file->imports + i;
1426 if (im->internal_name
1427 && (!im->name || strcmp (im->internal_name, im->name)))
1429 quoteput (im->internal_name, out, 0);
1430 fprintf (out, " = ");
1433 quoteput (im->module->name, out, 0);
1437 quoteput (im->name, out, 0);
1439 fprintf (out, "%d", im->ordinal);
1441 fprintf (out, "\n");
1446 fprintf (out, _("; no contents available\n"));
1448 if (fclose (out) == EOF)
1449 /* xgettext:c-format */
1450 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1453 /* Generate the import library. */
1455 static asymbol **symtab;
1458 static const char *dll_filename;
1459 static char *dll_symname;
1461 #define UNDSEC (asection *) &bfd_und_section
1464 quick_section (bfd *abfd, const char *name, int flags, int align)
1469 sec = bfd_make_section_old_way (abfd, name);
1470 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1471 bfd_set_section_alignment (abfd, sec, align);
1472 /* Remember to undo this before trying to link internally! */
1473 sec->output_section = sec;
1475 sym = bfd_make_empty_symbol (abfd);
1476 symtab[symptr++] = sym;
1477 sym->name = sec->name;
1479 sym->flags = BSF_LOCAL;
1486 quick_symbol (bfd *abfd,
1495 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1500 sym = bfd_make_empty_symbol (abfd);
1505 symtab[symptr++] = sym;
1508 static arelent *reltab = 0;
1509 static int relcount = 0, relsize = 0;
1512 quick_reloc (bfd *abfd, int address, int which_howto, int symidx)
1514 if (relcount >= relsize - 1)
1518 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1520 reltab = xmalloc (relsize * sizeof (arelent));
1522 reltab[relcount].address = address;
1523 reltab[relcount].addend = 0;
1524 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1525 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1530 save_relocs (asection *sec)
1534 sec->relocation = reltab;
1535 sec->reloc_count = relcount;
1536 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1537 for (i = 0; i < relcount; i++)
1538 sec->orelocation[i] = sec->relocation + i;
1539 sec->orelocation[relcount] = 0;
1540 sec->flags |= SEC_RELOC;
1542 relcount = relsize = 0;
1545 /* .section .idata$2
1546 .global __head_my_dll
1563 make_head (bfd *parent)
1565 asection *id2, *id5, *id4;
1566 unsigned char *d2, *d5, *d4;
1570 oname = xmalloc (20);
1571 sprintf (oname, "d%06d.o", tmp_seq);
1574 abfd = bfd_create (oname, parent);
1575 bfd_find_target (pe_details->object_target, abfd);
1576 bfd_make_writable (abfd);
1578 bfd_set_format (abfd, bfd_object);
1579 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1582 symtab = xmalloc (6 * sizeof (asymbol *));
1583 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1584 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1585 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1586 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1587 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1589 /* OK, pay attention here. I got confused myself looking back at
1590 it. We create a four-byte section to mark the beginning of the
1591 list, and we include an offset of 4 in the section, so that the
1592 pointer to the list points to the *end* of this section, which is
1593 the start of the list of sections from other objects. */
1595 bfd_set_section_size (abfd, id2, 20);
1599 d2[0] = d2[16] = 4; /* Reloc addend. */
1600 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1601 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1602 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1605 bfd_set_section_size (abfd, id5, 4);
1610 bfd_set_section_size (abfd, id4, 4);
1615 bfd_set_symtab (abfd, symtab, symptr);
1617 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1618 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1619 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1621 bfd_make_readable (abfd);
1625 /* .section .idata$4
1630 .global __my_dll_iname
1635 make_tail (bfd *parent)
1637 asection *id4, *id5, *id7;
1638 unsigned char *d4, *d5, *d7;
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 (5 * sizeof (asymbol *));
1656 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1657 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1658 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1659 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1661 bfd_set_section_size (abfd, id4, 4);
1666 bfd_set_section_size (abfd, id5, 4);
1671 len = strlen (dll_filename) + 1;
1674 bfd_set_section_size (abfd, id7, len);
1677 strcpy (d7, dll_filename);
1679 bfd_set_symtab (abfd, symtab, symptr);
1681 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1682 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1683 bfd_set_section_contents (abfd, id7, d7, 0, len);
1685 bfd_make_readable (abfd);
1691 .global ___imp_function
1692 .global __imp__function
1694 jmp *__imp__function:
1708 .asciz "function" xlate? (add underscore, kill at) */
1710 static unsigned char jmp_ix86_bytes[] =
1712 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1720 .dw __imp_function */
1722 static unsigned char jmp_sh_bytes[] =
1724 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1728 lui $t0,<high:__imp_function>
1729 lw $t0,<low:__imp_function>
1733 static unsigned char jmp_mips_bytes[] =
1735 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1736 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1740 make_one (def_file_export *exp, bfd *parent)
1742 asection *tx, *id7, *id5, *id4, *id6;
1743 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1747 unsigned char *jmp_bytes = NULL;
1748 int jmp_byte_count = 0;
1750 switch (pe_details->pe_arch)
1753 jmp_bytes = jmp_ix86_bytes;
1754 jmp_byte_count = sizeof (jmp_ix86_bytes);
1757 jmp_bytes = jmp_sh_bytes;
1758 jmp_byte_count = sizeof (jmp_sh_bytes);
1761 jmp_bytes = jmp_mips_bytes;
1762 jmp_byte_count = sizeof (jmp_mips_bytes);
1768 oname = xmalloc (20);
1769 sprintf (oname, "d%06d.o", tmp_seq);
1772 abfd = bfd_create (oname, parent);
1773 bfd_find_target (pe_details->object_target, abfd);
1774 bfd_make_writable (abfd);
1776 bfd_set_format (abfd, bfd_object);
1777 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1780 symtab = xmalloc (11 * sizeof (asymbol *));
1781 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1782 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1783 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1784 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1785 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1787 if (*exp->internal_name == '@')
1789 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1791 if (! exp->flag_data)
1792 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
1793 quick_symbol (abfd, U ("_imp_"), exp->internal_name, "", id5,
1795 /* Fastcall applies only to functions,
1796 so no need for auto-import symbol. */
1800 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1802 if (! exp->flag_data)
1803 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
1805 quick_symbol (abfd, U ("_imp__"), exp->internal_name, "", id5,
1807 /* Symbol to reference ord/name of imported
1808 data symbol, used to implement auto-import. */
1810 quick_symbol (abfd, U("_nm__"), exp->internal_name, "", id6,
1813 if (pe_dll_compat_implib)
1814 quick_symbol (abfd, U ("__imp_"), exp->internal_name, "", id5,
1817 if (! exp->flag_data)
1819 bfd_set_section_size (abfd, tx, jmp_byte_count);
1820 td = xmalloc (jmp_byte_count);
1822 memcpy (td, jmp_bytes, jmp_byte_count);
1824 switch (pe_details->pe_arch)
1827 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1830 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1833 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1834 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1835 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1843 bfd_set_section_size (abfd, id7, 4);
1847 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
1850 bfd_set_section_size (abfd, id5, 4);
1855 if (exp->flag_noname)
1857 d5[0] = exp->ordinal;
1858 d5[1] = exp->ordinal >> 8;
1863 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1867 bfd_set_section_size (abfd, id4, 4);
1872 if (exp->flag_noname)
1874 d4[0] = exp->ordinal;
1875 d4[1] = exp->ordinal >> 8;
1880 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1884 if (exp->flag_noname)
1887 bfd_set_section_size (abfd, id6, 0);
1891 len = strlen (exp->name) + 3;
1894 bfd_set_section_size (abfd, id6, len);
1897 memset (d6, 0, len);
1898 d6[0] = exp->hint & 0xff;
1899 d6[1] = exp->hint >> 8;
1900 strcpy (d6 + 2, exp->name);
1903 bfd_set_symtab (abfd, symtab, symptr);
1905 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
1906 bfd_set_section_contents (abfd, id7, d7, 0, 4);
1907 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1908 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1909 if (!exp->flag_noname)
1910 bfd_set_section_contents (abfd, id6, d6, 0, len);
1912 bfd_make_readable (abfd);
1917 make_singleton_name_thunk (const char *import, bfd *parent)
1919 /* Name thunks go to idata$4. */
1925 oname = xmalloc (20);
1926 sprintf (oname, "nmth%06d.o", tmp_seq);
1929 abfd = bfd_create (oname, parent);
1930 bfd_find_target (pe_details->object_target, abfd);
1931 bfd_make_writable (abfd);
1933 bfd_set_format (abfd, bfd_object);
1934 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1937 symtab = xmalloc (3 * sizeof (asymbol *));
1938 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1939 quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
1940 quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
1942 bfd_set_section_size (abfd, id4, 8);
1946 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1949 bfd_set_symtab (abfd, symtab, symptr);
1951 bfd_set_section_contents (abfd, id4, d4, 0, 8);
1953 bfd_make_readable (abfd);
1958 make_import_fixup_mark (arelent *rel)
1960 /* We convert reloc to symbol, for later reference. */
1962 static char *fixup_name = NULL;
1963 static size_t buffer_len = 0;
1965 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
1967 bfd *abfd = bfd_asymbol_bfd (sym);
1968 struct bfd_link_hash_entry *bh;
1972 fixup_name = xmalloc (384);
1976 if (strlen (sym->name) + 25 > buffer_len)
1977 /* Assume 25 chars for "__fu" + counter + "_". If counter is
1978 bigger than 20 digits long, we've got worse problems than
1979 overflowing this buffer... */
1982 /* New buffer size is length of symbol, plus 25, but
1983 then rounded up to the nearest multiple of 128. */
1984 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
1985 fixup_name = xmalloc (buffer_len);
1988 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
1991 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
1992 current_sec, /* sym->section, */
1993 rel->address, NULL, TRUE, FALSE, &bh);
1997 struct coff_link_hash_entry *myh;
1999 myh = (struct coff_link_hash_entry *) bh;
2000 printf ("type:%d\n", myh->type);
2001 printf ("%s\n", myh->root.u.def.section->name);
2007 /* .section .idata$3
2008 .rva __nm_thnk_SYM (singleton thunk with name of func)
2011 .rva __my_dll_iname (name of dll)
2012 .rva __fuNN_SYM (pointer to reference (address) in text) */
2015 make_import_fixup_entry (const char *name,
2016 const char *fixup_name,
2017 const char *dll_symname,
2025 oname = xmalloc (20);
2026 sprintf (oname, "fu%06d.o", tmp_seq);
2029 abfd = bfd_create (oname, parent);
2030 bfd_find_target (pe_details->object_target, abfd);
2031 bfd_make_writable (abfd);
2033 bfd_set_format (abfd, bfd_object);
2034 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2037 symtab = xmalloc (6 * sizeof (asymbol *));
2038 id3 = quick_section (abfd, ".idata$3", SEC_HAS_CONTENTS, 2);
2041 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
2043 quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2044 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2045 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2047 bfd_set_section_size (abfd, id3, 20);
2052 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2053 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2054 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2057 bfd_set_symtab (abfd, symtab, symptr);
2059 bfd_set_section_contents (abfd, id3, d3, 0, 20);
2061 bfd_make_readable (abfd);
2065 /* .section .rdata_runtime_pseudo_reloc
2067 .rva __fuNN_SYM (pointer to reference (address) in text) */
2070 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2071 const char *fixup_name,
2076 unsigned char *rt_rel_d;
2080 oname = xmalloc (20);
2081 sprintf (oname, "rtr%06d.o", tmp_seq);
2084 abfd = bfd_create (oname, parent);
2085 bfd_find_target (pe_details->object_target, abfd);
2086 bfd_make_writable (abfd);
2088 bfd_set_format (abfd, bfd_object);
2089 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2092 symtab = xmalloc (2 * sizeof (asymbol *));
2093 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2094 SEC_HAS_CONTENTS, 2);
2096 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2098 bfd_set_section_size (abfd, rt_rel, 8);
2099 rt_rel_d = xmalloc (8);
2100 rt_rel->contents = rt_rel_d;
2101 memset (rt_rel_d, 0, 8);
2102 bfd_put_32 (abfd, addend, rt_rel_d);
2104 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2105 save_relocs (rt_rel);
2107 bfd_set_symtab (abfd, symtab, symptr);
2109 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2111 bfd_make_readable (abfd);
2116 .rva __pei386_runtime_relocator */
2119 pe_create_runtime_relocator_reference (bfd *parent)
2121 asection *extern_rt_rel;
2122 unsigned char *extern_rt_rel_d;
2126 oname = xmalloc (20);
2127 sprintf (oname, "ertr%06d.o", tmp_seq);
2130 abfd = bfd_create (oname, parent);
2131 bfd_find_target (pe_details->object_target, abfd);
2132 bfd_make_writable (abfd);
2134 bfd_set_format (abfd, bfd_object);
2135 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2138 symtab = xmalloc (2 * sizeof (asymbol *));
2139 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2141 quick_symbol (abfd, "", "__pei386_runtime_relocator", "", UNDSEC,
2144 bfd_set_section_size (abfd, extern_rt_rel, 4);
2145 extern_rt_rel_d = xmalloc (4);
2146 extern_rt_rel->contents = extern_rt_rel_d;
2148 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2149 save_relocs (extern_rt_rel);
2151 bfd_set_symtab (abfd, symtab, symptr);
2153 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
2155 bfd_make_readable (abfd);
2160 pe_create_import_fixup (arelent *rel, asection *s, int addend)
2163 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2164 struct bfd_link_hash_entry *name_thunk_sym;
2165 const char *name = sym->name;
2166 char *fixup_name = make_import_fixup_mark (rel);
2169 sprintf (buf, U ("_nm_thnk_%s"), name);
2171 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2173 if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2175 bfd *b = make_singleton_name_thunk (name, output_bfd);
2176 add_bfd_to_link (b, b->filename, &link_info);
2178 /* If we ever use autoimport, we have to cast text section writable. */
2179 config.text_read_only = FALSE;
2180 output_bfd->flags &= ~WP_TEXT;
2183 if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2185 extern char * pe_data_import_dll;
2186 char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2188 b = make_import_fixup_entry (name, fixup_name, dll_symname, output_bfd);
2189 add_bfd_to_link (b, b->filename, &link_info);
2194 if (link_info.pei386_runtime_pseudo_reloc)
2196 if (pe_dll_extra_pe_debug)
2197 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2198 fixup_name, addend);
2199 b = make_runtime_pseudo_reloc (name, fixup_name, addend, output_bfd);
2200 add_bfd_to_link (b, b->filename, &link_info);
2202 if (runtime_pseudo_relocs_created == 0)
2204 b = pe_create_runtime_relocator_reference (output_bfd);
2205 add_bfd_to_link (b, b->filename, &link_info);
2207 runtime_pseudo_relocs_created++;
2211 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2212 s->owner, s, rel->address, sym->name);
2220 pe_dll_generate_implib (def_file *def, const char *impfilename)
2228 dll_filename = (def->name) ? def->name : dll_name;
2229 dll_symname = xstrdup (dll_filename);
2230 for (i = 0; dll_symname[i]; i++)
2231 if (!ISALNUM (dll_symname[i]))
2232 dll_symname[i] = '_';
2234 unlink (impfilename);
2236 outarch = bfd_openw (impfilename, 0);
2240 /* xgettext:c-format */
2241 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2245 /* xgettext:c-format */
2246 einfo (_("Creating library file: %s\n"), impfilename);
2248 bfd_set_format (outarch, bfd_archive);
2249 outarch->has_armap = 1;
2251 /* Work out a reasonable size of things to put onto one line. */
2252 ar_head = make_head (outarch);
2254 for (i = 0; i < def->num_exports; i++)
2256 /* The import library doesn't know about the internal name. */
2257 char *internal = def->exports[i].internal_name;
2260 /* Don't add PRIVATE entries to import lib. */
2261 if (pe_def_file->exports[i].flag_private)
2263 def->exports[i].internal_name = def->exports[i].name;
2264 n = make_one (def->exports + i, outarch);
2267 def->exports[i].internal_name = internal;
2270 ar_tail = make_tail (outarch);
2272 if (ar_head == NULL || ar_tail == NULL)
2275 /* Now stick them all into the archive. */
2276 ar_head->next = head;
2277 ar_tail->next = ar_head;
2280 if (! bfd_set_archive_head (outarch, head))
2281 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
2283 if (! bfd_close (outarch))
2284 einfo ("%Xbfd_close %s: %s\n", impfilename, bfd_errmsg (bfd_get_error ()));
2286 while (head != NULL)
2288 bfd *n = head->next;
2295 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *link_info)
2297 lang_input_statement_type *fake_file;
2299 fake_file = lang_add_input_file (name,
2300 lang_input_file_is_fake_enum,
2302 fake_file->the_bfd = abfd;
2303 ldlang_add_file (fake_file);
2305 if (!bfd_link_add_symbols (abfd, link_info))
2306 einfo ("%Xaddsym %s: %s\n", name, bfd_errmsg (bfd_get_error ()));
2310 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *link_info)
2312 def_file_module *module;
2314 pe_dll_id_target (bfd_get_target (output_bfd));
2319 for (module = pe_def_file->modules; module; module = module->next)
2323 dll_filename = module->name;
2324 dll_symname = xstrdup (module->name);
2325 for (i = 0; dll_symname[i]; i++)
2326 if (!ISALNUM (dll_symname[i]))
2327 dll_symname[i] = '_';
2331 for (i = 0; i < pe_def_file->num_imports; i++)
2332 if (pe_def_file->imports[i].module == module)
2334 def_file_export exp;
2335 struct bfd_link_hash_entry *blhe;
2336 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2337 /* See if we need this import. */
2338 size_t len = strlen (pe_def_file->imports[i].internal_name);
2339 char *name = xmalloc (len + 2 + 6);
2342 sprintf (name, "%s%s", "",
2343 pe_def_file->imports[i].internal_name);
2345 sprintf (name, "%s%s",U (""),
2346 pe_def_file->imports[i].internal_name);
2348 blhe = bfd_link_hash_lookup (link_info->hash, name,
2349 FALSE, FALSE, FALSE);
2351 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2354 sprintf (name, "%s%s", U ("_imp_"),
2355 pe_def_file->imports[i].internal_name);
2357 sprintf (name, "%s%s", U ("_imp__"),
2358 pe_def_file->imports[i].internal_name);
2360 blhe = bfd_link_hash_lookup (link_info->hash, name,
2361 FALSE, FALSE, FALSE);
2365 if (blhe && blhe->type == bfd_link_hash_undefined)
2371 bfd *ar_head = make_head (output_bfd);
2372 add_bfd_to_link (ar_head, ar_head->filename, link_info);
2375 exp.internal_name = pe_def_file->imports[i].internal_name;
2376 exp.name = pe_def_file->imports[i].name;
2377 exp.ordinal = pe_def_file->imports[i].ordinal;
2378 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2379 exp.flag_private = 0;
2380 exp.flag_constant = 0;
2381 exp.flag_data = pe_def_file->imports[i].data;
2382 exp.flag_noname = exp.name ? 0 : 1;
2383 one = make_one (&exp, output_bfd);
2384 add_bfd_to_link (one, one->filename, link_info);
2389 bfd *ar_tail = make_tail (output_bfd);
2390 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2397 /* We were handed a *.DLL file. Parse it and turn it into a set of
2398 IMPORTS directives in the def file. Return TRUE if the file was
2399 handled, FALSE if not. */
2402 pe_get16 (bfd *abfd, int where)
2406 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2407 bfd_bread (b, (bfd_size_type) 2, abfd);
2408 return b[0] + (b[1] << 8);
2412 pe_get32 (bfd *abfd, int where)
2416 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2417 bfd_bread (b, (bfd_size_type) 4, abfd);
2418 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2421 #if 0 /* This is not currently used. */
2426 unsigned char *b = ptr;
2428 return b[0] + (b[1] << 8);
2436 unsigned char *b = ptr;
2438 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2442 pe_implied_import_dll (const char *filename)
2445 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
2446 unsigned long export_rva, export_size, nsections, secptr, expptr;
2447 unsigned long exp_funcbase;
2448 unsigned char *expdata, *erva;
2449 unsigned long name_rvas, ordinals, nexp, ordbase;
2450 const char *dll_name;
2451 /* Initialization with start > end guarantees that is_data
2452 will not be set by mistake, and avoids compiler warning. */
2453 unsigned long data_start = 1;
2454 unsigned long data_end = 0;
2455 unsigned long rdata_start = 1;
2456 unsigned long rdata_end = 0;
2457 unsigned long bss_start = 1;
2458 unsigned long bss_end = 0;
2460 /* No, I can't use bfd here. kernel32.dll puts its export table in
2461 the middle of the .rdata section. */
2462 dll = bfd_openr (filename, pe_details->target_name);
2465 einfo ("%Xopen %s: %s\n", filename, bfd_errmsg (bfd_get_error ()));
2469 /* PEI dlls seem to be bfd_objects. */
2470 if (!bfd_check_format (dll, bfd_object))
2472 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2476 /* Get pe_header, optional header and numbers of export entries. */
2477 pe_header_offset = pe_get32 (dll, 0x3c);
2478 opthdr_ofs = pe_header_offset + 4 + 20;
2479 num_entries = pe_get32 (dll, opthdr_ofs + 92);
2481 if (num_entries < 1) /* No exports. */
2484 export_rva = pe_get32 (dll, opthdr_ofs + 96);
2485 export_size = pe_get32 (dll, opthdr_ofs + 100);
2486 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2487 secptr = (pe_header_offset + 4 + 20 +
2488 pe_get16 (dll, pe_header_offset + 4 + 16));
2491 /* Get the rva and size of the export section. */
2492 for (i = 0; i < nsections; i++)
2495 unsigned long secptr1 = secptr + 40 * i;
2496 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2497 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
2498 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
2500 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2501 bfd_bread (sname, (bfd_size_type) 8, dll);
2503 if (vaddr <= export_rva && vaddr + vsize > export_rva)
2505 expptr = fptr + (export_rva - vaddr);
2506 if (export_rva + export_size > vaddr + vsize)
2507 export_size = vsize - (export_rva - vaddr);
2512 /* Scan sections and store the base and size of the
2513 data and bss segments in data/base_start/end. */
2514 for (i = 0; i < nsections; i++)
2516 unsigned long secptr1 = secptr + 40 * i;
2517 unsigned long vsize = pe_get32 (dll, secptr1 + 8);
2518 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2519 unsigned long flags = pe_get32 (dll, secptr1 + 36);
2523 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
2524 bfd_bread (sec_name, (bfd_size_type) 8, dll);
2526 if (strcmp(sec_name,".data") == 0)
2529 data_end = vaddr + vsize;
2531 if (pe_dll_extra_pe_debug)
2532 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2533 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2535 else if (strcmp(sec_name,".rdata") == 0)
2537 rdata_start = vaddr;
2538 rdata_end = vaddr + vsize;
2540 if (pe_dll_extra_pe_debug)
2541 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2542 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2544 else if (strcmp (sec_name,".bss") == 0)
2547 bss_end = vaddr + vsize;
2549 if (pe_dll_extra_pe_debug)
2550 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2551 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2555 expdata = xmalloc (export_size);
2556 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2557 bfd_bread (expdata, (bfd_size_type) export_size, dll);
2558 erva = expdata - export_rva;
2560 if (pe_def_file == 0)
2561 pe_def_file = def_file_empty ();
2563 nexp = pe_as32 (expdata + 24);
2564 name_rvas = pe_as32 (expdata + 32);
2565 ordinals = pe_as32 (expdata + 36);
2566 ordbase = pe_as32 (expdata + 16);
2567 exp_funcbase = pe_as32 (expdata + 28);
2569 /* Use internal dll name instead of filename
2570 to enable symbolic dll linking. */
2571 dll_name = pe_as32 (expdata + 12) + erva;
2573 /* Check to see if the dll has already been added to
2574 the definition list and if so return without error.
2575 This avoids multiple symbol definitions. */
2576 if (def_get_module (pe_def_file, dll_name))
2578 if (pe_dll_extra_pe_debug)
2579 printf ("%s is already loaded\n", dll_name);
2583 /* Iterate through the list of symbols. */
2584 for (i = 0; i < nexp; i++)
2586 /* Pointer to the names vector. */
2587 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
2588 def_file_import *imp;
2589 /* Pointer to the function address vector. */
2590 unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
2593 /* Skip unwanted symbols, which are
2594 exported in buggy auto-import releases. */
2595 if (strncmp (erva + name_rva, "_nm_", 4) != 0)
2597 /* is_data is true if the address is in the data, rdata or bss
2600 (func_rva >= data_start && func_rva < data_end)
2601 || (func_rva >= rdata_start && func_rva < rdata_end)
2602 || (func_rva >= bss_start && func_rva < bss_end);
2604 imp = def_file_add_import (pe_def_file, erva + name_rva,
2606 /* Mark symbol type. */
2607 imp->data = is_data;
2609 if (pe_dll_extra_pe_debug)
2610 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2611 __FUNCTION__, dll_name, erva + name_rva,
2612 func_rva, is_data ? "(data)" : "");
2619 /* These are the main functions, called from the emulation. The first
2620 is called after the bfds are read, so we can guess at how much space
2621 we need. The second is called after everything is placed, so we
2622 can put the right values in place. */
2625 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
2627 pe_dll_id_target (bfd_get_target (abfd));
2628 process_def_file (abfd, info);
2630 if (pe_def_file->num_exports == 0 && !info->shared)
2633 generate_edata (abfd, info);
2634 build_filler_bfd (1);
2638 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2640 pe_dll_id_target (bfd_get_target (abfd));
2641 build_filler_bfd (0);
2645 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
2647 pe_dll_id_target (bfd_get_target (abfd));
2648 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2650 generate_reloc (abfd, info);
2653 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2655 /* Resize the sections. */
2656 lang_size_sections (stat_ptr->head, abs_output_section,
2657 &stat_ptr->head, 0, 0, NULL, TRUE);
2659 /* Redo special stuff. */
2660 ldemul_after_allocation ();
2662 /* Do the assignments again. */
2663 lang_do_assignments (stat_ptr->head, abs_output_section, NULL, 0);
2666 fill_edata (abfd, info);
2669 pe_data (abfd)->dll = 1;
2671 edata_s->contents = edata_d;
2672 reloc_s->contents = reloc_d;
2676 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
2678 pe_dll_id_target (bfd_get_target (abfd));
2679 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2681 generate_reloc (abfd, info);
2684 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2686 /* Resize the sections. */
2687 lang_size_sections (stat_ptr->head, abs_output_section,
2688 &stat_ptr->head, 0, 0, NULL, TRUE);
2690 /* Redo special stuff. */
2691 ldemul_after_allocation ();
2693 /* Do the assignments again. */
2694 lang_do_assignments (stat_ptr->head, abs_output_section, NULL, 0);
2696 reloc_s->contents = reloc_d;