1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998 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"
34 #include "coff/internal.h"
35 #include "../bfd/libcoff.h"
38 /************************************************************************
40 This file turns a regular Windows PE image into a DLL. Because of
41 the complexity of this operation, it has been broken down into a
42 number of separate modules which are all called by the main function
43 at the end of this file. This function is not re-entrant and is
44 normally only called once, so static variables are used to reduce
45 the number of parameters and return values required.
47 See also: ld/emultempl/pe.em
49 ************************************************************************/
51 /* from emultempl/pe.em */
53 extern def_file *pe_def_file;
54 extern int pe_dll_export_everything;
55 extern int pe_dll_do_default_excludes;
56 extern int pe_dll_kill_ats;
57 extern int pe_dll_stdcall_aliases;
59 /************************************************************************
61 static variables and types
63 ************************************************************************/
65 static bfd_vma image_base;
67 static bfd *filler_bfd;
68 static struct sec *edata_s, *reloc_s;
69 static unsigned char *edata_d, *reloc_d;
70 static int edata_sz, reloc_sz;
72 /************************************************************************
74 Helper functions for qsort. Relocs must be sorted so that we can write
77 ************************************************************************/
83 unsigned long a = *(unsigned long *) va;
84 unsigned long b = *(unsigned long *) vb;
89 pe_export_sort (va, vb)
92 def_file_export *a = (def_file_export *) va;
93 def_file_export *b = (def_file_export *) vb;
94 return strcmp (a->name, b->name);
97 /************************************************************************
99 Read and process the .DEF file
101 ************************************************************************/
103 /* These correspond to the entries in pe_def_file->exports[]. I use
104 exported_symbol_sections[i] to tag whether or not the symbol was
105 defined, since we can't export symbols we don't have. */
107 static bfd_vma *exported_symbol_offsets;
108 static struct sec **exported_symbol_sections;
110 static int export_table_size;
111 static int count_exported;
112 static int count_exported_byname;
113 static int count_with_ordinals;
114 static const char *dll_name;
115 static int min_ordinal, max_ordinal;
116 static int *exported_symbols;
118 typedef struct exclude_list_struct
121 struct exclude_list_struct *next;
124 static struct exclude_list_struct *excludes = 0;
127 pe_dll_add_excludes (new_excludes)
128 const char *new_excludes;
131 char *exclude_string;
133 local_copy = xstrdup (new_excludes);
135 exclude_string = strtok (local_copy, ",:");
136 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
138 struct exclude_list_struct *new_exclude;
140 new_exclude = ((struct exclude_list_struct *)
141 xmalloc (sizeof (struct exclude_list_struct)));
142 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 1);
143 strcpy (new_exclude->string, exclude_string);
144 new_exclude->next = excludes;
145 excludes = new_exclude;
157 struct exclude_list_struct *ex;
158 for (i = 0; i < d->num_exports; i++)
159 if (strcmp (d->exports[i].name, n) == 0)
161 if (pe_dll_do_default_excludes)
163 if (strcmp (n, "DllMain@12") == 0)
165 if (strcmp (n, "DllEntryPoint@0") == 0)
167 if (strcmp (n, "impure_ptr") == 0)
170 for (ex = excludes; ex; ex = ex->next)
171 if (strcmp (n, ex->string) == 0)
177 process_def_file (abfd, info)
179 struct bfd_link_info *info;
182 struct bfd_link_hash_entry *blhe;
185 def_file_export *e=0;
188 pe_def_file = def_file_empty ();
190 /* First, run around to all the objects looking for the .drectve
191 sections, and push those into the def file too */
193 for (b = info->input_bfds; b; b = b->link_next)
195 s = bfd_get_section_by_name (b, ".drectve");
198 int size = bfd_get_section_size_before_reloc (s);
199 char *buf = xmalloc (size);
200 bfd_get_section_contents (b, s, buf, 0, size);
201 def_file_add_directive (pe_def_file, buf, size);
206 /* Now, maybe export everything else the default way */
208 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
210 for (b = info->input_bfds; b; b = b->link_next)
215 symsize = bfd_get_symtab_upper_bound (b);
216 symbols = (asymbol **) xmalloc (symsize);
217 nsyms = bfd_canonicalize_symtab (b, symbols);
219 for (j = 0; j < nsyms; j++)
221 if ((symbols[j]->flags & (BSF_FUNCTION | BSF_GLOBAL))
222 == (BSF_FUNCTION | BSF_GLOBAL))
224 const char *sn = symbols[j]->name;
227 if (auto_export (pe_def_file, sn))
228 def_file_add_export (pe_def_file, sn, 0, -1);
235 #define NE pe_def_file->num_exports
237 /* Canonicalize the export list */
241 for (i = 0; i < NE; i++)
243 if (strchr (pe_def_file->exports[i].name, '@'))
245 /* This will preserve internal_name, which may have been pointing
246 to the same memory as name, or might not have */
247 char *tmp = xstrdup (pe_def_file->exports[i].name);
248 *(strchr (tmp, '@')) = 0;
249 pe_def_file->exports[i].name = tmp;
254 if (pe_dll_stdcall_aliases)
256 for (i = 0; i < NE; i++)
258 if (strchr (pe_def_file->exports[i].name, '@'))
260 char *tmp = xstrdup (pe_def_file->exports[i].name);
261 *(strchr (tmp, '@')) = 0;
262 if (auto_export (pe_def_file, tmp))
263 def_file_add_export (pe_def_file, tmp,
264 pe_def_file->exports[i].internal_name, -1);
271 e = pe_def_file->exports; /* convenience, but watch out for it changing */
273 exported_symbol_offsets = (bfd_vma *) xmalloc (NE * sizeof (bfd_vma));
274 exported_symbol_sections = (struct sec **) xmalloc (NE * sizeof (struct sec *));
276 memset (exported_symbol_sections, 0, NE * sizeof (struct sec *));
280 count_exported_byname = 0;
281 count_with_ordinals = 0;
283 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]), pe_export_sort);
284 for (i = 0, j = 0; i < NE; i++)
286 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
288 /* This is a duplicate */
289 if (e[j - 1].ordinal != -1
290 && e[i].ordinal != -1
291 && e[j - 1].ordinal != e[i].ordinal)
293 /* xgettext:c-format */
294 einfo (_("%XError, duplicate EXPORT with oridinals: %s (%d vs %d)\n"),
295 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
299 /* xgettext:c-format */
300 einfo (_("Warning, duplicate EXPORT: %s\n"),
304 e[j - 1].ordinal = e[i].ordinal;
305 e[j - 1].flag_private |= e[i].flag_private;
306 e[j - 1].flag_constant |= e[i].flag_constant;
307 e[j - 1].flag_noname |= e[i].flag_noname;
308 e[j - 1].flag_data |= e[i].flag_data;
317 pe_def_file->num_exports = j; /* == NE */
319 for (i = 0; i < NE; i++)
321 char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
323 strcpy (name + 1, pe_def_file->exports[i].internal_name);
325 blhe = bfd_link_hash_lookup (info->hash,
329 if (blhe && (blhe->type == bfd_link_hash_defined))
332 if (!pe_def_file->exports[i].flag_noname)
333 count_exported_byname++;
334 exported_symbol_offsets[i] = blhe->u.def.value;
335 exported_symbol_sections[i] = blhe->u.def.section;
336 if (pe_def_file->exports[i].ordinal != -1)
338 if (max_ordinal < pe_def_file->exports[i].ordinal)
339 max_ordinal = pe_def_file->exports[i].ordinal;
340 if (min_ordinal > pe_def_file->exports[i].ordinal)
341 min_ordinal = pe_def_file->exports[i].ordinal;
342 count_with_ordinals++;
345 else if (blhe && blhe->type == bfd_link_hash_undefined)
347 /* xgettext:c-format */
348 einfo (_("%XCannot export %s: symbol not defined\n"),
349 pe_def_file->exports[i].internal_name);
353 /* xgettext:c-format */
354 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
355 pe_def_file->exports[i].internal_name,
356 blhe->type, bfd_link_hash_defined);
360 /* xgettext:c-format */
361 einfo (_("%XCannot export %s: symbol not found\n"),
362 pe_def_file->exports[i].internal_name);
368 /************************************************************************
370 Build the bfd that will contain .edata and .reloc sections
372 ************************************************************************/
377 static lang_input_statement_type *filler_file;
378 filler_file = lang_add_input_file ("dll stuff",
379 lang_input_file_is_fake_enum,
381 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
382 if (filler_bfd == NULL
383 || !bfd_set_arch_mach (filler_bfd,
384 bfd_get_arch (output_bfd),
385 bfd_get_mach (output_bfd)))
387 einfo ("%X%P: can not create BFD %E\n");
391 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
393 || !bfd_set_section_flags (filler_bfd, edata_s,
400 einfo ("%X%P: can not create .edata section: %E\n");
403 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
405 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
407 || !bfd_set_section_flags (filler_bfd, reloc_s,
414 einfo ("%X%P: can not create .reloc section: %E\n");
417 bfd_set_section_size (filler_bfd, reloc_s, 0);
419 ldlang_add_file (filler_file);
422 /************************************************************************
424 Gather all the exported symbols and build the .edata section
426 ************************************************************************/
429 generate_edata (abfd, info)
431 struct bfd_link_info *info;
433 int i, j, next_ordinal;
434 int name_table_size = 0;
437 /* First, we need to know how many exported symbols there are,
438 and what the range of ordinals is. */
440 if (pe_def_file->name)
442 dll_name = pe_def_file->name;
446 dll_name = abfd->filename;
447 for (dlnp = dll_name; *dlnp; dlnp++)
449 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
454 if (count_with_ordinals && max_ordinal > count_exported)
456 if (min_ordinal > max_ordinal - count_exported + 1)
457 min_ordinal = max_ordinal - count_exported + 1;
462 max_ordinal = count_exported;
464 export_table_size = max_ordinal - min_ordinal + 1;
466 exported_symbols = (int *) xmalloc (export_table_size * sizeof (int));
467 for (i = 0; i < export_table_size; i++)
468 exported_symbols[i] = -1;
470 /* Now we need to assign ordinals to those that don't have them */
471 for (i = 0; i < NE; i++)
473 if (exported_symbol_sections[i])
475 if (pe_def_file->exports[i].ordinal != -1)
477 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
478 int pi = exported_symbols[ei];
481 /* xgettext:c-format */
482 einfo (_("%XError, oridinal used twice: %d (%s vs %s)\n"),
483 pe_def_file->exports[i].ordinal,
484 pe_def_file->exports[i].name,
485 pe_def_file->exports[pi].name);
487 exported_symbols[ei] = i;
489 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
493 next_ordinal = min_ordinal;
494 for (i = 0; i < NE; i++)
495 if (exported_symbol_sections[i])
496 if (pe_def_file->exports[i].ordinal == -1)
498 while (exported_symbols[next_ordinal - min_ordinal] != -1)
500 exported_symbols[next_ordinal - min_ordinal] = i;
501 pe_def_file->exports[i].ordinal = next_ordinal;
504 /* OK, now we can allocate some memory */
506 edata_sz = (40 /* directory */
507 + 4 * export_table_size /* addresses */
508 + 4 * count_exported_byname /* name ptrs */
509 + 2 * count_exported_byname /* ordinals */
510 + name_table_size + strlen (dll_name) + 1);
514 fill_edata (abfd, info)
516 struct bfd_link_info *info;
519 unsigned char *edirectory;
520 unsigned long *eaddresses;
521 unsigned long *enameptrs;
522 unsigned short *eordinals;
523 unsigned char *enamestr;
525 edata_d = (unsigned char *) xmalloc (edata_sz);
527 /* Note use of array pointer math here */
528 edirectory = edata_d;
529 eaddresses = (unsigned long *) (edata_d + 40);
530 enameptrs = eaddresses + export_table_size;
531 eordinals = (unsigned short *) (enameptrs + count_exported_byname);
532 enamestr = (char *) (eordinals + count_exported_byname);
534 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
536 memset (edata_d, 0, 40);
537 if (pe_def_file->version_major != -1)
539 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
540 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
542 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
543 strcpy (enamestr, dll_name);
544 enamestr += strlen (enamestr) + 1;
545 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
546 bfd_put_32 (abfd, export_table_size, edata_d + 20);
547 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
548 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
549 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
550 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
552 /* Ok, now for the filling in part */
553 for (i = 0; i < export_table_size; i++)
555 int s = exported_symbols[i];
558 struct sec *ssec = exported_symbol_sections[s];
559 unsigned long srva = (exported_symbol_offsets[s]
560 + ssec->output_section->vma
561 + ssec->output_offset);
563 bfd_put_32 (abfd, srva - image_base, (void *) (eaddresses + i));
564 if (!pe_def_file->exports[s].flag_noname)
566 char *ename = pe_def_file->exports[s].name;
567 bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs);
568 strcpy (enamestr, ename[0] == '_' ? ename + 1 : ename);
569 enamestr += strlen (enamestr) + 1;
570 bfd_put_16 (abfd, i, (void *) eordinals);
578 /************************************************************************
580 Gather all the relocations and build the .reloc section
582 ************************************************************************/
585 generate_reloc (abfd, info)
587 struct bfd_link_info *info;
590 /* for .reloc stuff */
591 bfd_vma *reloc_addresses;
592 int total_relocs = 0;
594 unsigned long sec_page = (unsigned long) (-1);
595 unsigned long page_ptr, page_count;
601 for (b = info->input_bfds; b; b = b->link_next)
602 for (s = b->sections; s; s = s->next)
603 total_relocs += s->reloc_count;
605 reloc_addresses = (unsigned long *) xmalloc (total_relocs * sizeof (unsigned long));
609 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
612 int relsize, nrelocs, i;
614 for (s = b->sections; s; s = s->next)
616 unsigned long sec_vma = s->output_section->vma + s->output_offset;
620 symsize = bfd_get_symtab_upper_bound (b);
621 symbols = (asymbol **) xmalloc (symsize);
622 nsyms = bfd_canonicalize_symtab (b, symbols);
624 relsize = bfd_get_reloc_upper_bound (b, s);
625 relocs = (arelent **) xmalloc ((size_t) relsize);
626 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
628 for (i = 0; i < nrelocs; i++)
630 if (!relocs[i]->howto->pc_relative)
632 switch (relocs[i]->howto->bitsize)
635 reloc_addresses[total_relocs++] = sec_vma + relocs[i]->address;
638 /* xgettext:c-format */
639 einfo (_("%XError: %d-bit reloc in dll\n"),
640 relocs[i]->howto->bitsize);
646 /* Warning: the allocated symbols are remembered in BFD and reused
647 later, so don't free them! */
652 /* At this point, we have total_relocs relocation addresses in
653 reloc_addresses, which are all suitable for the .reloc section.
654 We must now create the new sections. */
656 qsort (reloc_addresses, total_relocs, sizeof (unsigned long), reloc_sort);
658 for (i = 0; i < total_relocs; i++)
660 unsigned long this_page = (reloc_addresses[i] >> 12);
661 if (this_page != sec_page)
663 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align */
665 sec_page = this_page;
669 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align */
671 reloc_d = (unsigned char *) xmalloc (reloc_sz);
673 sec_page = (unsigned long) (-1);
675 page_ptr = (unsigned long) (-1);
677 for (i = 0; i < total_relocs; i++)
679 unsigned long rva = reloc_addresses[i] - image_base;
680 unsigned long this_page = (rva & ~0xfff);
681 if (this_page != sec_page)
684 reloc_d[reloc_sz++] = 0;
685 if (page_ptr != (unsigned long) (-1))
686 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
687 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
690 sec_page = this_page;
693 bfd_put_16 (abfd, (rva & 0xfff) + 0x3000, reloc_d + reloc_sz);
698 reloc_d[reloc_sz++] = 0;
699 if (page_ptr != (unsigned long) (-1))
700 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
701 while (reloc_sz < reloc_s->_raw_size)
702 reloc_d[reloc_sz++] = 0;
705 /************************************************************************
707 Given the exiting def_file structure, print out a .DEF file that
710 ************************************************************************/
713 quoteput (s, f, needs_quotes)
719 for (cp = s; *cp; cp++)
720 if (*cp == '\'' || *cp == '"' || *cp == '\\' || isspace (*cp) || *cp == ','
728 if (*s == '"' || *s == '\\')
740 pe_dll_generate_def_file (pe_out_def_filename)
741 char *pe_out_def_filename;
744 FILE *out = fopen (pe_out_def_filename, "w");
747 /* xgettext:c-format */
748 einfo (_("%s: Can't open output def file %s\n"),
749 program_name, pe_out_def_filename);
754 if (pe_def_file->name)
756 if (pe_def_file->is_dll)
757 fprintf (out, "LIBRARY ");
759 fprintf (out, "NAME ");
760 quoteput (pe_def_file->name, out, 1);
761 if (pe_def_file->base_address != (bfd_vma) (-1))
762 fprintf (out, " BASE=0x%x", pe_def_file->base_address);
766 if (pe_def_file->description)
768 fprintf (out, "DESCRIPTION ");
769 quoteput (pe_def_file->description, out, 1);
773 if (pe_def_file->version_minor)
774 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
775 pe_def_file->version_minor);
777 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
779 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
782 if (pe_def_file->stack_commit != -1)
783 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
784 pe_def_file->stack_reserve, pe_def_file->stack_commit);
785 else if (pe_def_file->stack_reserve != -1)
786 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
787 if (pe_def_file->heap_commit != -1)
788 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
789 pe_def_file->heap_reserve, pe_def_file->heap_commit);
790 else if (pe_def_file->heap_reserve != -1)
791 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
793 if (pe_def_file->num_section_defs > 0)
795 fprintf (out, "\nSECTIONS\n\n");
796 for (i = 0; i < pe_def_file->num_section_defs; i++)
799 quoteput (pe_def_file->section_defs[i].name, out, 0);
800 if (pe_def_file->section_defs[i].class)
802 fprintf (out, " CLASS ");
803 quoteput (pe_def_file->section_defs[i].class, out, 0);
805 if (pe_def_file->section_defs[i].flag_read)
806 fprintf (out, " READ");
807 if (pe_def_file->section_defs[i].flag_write)
808 fprintf (out, " WRITE");
809 if (pe_def_file->section_defs[i].flag_execute)
810 fprintf (out, " EXECUTE");
811 if (pe_def_file->section_defs[i].flag_shared)
812 fprintf (out, " SHARED");
817 if (pe_def_file->num_exports > 0)
819 fprintf (out, "\nEXPORTS\n\n");
820 for (i = 0; i < pe_def_file->num_exports; i++)
822 def_file_export *e = pe_def_file->exports + i;
824 quoteput (e->name, out, 0);
825 if (e->internal_name && strcmp (e->internal_name, e->name))
827 fprintf (out, " = ");
828 quoteput (e->internal_name, out, 0);
830 if (e->ordinal != -1)
831 fprintf (out, " @%d", e->ordinal);
833 fprintf (out, " PRIVATE");
834 if (e->flag_constant)
835 fprintf (out, " CONSTANT");
837 fprintf (out, " NONAME");
839 fprintf (out, " DATA");
845 if (pe_def_file->num_imports > 0)
847 fprintf (out, "\nIMPORTS\n\n");
848 for (i = 0; i < pe_def_file->num_imports; i++)
850 def_file_import *im = pe_def_file->imports + i;
852 if (im->internal_name
853 && (!im->name || strcmp (im->internal_name, im->name)))
855 quoteput (im->internal_name, out, 0);
856 fprintf (out, " = ");
858 quoteput (im->module->name, out, 0);
861 quoteput (im->name, out, 0);
863 fprintf (out, "%d", im->ordinal);
869 fprintf (out, _("; no contents available\n"));
871 if (fclose (out) == EOF)
873 /* xgettext:c-format */
874 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
878 /************************************************************************
880 These are the main functions, called from the emulation. The first
881 is called after the bfds are read, so we can guess at how much space
882 we need. The second is called after everything is placed, so we
883 can put the right values in place.
885 ************************************************************************/
888 pe_dll_build_sections (abfd, info)
890 struct bfd_link_info *info;
892 process_def_file (abfd, info);
894 generate_edata (abfd, info);
899 pe_dll_fill_sections (abfd, info)
901 struct bfd_link_info *info;
903 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
905 generate_reloc (abfd, info);
908 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
910 /* Resize the sections. */
911 lang_size_sections (stat_ptr->head, abs_output_section,
912 &stat_ptr->head, 0, (bfd_vma) 0, false);
914 /* Redo special stuff. */
915 ldemul_after_allocation ();
917 /* Do the assignments again. */
918 lang_do_assignments (stat_ptr->head,
920 (fill_type) 0, (bfd_vma) 0);
923 fill_edata (abfd, info);
925 pe_data (abfd)->dll = 1;
927 edata_s->contents = edata_d;
928 reloc_s->contents = reloc_d;