1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998, 1999, 2000 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"
39 #include "coff/internal.h"
40 #include "../bfd/libcoff.h"
44 /************************************************************************
46 This file turns a regular Windows PE image into a DLL. Because of
47 the complexity of this operation, it has been broken down into a
48 number of separate modules which are all called by the main function
49 at the end of this file. This function is not re-entrant and is
50 normally only called once, so static variables are used to reduce
51 the number of parameters and return values required.
53 See also: ld/emultempl/pe.em
55 ************************************************************************/
57 /* for emultempl/pe.em */
59 def_file *pe_def_file = 0;
60 int pe_dll_export_everything = 0;
61 int pe_dll_do_default_excludes = 1;
62 int pe_dll_kill_ats = 0;
63 int pe_dll_stdcall_aliases = 0;
64 int pe_dll_warn_dup_exports = 0;
65 int pe_dll_compat_implib = 0;
67 /************************************************************************
69 static variables and types
71 ************************************************************************/
73 static bfd_vma image_base;
75 static bfd *filler_bfd;
76 static struct sec *edata_s, *reloc_s;
77 static unsigned char *edata_d, *reloc_d;
78 static size_t edata_sz, reloc_sz;
83 unsigned int imagebase_reloc;
89 #define PE_ARCH_i386 1
91 #define PE_ARCH_mips 3
94 static pe_details_type pe_detail_list[] = {
106 16 /* R_SH_IMAGEBASE */,
127 { NULL, NULL, 0, 0, 0, 0 }
130 static pe_details_type *pe_details;
132 #define U(str) (pe_details->underscored ? "_" str : str)
135 pe_dll_id_target (target)
139 for (i=0; pe_detail_list[i].target_name; i++)
140 if (strcmp (pe_detail_list[i].target_name, target) == 0)
142 pe_details = pe_detail_list+i;
145 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
149 /************************************************************************
151 Helper functions for qsort. Relocs must be sorted so that we can write
154 ************************************************************************/
166 bfd_vma a = ((reloc_data_type *) va)->vma;
167 bfd_vma b = ((reloc_data_type *) vb)->vma;
168 return (a > b) ? 1 : ((a < b) ? -1 : 0);
172 pe_export_sort (va, vb)
175 def_file_export *a = (def_file_export *) va;
176 def_file_export *b = (def_file_export *) vb;
177 return strcmp (a->name, b->name);
180 /************************************************************************
182 Read and process the .DEF file
184 ************************************************************************/
186 /* These correspond to the entries in pe_def_file->exports[]. I use
187 exported_symbol_sections[i] to tag whether or not the symbol was
188 defined, since we can't export symbols we don't have. */
190 static bfd_vma *exported_symbol_offsets;
191 static struct sec **exported_symbol_sections;
193 static int export_table_size;
194 static int count_exported;
195 static int count_exported_byname;
196 static int count_with_ordinals;
197 static const char *dll_name;
198 static int min_ordinal, max_ordinal;
199 static int *exported_symbols;
201 typedef struct exclude_list_struct
204 struct exclude_list_struct *next;
207 static struct exclude_list_struct *excludes = 0;
210 pe_dll_add_excludes (new_excludes)
211 const char *new_excludes;
214 char *exclude_string;
216 local_copy = xstrdup (new_excludes);
218 exclude_string = strtok (local_copy, ",:");
219 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
221 struct exclude_list_struct *new_exclude;
223 new_exclude = ((struct exclude_list_struct *)
224 xmalloc (sizeof (struct exclude_list_struct)));
225 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 1);
226 strcpy (new_exclude->string, exclude_string);
227 new_exclude->next = excludes;
228 excludes = new_exclude;
240 struct exclude_list_struct *ex;
241 for (i = 0; i < d->num_exports; i++)
242 if (strcmp (d->exports[i].name, n) == 0)
244 if (pe_dll_do_default_excludes)
246 if (strcmp (n, "DllMain@12") == 0)
248 if (strcmp (n, "DllEntryPoint@0") == 0)
250 if (strcmp (n, "impure_ptr") == 0)
253 for (ex = excludes; ex; ex = ex->next)
254 if (strcmp (n, ex->string) == 0)
260 process_def_file (abfd, info)
261 bfd *abfd ATTRIBUTE_UNUSED;
262 struct bfd_link_info *info;
265 struct bfd_link_hash_entry *blhe;
268 def_file_export *e=0;
271 pe_def_file = def_file_empty ();
273 /* First, run around to all the objects looking for the .drectve
274 sections, and push those into the def file too */
276 for (b = info->input_bfds; b; b = b->link_next)
278 s = bfd_get_section_by_name (b, ".drectve");
281 int size = bfd_get_section_size_before_reloc (s);
282 char *buf = xmalloc (size);
283 bfd_get_section_contents (b, s, buf, 0, size);
284 def_file_add_directive (pe_def_file, buf, size);
289 /* Now, maybe export everything else the default way */
291 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
293 for (b = info->input_bfds; b; b = b->link_next)
298 symsize = bfd_get_symtab_upper_bound (b);
299 symbols = (asymbol **) xmalloc (symsize);
300 nsyms = bfd_canonicalize_symtab (b, symbols);
302 for (j = 0; j < nsyms; j++)
304 if ((symbols[j]->flags & (BSF_FUNCTION | BSF_GLOBAL))
305 == (BSF_FUNCTION | BSF_GLOBAL))
307 const char *sn = symbols[j]->name;
310 if (auto_export (pe_def_file, sn))
311 def_file_add_export (pe_def_file, sn, 0, -1);
318 #define NE pe_def_file->num_exports
320 /* Canonicalize the export list */
324 for (i = 0; i < NE; i++)
326 if (strchr (pe_def_file->exports[i].name, '@'))
328 /* This will preserve internal_name, which may have been pointing
329 to the same memory as name, or might not have */
330 char *tmp = xstrdup (pe_def_file->exports[i].name);
331 *(strchr (tmp, '@')) = 0;
332 pe_def_file->exports[i].name = tmp;
337 if (pe_dll_stdcall_aliases)
339 for (i = 0; i < NE; i++)
341 if (strchr (pe_def_file->exports[i].name, '@'))
343 char *tmp = xstrdup (pe_def_file->exports[i].name);
344 *(strchr (tmp, '@')) = 0;
345 if (auto_export (pe_def_file, tmp))
346 def_file_add_export (pe_def_file, tmp,
347 pe_def_file->exports[i].internal_name, -1);
354 e = pe_def_file->exports; /* convenience, but watch out for it changing */
356 exported_symbol_offsets = (bfd_vma *) xmalloc (NE * sizeof (bfd_vma));
357 exported_symbol_sections = (struct sec **) xmalloc (NE * sizeof (struct sec *));
359 memset (exported_symbol_sections, 0, NE * sizeof (struct sec *));
363 count_exported_byname = 0;
364 count_with_ordinals = 0;
366 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]), pe_export_sort);
367 for (i = 0, j = 0; i < NE; i++)
369 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
371 /* This is a duplicate. */
372 if (e[j - 1].ordinal != -1
373 && e[i].ordinal != -1
374 && e[j - 1].ordinal != e[i].ordinal)
376 if (pe_dll_warn_dup_exports)
377 /* xgettext:c-format */
378 einfo (_("%XError, duplicate EXPORT with oridinals: %s (%d vs %d)\n"),
379 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
383 if (pe_dll_warn_dup_exports)
384 /* xgettext:c-format */
385 einfo (_("Warning, duplicate EXPORT: %s\n"),
389 e[j - 1].ordinal = e[i].ordinal;
390 e[j - 1].flag_private |= e[i].flag_private;
391 e[j - 1].flag_constant |= e[i].flag_constant;
392 e[j - 1].flag_noname |= e[i].flag_noname;
393 e[j - 1].flag_data |= e[i].flag_data;
402 pe_def_file->num_exports = j; /* == NE */
404 for (i = 0; i < NE; i++)
406 char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
407 if (pe_details->underscored)
410 strcpy (name + 1, pe_def_file->exports[i].internal_name);
413 strcpy (name, pe_def_file->exports[i].internal_name);
415 blhe = bfd_link_hash_lookup (info->hash,
420 && (blhe->type == bfd_link_hash_defined
421 || (blhe->type == bfd_link_hash_common)))
424 if (!pe_def_file->exports[i].flag_noname)
425 count_exported_byname++;
427 /* Only fill in the sections. The actual offsets are computed
428 in fill_exported_offsets() after common symbols are laid
430 if (blhe->type == bfd_link_hash_defined)
431 exported_symbol_sections[i] = blhe->u.def.section;
433 exported_symbol_sections[i] = blhe->u.c.p->section;
435 if (pe_def_file->exports[i].ordinal != -1)
437 if (max_ordinal < pe_def_file->exports[i].ordinal)
438 max_ordinal = pe_def_file->exports[i].ordinal;
439 if (min_ordinal > pe_def_file->exports[i].ordinal)
440 min_ordinal = pe_def_file->exports[i].ordinal;
441 count_with_ordinals++;
444 else if (blhe && blhe->type == bfd_link_hash_undefined)
446 /* xgettext:c-format */
447 einfo (_("%XCannot export %s: symbol not defined\n"),
448 pe_def_file->exports[i].internal_name);
452 /* xgettext:c-format */
453 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
454 pe_def_file->exports[i].internal_name,
455 blhe->type, bfd_link_hash_defined);
459 /* xgettext:c-format */
460 einfo (_("%XCannot export %s: symbol not found\n"),
461 pe_def_file->exports[i].internal_name);
467 /************************************************************************
469 Build the bfd that will contain .edata and .reloc sections
471 ************************************************************************/
474 build_filler_bfd (include_edata)
477 lang_input_statement_type *filler_file;
478 filler_file = lang_add_input_file ("dll stuff",
479 lang_input_file_is_fake_enum,
481 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
482 if (filler_bfd == NULL
483 || !bfd_set_arch_mach (filler_bfd,
484 bfd_get_arch (output_bfd),
485 bfd_get_mach (output_bfd)))
487 einfo ("%X%P: can not create BFD %E\n");
493 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
495 || !bfd_set_section_flags (filler_bfd, edata_s,
502 einfo ("%X%P: can not create .edata section: %E\n");
505 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
508 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
510 || !bfd_set_section_flags (filler_bfd, reloc_s,
517 einfo ("%X%P: can not create .reloc section: %E\n");
520 bfd_set_section_size (filler_bfd, reloc_s, 0);
522 ldlang_add_file (filler_file);
525 /************************************************************************
527 Gather all the exported symbols and build the .edata section
529 ************************************************************************/
532 generate_edata (abfd, info)
534 struct bfd_link_info *info ATTRIBUTE_UNUSED;
537 int name_table_size = 0;
540 /* First, we need to know how many exported symbols there are,
541 and what the range of ordinals is. */
543 if (pe_def_file->name)
545 dll_name = pe_def_file->name;
549 dll_name = abfd->filename;
550 for (dlnp = dll_name; *dlnp; dlnp++)
552 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
557 if (count_with_ordinals && max_ordinal > count_exported)
559 if (min_ordinal > max_ordinal - count_exported + 1)
560 min_ordinal = max_ordinal - count_exported + 1;
565 max_ordinal = count_exported;
567 export_table_size = max_ordinal - min_ordinal + 1;
569 exported_symbols = (int *) xmalloc (export_table_size * sizeof (int));
570 for (i = 0; i < export_table_size; i++)
571 exported_symbols[i] = -1;
573 /* Now we need to assign ordinals to those that don't have them */
574 for (i = 0; i < NE; i++)
576 if (exported_symbol_sections[i])
578 if (pe_def_file->exports[i].ordinal != -1)
580 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
581 int pi = exported_symbols[ei];
584 /* xgettext:c-format */
585 einfo (_("%XError, oridinal used twice: %d (%s vs %s)\n"),
586 pe_def_file->exports[i].ordinal,
587 pe_def_file->exports[i].name,
588 pe_def_file->exports[pi].name);
590 exported_symbols[ei] = i;
592 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
596 next_ordinal = min_ordinal;
597 for (i = 0; i < NE; i++)
598 if (exported_symbol_sections[i])
599 if (pe_def_file->exports[i].ordinal == -1)
601 while (exported_symbols[next_ordinal - min_ordinal] != -1)
603 exported_symbols[next_ordinal - min_ordinal] = i;
604 pe_def_file->exports[i].ordinal = next_ordinal;
607 /* OK, now we can allocate some memory */
609 edata_sz = (40 /* directory */
610 + 4 * export_table_size /* addresses */
611 + 4 * count_exported_byname /* name ptrs */
612 + 2 * count_exported_byname /* ordinals */
613 + name_table_size + strlen (dll_name) + 1);
616 /* Fill the exported symbol offsets. The preliminary work has already
617 been done in process_def_file(). */
620 fill_exported_offsets (abfd, info)
621 bfd *abfd ATTRIBUTE_UNUSED;
622 struct bfd_link_info *info;
625 struct bfd_link_hash_entry *blhe;
627 for (i = 0; i < pe_def_file->num_exports; i++)
629 char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
630 if (pe_details->underscored)
633 strcpy (name + 1, pe_def_file->exports[i].internal_name);
636 strcpy (name, pe_def_file->exports[i].internal_name);
638 blhe = bfd_link_hash_lookup (info->hash,
642 if (blhe && (blhe->type == bfd_link_hash_defined))
644 exported_symbol_offsets[i] = blhe->u.def.value;
651 fill_edata (abfd, info)
653 struct bfd_link_info *info ATTRIBUTE_UNUSED;
656 unsigned char *edirectory;
657 unsigned long *eaddresses;
658 unsigned long *enameptrs;
659 unsigned short *eordinals;
660 unsigned char *enamestr;
665 edata_d = (unsigned char *) xmalloc (edata_sz);
667 /* Note use of array pointer math here */
668 edirectory = edata_d;
669 eaddresses = (unsigned long *) (edata_d + 40);
670 enameptrs = eaddresses + export_table_size;
671 eordinals = (unsigned short *) (enameptrs + count_exported_byname);
672 enamestr = (char *) (eordinals + count_exported_byname);
674 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
676 memset (edata_d, 0, 40);
677 bfd_put_32 (abfd, now, edata_d + 4);
678 if (pe_def_file->version_major != -1)
680 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
681 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
683 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
684 strcpy (enamestr, dll_name);
685 enamestr += strlen (enamestr) + 1;
686 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
687 bfd_put_32 (abfd, export_table_size, edata_d + 20);
688 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
689 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
690 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
691 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
693 fill_exported_offsets (abfd, info);
695 /* Ok, now for the filling in part */
697 for (i = 0; i < export_table_size; i++)
699 int s = exported_symbols[i];
702 struct sec *ssec = exported_symbol_sections[s];
703 unsigned long srva = (exported_symbol_offsets[s]
704 + ssec->output_section->vma
705 + ssec->output_offset);
707 bfd_put_32 (abfd, srva - image_base, (void *) (eaddresses + i));
708 if (!pe_def_file->exports[s].flag_noname)
710 char *ename = pe_def_file->exports[s].name;
711 bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs);
712 strcpy (enamestr, ename);
713 enamestr += strlen (enamestr) + 1;
714 bfd_put_16 (abfd, i, (void *) eordinals);
716 pe_def_file->exports[s].hint = hint++;
723 /************************************************************************
725 Gather all the relocations and build the .reloc section
727 ************************************************************************/
730 generate_reloc (abfd, info)
732 struct bfd_link_info *info;
735 /* for .reloc stuff */
736 reloc_data_type *reloc_data;
737 int total_relocs = 0;
739 unsigned long sec_page = (unsigned long) (-1);
740 unsigned long page_ptr, page_count;
746 for (b = info->input_bfds; b; b = b->link_next)
747 for (s = b->sections; s; s = s->next)
748 total_relocs += s->reloc_count;
750 reloc_data = (reloc_data_type *) xmalloc (total_relocs * sizeof (reloc_data_type));
754 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
757 int relsize, nrelocs, i;
759 for (s = b->sections; s; s = s->next)
761 unsigned long sec_vma = s->output_section->vma + s->output_offset;
765 /* if it's not loaded, we don't need to relocate it this way */
766 if (!(s->output_section->flags & SEC_LOAD))
769 /* I don't know why there would be a reloc for these, but I've
770 seen it happen - DJ */
771 if (s->output_section == &bfd_abs_section)
774 if (s->output_section->vma == 0)
776 /* Huh? Shouldn't happen, but punt if it does */
777 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
778 s->output_section->name, s->output_section->index,
779 s->output_section->flags);
783 symsize = bfd_get_symtab_upper_bound (b);
784 symbols = (asymbol **) xmalloc (symsize);
785 nsyms = bfd_canonicalize_symtab (b, symbols);
787 relsize = bfd_get_reloc_upper_bound (b, s);
788 relocs = (arelent **) xmalloc ((size_t) relsize);
789 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
791 for (i = 0; i < nrelocs; i++)
793 if (!relocs[i]->howto->pc_relative
794 && relocs[i]->howto->type != pe_details->imagebase_reloc)
797 struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
798 sym_vma = (relocs[i]->addend
801 + sym->section->output_offset
802 + sym->section->output_section->vma);
803 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
805 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
807 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
808 relocs[i]->howto->rightshift)
810 case BITS_AND_SHIFT (32, 0):
811 reloc_data[total_relocs].type = 3;
814 case BITS_AND_SHIFT (16, 0):
815 reloc_data[total_relocs].type = 2;
818 case BITS_AND_SHIFT (16, 16):
819 reloc_data[total_relocs].type = 4;
820 /* FIXME: we can't know the symbol's right value yet,
821 but we probably can safely assume that CE will relocate
822 us in 64k blocks, so leaving it zero is safe. */
823 reloc_data[total_relocs].extra = 0;
826 case BITS_AND_SHIFT (26, 2):
827 reloc_data[total_relocs].type = 5;
831 /* xgettext:c-format */
832 einfo (_("%XError: %d-bit reloc in dll\n"),
833 relocs[i]->howto->bitsize);
839 /* Warning: the allocated symbols are remembered in BFD and reused
840 later, so don't free them! */
841 /* free (symbols); */
845 /* At this point, we have total_relocs relocation addresses in
846 reloc_addresses, which are all suitable for the .reloc section.
847 We must now create the new sections. */
849 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
851 for (i = 0; i < total_relocs; i++)
853 unsigned long this_page = (reloc_data[i].vma >> 12);
855 if (this_page != sec_page)
857 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align */
859 sec_page = this_page;
864 if (reloc_data[i].type == 4)
867 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align */
869 reloc_d = (unsigned char *) xmalloc (reloc_sz);
871 sec_page = (unsigned long) (-1);
873 page_ptr = (unsigned long) (-1);
875 for (i = 0; i < total_relocs; i++)
877 unsigned long rva = reloc_data[i].vma - image_base;
878 unsigned long this_page = (rva & ~0xfff);
879 if (this_page != sec_page)
882 reloc_d[reloc_sz++] = 0;
883 if (page_ptr != (unsigned long) (-1))
884 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
885 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
888 sec_page = this_page;
891 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type<<12),
894 if (reloc_data[i].type == 4)
896 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
902 reloc_d[reloc_sz++] = 0;
903 if (page_ptr != (unsigned long) (-1))
904 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
905 while (reloc_sz < reloc_s->_raw_size)
906 reloc_d[reloc_sz++] = 0;
909 /************************************************************************
911 Given the exiting def_file structure, print out a .DEF file that
914 ************************************************************************/
917 quoteput (s, f, needs_quotes)
923 for (cp = s; *cp; cp++)
927 || isspace ((unsigned char) *cp)
936 if (*s == '"' || *s == '\\')
948 pe_dll_generate_def_file (pe_out_def_filename)
949 const char *pe_out_def_filename;
952 FILE *out = fopen (pe_out_def_filename, "w");
955 /* xgettext:c-format */
956 einfo (_("%s: Can't open output def file %s\n"),
957 program_name, pe_out_def_filename);
962 if (pe_def_file->name)
964 if (pe_def_file->is_dll)
965 fprintf (out, "LIBRARY ");
967 fprintf (out, "NAME ");
968 quoteput (pe_def_file->name, out, 1);
969 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
970 fprintf (out, " BASE=0x%lx",
971 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
975 if (pe_def_file->description)
977 fprintf (out, "DESCRIPTION ");
978 quoteput (pe_def_file->description, out, 1);
982 if (pe_def_file->version_minor != -1)
983 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
984 pe_def_file->version_minor);
985 else if (pe_def_file->version_major != -1)
986 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
988 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
991 if (pe_def_file->stack_commit != -1)
992 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
993 pe_def_file->stack_reserve, pe_def_file->stack_commit);
994 else if (pe_def_file->stack_reserve != -1)
995 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
996 if (pe_def_file->heap_commit != -1)
997 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
998 pe_def_file->heap_reserve, pe_def_file->heap_commit);
999 else if (pe_def_file->heap_reserve != -1)
1000 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1002 if (pe_def_file->num_section_defs > 0)
1004 fprintf (out, "\nSECTIONS\n\n");
1005 for (i = 0; i < pe_def_file->num_section_defs; i++)
1008 quoteput (pe_def_file->section_defs[i].name, out, 0);
1009 if (pe_def_file->section_defs[i].class)
1011 fprintf (out, " CLASS ");
1012 quoteput (pe_def_file->section_defs[i].class, out, 0);
1014 if (pe_def_file->section_defs[i].flag_read)
1015 fprintf (out, " READ");
1016 if (pe_def_file->section_defs[i].flag_write)
1017 fprintf (out, " WRITE");
1018 if (pe_def_file->section_defs[i].flag_execute)
1019 fprintf (out, " EXECUTE");
1020 if (pe_def_file->section_defs[i].flag_shared)
1021 fprintf (out, " SHARED");
1022 fprintf (out, "\n");
1026 if (pe_def_file->num_exports > 0)
1028 fprintf (out, "\nEXPORTS\n\n");
1029 for (i = 0; i < pe_def_file->num_exports; i++)
1031 def_file_export *e = pe_def_file->exports + i;
1033 quoteput (e->name, out, 0);
1034 if (e->internal_name && strcmp (e->internal_name, e->name))
1036 fprintf (out, " = ");
1037 quoteput (e->internal_name, out, 0);
1039 if (e->ordinal != -1)
1040 fprintf (out, " @%d", e->ordinal);
1041 if (e->flag_private)
1042 fprintf (out, " PRIVATE");
1043 if (e->flag_constant)
1044 fprintf (out, " CONSTANT");
1046 fprintf (out, " NONAME");
1048 fprintf (out, " DATA");
1050 fprintf (out, "\n");
1054 if (pe_def_file->num_imports > 0)
1056 fprintf (out, "\nIMPORTS\n\n");
1057 for (i = 0; i < pe_def_file->num_imports; i++)
1059 def_file_import *im = pe_def_file->imports + i;
1061 if (im->internal_name
1062 && (!im->name || strcmp (im->internal_name, im->name)))
1064 quoteput (im->internal_name, out, 0);
1065 fprintf (out, " = ");
1067 quoteput (im->module->name, out, 0);
1070 quoteput (im->name, out, 0);
1072 fprintf (out, "%d", im->ordinal);
1073 fprintf (out, "\n");
1078 fprintf (out, _("; no contents available\n"));
1080 if (fclose (out) == EOF)
1082 /* xgettext:c-format */
1083 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1087 /************************************************************************
1089 Generate the import library
1091 ************************************************************************/
1093 static asymbol **symtab;
1096 static const char *dll_filename;
1097 static char *dll_symname;
1099 #define UNDSEC (asection *) &bfd_und_section
1102 quick_section(abfd, name, flags, align)
1111 sec = bfd_make_section_old_way (abfd, name);
1112 bfd_set_section_flags (abfd, sec, flags
1117 bfd_set_section_alignment (abfd, sec, align);
1118 /* remember to undo this before trying to link internally! */
1119 sec->output_section = sec;
1121 sym = bfd_make_empty_symbol (abfd);
1122 symtab[symptr++] = sym;
1123 sym->name = sec->name;
1125 sym->flags = BSF_LOCAL;
1132 quick_symbol (abfd, n1, n2, n3, sec, flags, addr)
1142 char *name = (char *) xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1146 sym = bfd_make_empty_symbol (abfd);
1151 symtab[symptr++] = sym;
1154 static arelent *reltab = 0;
1155 static int relcount = 0, relsize = 0;
1158 quick_reloc (abfd, address, which_howto, symidx)
1164 if (relcount >= (relsize-1))
1168 reltab = (arelent *) xrealloc (reltab, relsize * sizeof (arelent));
1170 reltab = (arelent *) xmalloc (relsize * sizeof (arelent));
1172 reltab[relcount].address = address;
1173 reltab[relcount].addend = 0;
1174 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1175 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1180 save_relocs (asection *sec)
1183 sec->relocation = reltab;
1184 sec->reloc_count = relcount;
1185 sec->orelocation = (arelent **) xmalloc ((relcount+1) * sizeof (arelent *));
1186 for (i=0; i<relcount; i++)
1187 sec->orelocation[i] = sec->relocation + i;
1188 sec->orelocation[relcount] = 0;
1189 sec->flags |= SEC_RELOC;
1191 relcount = relsize = 0;
1196 * .global __head_my_dll
1201 * .rva __my_dll_iname
1217 asection *id2, *id5, *id4;
1218 unsigned char *d2, *d5, *d4;
1222 oname = (char *) xmalloc (20);
1223 sprintf (oname, "d%06d.o", tmp_seq);
1226 abfd = bfd_create (oname, parent);
1227 bfd_find_target (pe_details->object_target, abfd);
1228 bfd_make_writable (abfd);
1230 bfd_set_format (abfd, bfd_object);
1231 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1234 symtab = (asymbol **) xmalloc (6 * sizeof (asymbol *));
1235 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1236 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1237 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1238 quick_symbol (abfd, U("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1239 quick_symbol (abfd, U(""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1241 /* OK, pay attention here. I got confused myself looking back at
1242 it. We create a four-byte section to mark the beginning of the
1243 list, and we include an offset of 4 in the section, so that the
1244 pointer to the list points to the *end* of this section, which is
1245 the start of the list of sections from other objects. */
1247 bfd_set_section_size (abfd, id2, 20);
1248 d2 = (unsigned char *) xmalloc (20);
1251 d2[0] = d2[16] = 4; /* reloc addend */
1252 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1253 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1254 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1257 bfd_set_section_size (abfd, id5, 4);
1258 d5 = (unsigned char *) xmalloc (4);
1262 bfd_set_section_size (abfd, id4, 4);
1263 d4 = (unsigned char *) xmalloc (4);
1267 bfd_set_symtab (abfd, symtab, symptr);
1269 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1270 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1271 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1273 bfd_make_readable (abfd);
1283 * .global __my_dll_iname
1292 asection *id4, *id5, *id7;
1293 unsigned char *d4, *d5, *d7;
1298 oname = (char *) xmalloc (20);
1299 sprintf (oname, "d%06d.o", tmp_seq);
1302 abfd = bfd_create (oname, parent);
1303 bfd_find_target (pe_details->object_target, abfd);
1304 bfd_make_writable (abfd);
1306 bfd_set_format (abfd, bfd_object);
1307 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1310 symtab = (asymbol **) xmalloc (5 * sizeof (asymbol *));
1311 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1312 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1313 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1314 quick_symbol (abfd, U(""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1316 bfd_set_section_size (abfd, id4, 4);
1317 d4 = (unsigned char *) xmalloc (4);
1321 bfd_set_section_size (abfd, id5, 4);
1322 d5 = (unsigned char *) xmalloc (4);
1326 len = strlen (dll_filename)+1;
1329 bfd_set_section_size (abfd, id7, len);
1330 d7 = (unsigned char *) xmalloc (len);
1332 strcpy (d7, dll_filename);
1334 bfd_set_symtab (abfd, symtab, symptr);
1336 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1337 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1338 bfd_set_section_contents (abfd, id7, d7, 0, len);
1340 bfd_make_readable (abfd);
1347 * .global ___imp_function
1348 * .global __imp__function
1350 * jmp *__imp__function:
1353 * .long __head_my_dll
1364 * .asciz "function" xlate? (add underscore, kill at)
1367 static unsigned char jmp_ix86_bytes[] = {
1368 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1377 * .dw __imp_function
1380 static unsigned char jmp_sh_bytes[] = {
1381 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1386 * lui $t0,<high:__imp_function>
1387 * lw $t0,<low:__imp_function>
1392 static unsigned char jmp_mips_bytes[] = {
1393 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1394 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1398 make_one (exp, parent)
1399 def_file_export *exp;
1402 asection *tx, *id7, *id5, *id4, *id6;
1403 unsigned char *td, *d7, *d5, *d4, *d6 = NULL;
1407 unsigned char *jmp_bytes = NULL;
1408 int jmp_byte_count = 0;
1410 switch (pe_details->pe_arch)
1413 jmp_bytes = jmp_ix86_bytes;
1414 jmp_byte_count = sizeof (jmp_ix86_bytes);
1417 jmp_bytes = jmp_sh_bytes;
1418 jmp_byte_count = sizeof (jmp_sh_bytes);
1421 jmp_bytes = jmp_mips_bytes;
1422 jmp_byte_count = sizeof (jmp_mips_bytes);
1426 oname = (char *) xmalloc (20);
1427 sprintf (oname, "d%06d.o", tmp_seq);
1430 abfd = bfd_create (oname, parent);
1431 bfd_find_target (pe_details->object_target, abfd);
1432 bfd_make_writable (abfd);
1434 bfd_set_format (abfd, bfd_object);
1435 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1438 symtab = (asymbol **) xmalloc (10 * sizeof (asymbol *));
1439 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1440 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1441 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1442 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1443 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1444 if (! exp->flag_data)
1445 quick_symbol (abfd, U(""), exp->internal_name, "", tx, BSF_GLOBAL, 0);
1446 quick_symbol (abfd, U("_head_"), dll_symname, "", UNDSEC, BSF_GLOBAL, 0);
1447 quick_symbol (abfd, U("__imp_"), exp->internal_name, "", id5, BSF_GLOBAL, 0);
1448 if (pe_dll_compat_implib)
1449 quick_symbol (abfd, U("__imp_"), exp->internal_name, "",
1450 id5, BSF_GLOBAL, 0);
1452 bfd_set_section_size (abfd, tx, jmp_byte_count);
1453 td = (unsigned char *) xmalloc (jmp_byte_count);
1455 memcpy (td, jmp_bytes, jmp_byte_count);
1456 switch (pe_details->pe_arch)
1459 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1462 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1465 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1466 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1467 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1472 bfd_set_section_size (abfd, id7, 4);
1473 d7 = (unsigned char *) xmalloc (4);
1476 quick_reloc (abfd, 0, BFD_RELOC_RVA, 6);
1479 bfd_set_section_size (abfd, id5, 4);
1480 d5 = (unsigned char *) xmalloc (4);
1483 if (exp->flag_noname)
1485 d5[0] = exp->ordinal;
1486 d5[1] = exp->ordinal >> 8;
1491 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1495 bfd_set_section_size (abfd, id4, 4);
1496 d4 = (unsigned char *) xmalloc (4);
1499 if (exp->flag_noname)
1501 d5[0] = exp->ordinal;
1502 d5[1] = exp->ordinal >> 8;
1507 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1511 if (exp->flag_noname)
1514 bfd_set_section_size (abfd, id6, 0);
1518 len = strlen (exp->name) + 3;
1521 bfd_set_section_size (abfd, id6, len);
1522 d6 = (unsigned char *) xmalloc (len);
1524 memset (d6, 0, len);
1525 d6[0] = exp->hint & 0xff;
1526 d6[1] = exp->hint >> 8;
1527 strcpy (d6+2, exp->name);
1530 bfd_set_symtab (abfd, symtab, symptr);
1532 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
1533 bfd_set_section_contents (abfd, id7, d7, 0, 4);
1534 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1535 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1536 if (!exp->flag_noname)
1537 bfd_set_section_contents (abfd, id6, d6, 0, len);
1539 bfd_make_readable (abfd);
1544 pe_dll_generate_implib (def, impfilename)
1546 const char *impfilename;
1554 dll_filename = (def->name) ? def->name : dll_name;
1555 dll_symname = xstrdup (dll_filename);
1556 for (i=0; dll_symname[i]; i++)
1557 if (!isalnum ((unsigned char) dll_symname[i]))
1558 dll_symname[i] = '_';
1560 unlink (impfilename);
1562 outarch = bfd_openw (impfilename, 0);
1566 /* xgettext:c-format */
1567 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
1571 /* xgettext:c-format */
1572 einfo (_("Creating library file: %s\n"), impfilename);
1574 bfd_set_format (outarch, bfd_archive);
1575 outarch->has_armap = 1;
1577 /* Work out a reasonable size of things to put onto one line. */
1579 ar_head = make_head (outarch);
1581 for (i = 0; i<def->num_exports; i++)
1583 /* The import library doesn't know about the internal name */
1584 char *internal = def->exports[i].internal_name;
1586 def->exports[i].internal_name = def->exports[i].name;
1587 n = make_one (def->exports+i, outarch);
1590 def->exports[i].internal_name = internal;
1593 ar_tail = make_tail (outarch);
1595 if (ar_head == NULL || ar_tail == NULL)
1598 /* Now stick them all into the archive */
1600 ar_head->next = head;
1601 ar_tail->next = ar_head;
1604 if (! bfd_set_archive_head (outarch, head))
1605 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
1607 if (! bfd_close (outarch))
1608 einfo ("%Xbfd_close %s: %s\n", impfilename, bfd_errmsg (bfd_get_error ()));
1610 while (head != NULL)
1612 bfd *n = head->next;
1619 add_bfd_to_link (abfd, name, link_info)
1622 struct bfd_link_info *link_info;
1624 lang_input_statement_type *fake_file;
1625 fake_file = lang_add_input_file (name,
1626 lang_input_file_is_fake_enum,
1628 fake_file->the_bfd = abfd;
1629 ldlang_add_file (fake_file);
1630 if (!bfd_link_add_symbols (abfd, link_info))
1631 einfo ("%Xaddsym %s: %s\n", name, bfd_errmsg (bfd_get_error ()));
1635 pe_process_import_defs (output_bfd, link_info)
1637 struct bfd_link_info *link_info;
1639 def_file_module *module;
1640 pe_dll_id_target(bfd_get_target (output_bfd));
1645 for (module = pe_def_file->modules; module; module = module->next)
1649 dll_filename = module->name;
1650 dll_symname = xstrdup (module->name);
1651 for (i=0; dll_symname[i]; i++)
1652 if (!isalnum (dll_symname[i]))
1653 dll_symname[i] = '_';
1657 for (i=0; i<pe_def_file->num_imports; i++)
1658 if (pe_def_file->imports[i].module == module)
1660 def_file_export exp;
1661 struct bfd_link_hash_entry *blhe;
1663 /* see if we need this import */
1664 char *name = (char *) xmalloc (strlen (pe_def_file->imports[i].internal_name) + 2);
1665 sprintf (name, "%s%s", U(""), pe_def_file->imports[i].internal_name);
1666 blhe = bfd_link_hash_lookup (link_info->hash, name,
1667 false, false, false);
1669 if (blhe && blhe->type == bfd_link_hash_undefined)
1675 bfd *ar_head = make_head (output_bfd);
1676 add_bfd_to_link (ar_head, ar_head->filename, link_info);
1679 exp.internal_name = pe_def_file->imports[i].internal_name;
1680 exp.name = pe_def_file->imports[i].name;
1681 exp.ordinal = pe_def_file->imports[i].ordinal;
1682 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
1683 exp.flag_private = 0;
1684 exp.flag_constant = 0;
1686 exp.flag_noname = exp.name ? 0 : 1;
1687 one = make_one (&exp, output_bfd);
1688 add_bfd_to_link (one, one->filename, link_info);
1693 bfd *ar_tail = make_tail (output_bfd);
1694 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
1701 /************************************************************************
1703 We were handed a *.DLL file. Parse it and turn it into a set of
1704 IMPORTS directives in the def file. Return true if the file was
1705 handled, false if not.
1707 ************************************************************************/
1710 pe_get16 (abfd, where)
1715 bfd_seek (abfd, where, SEEK_SET);
1716 bfd_read (b, 1, 2, abfd);
1717 return b[0] + (b[1]<<8);
1721 pe_get32 (abfd, where)
1726 bfd_seek (abfd, where, SEEK_SET);
1727 bfd_read (b, 1, 4, abfd);
1728 return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
1731 #if 0 /* This is not currently used. */
1737 unsigned char *b = ptr;
1738 return b[0] + (b[1]<<8);
1747 unsigned char *b = ptr;
1748 return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
1752 pe_implied_import_dll (filename)
1753 const char *filename;
1756 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
1757 unsigned long export_rva, export_size, nsections, secptr, expptr;
1758 unsigned char *expdata, *erva;
1759 unsigned long name_rvas, ordinals, nexp, ordbase;
1760 const char *dll_name;
1762 /* No, I can't use bfd here. kernel32.dll puts its export table in
1763 the middle of the .rdata section. */
1765 dll = bfd_openr (filename, pe_details->target_name);
1768 einfo ("%Xopen %s: %s\n", filename, bfd_errmsg (bfd_get_error ()));
1771 /* PEI dlls seem to be bfd_objects */
1772 if (!bfd_check_format (dll, bfd_object))
1774 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
1778 dll_name = filename;
1779 for (i=0; filename[i]; i++)
1780 if (filename[i] == '/' || filename[i] == '\\' || filename[i] == ':')
1781 dll_name = filename + i + 1;
1783 pe_header_offset = pe_get32 (dll, 0x3c);
1784 opthdr_ofs = pe_header_offset + 4 + 20;
1785 num_entries = pe_get32 (dll, opthdr_ofs + 92);
1786 if (num_entries < 1) /* no exports */
1788 export_rva = pe_get32 (dll, opthdr_ofs + 96);
1789 export_size = pe_get32 (dll, opthdr_ofs + 100);
1790 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
1791 secptr = (pe_header_offset + 4 + 20 +
1792 pe_get16 (dll, pe_header_offset + 4 + 16));
1794 for (i=0; i<nsections; i++)
1797 unsigned long secptr1 = secptr + 40 * i;
1798 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
1799 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
1800 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
1801 bfd_seek(dll, secptr1, SEEK_SET);
1802 bfd_read(sname, 1, 8, dll);
1803 if (vaddr <= export_rva && vaddr+vsize > export_rva)
1805 expptr = fptr + (export_rva - vaddr);
1806 if (export_rva + export_size > vaddr + vsize)
1807 export_size = vsize - (export_rva - vaddr);
1812 expdata = (unsigned char *) xmalloc (export_size);
1813 bfd_seek (dll, expptr, SEEK_SET);
1814 bfd_read (expdata, 1, export_size, dll);
1815 erva = expdata - export_rva;
1817 if (pe_def_file == 0)
1818 pe_def_file = def_file_empty();
1820 nexp = pe_as32 (expdata+24);
1821 name_rvas = pe_as32 (expdata+32);
1822 ordinals = pe_as32 (expdata+36);
1823 ordbase = pe_as32 (expdata+16);
1824 for (i=0; i<nexp; i++)
1826 unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);
1827 def_file_import *imp;
1828 imp = def_file_add_import (pe_def_file, erva+name_rva, dll_name,
1835 /************************************************************************
1837 These are the main functions, called from the emulation. The first
1838 is called after the bfds are read, so we can guess at how much space
1839 we need. The second is called after everything is placed, so we
1840 can put the right values in place.
1842 ************************************************************************/
1845 pe_dll_build_sections (abfd, info)
1847 struct bfd_link_info *info;
1849 pe_dll_id_target (bfd_get_target (abfd));
1850 process_def_file (abfd, info);
1852 generate_edata (abfd, info);
1853 build_filler_bfd (1);
1857 pe_exe_build_sections (abfd, info)
1859 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1861 pe_dll_id_target (bfd_get_target (abfd));
1862 build_filler_bfd (0);
1866 pe_dll_fill_sections (abfd, info)
1868 struct bfd_link_info *info;
1870 pe_dll_id_target (bfd_get_target (abfd));
1871 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
1873 generate_reloc (abfd, info);
1876 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
1878 /* Resize the sections. */
1879 lang_size_sections (stat_ptr->head, abs_output_section,
1880 &stat_ptr->head, 0, (bfd_vma) 0, false);
1882 /* Redo special stuff. */
1883 ldemul_after_allocation ();
1885 /* Do the assignments again. */
1886 lang_do_assignments (stat_ptr->head,
1888 (fill_type) 0, (bfd_vma) 0);
1891 fill_edata (abfd, info);
1893 pe_data (abfd)->dll = 1;
1895 edata_s->contents = edata_d;
1896 reloc_s->contents = reloc_d;
1900 pe_exe_fill_sections (abfd, info)
1902 struct bfd_link_info *info;
1904 pe_dll_id_target (bfd_get_target (abfd));
1905 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
1907 generate_reloc (abfd, info);
1910 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
1912 /* Resize the sections. */
1913 lang_size_sections (stat_ptr->head, abs_output_section,
1914 &stat_ptr->head, 0, (bfd_vma) 0, false);
1916 /* Redo special stuff. */
1917 ldemul_after_allocation ();
1919 /* Do the assignments again. */
1920 lang_do_assignments (stat_ptr->head,
1922 (fill_type) 0, (bfd_vma) 0);
1924 reloc_s->contents = reloc_d;