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 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 */
554 for (i
= 0; i
< export_table_size
; i
++)
556 int s
= exported_symbols
[i
];
559 struct sec
*ssec
= exported_symbol_sections
[s
];
560 unsigned long srva
= (exported_symbol_offsets
[s
]
561 + ssec
->output_section
->vma
562 + ssec
->output_offset
);
564 bfd_put_32 (abfd
, srva
- image_base
, (void *) (eaddresses
+ i
));
565 if (!pe_def_file
->exports
[s
].flag_noname
)
567 char *ename
= pe_def_file
->exports
[s
].name
;
568 bfd_put_32 (abfd
, ERVA (enamestr
), (void *) enameptrs
);
569 strcpy (enamestr
, ename
);
570 enamestr
+= strlen (enamestr
) + 1;
571 bfd_put_16 (abfd
, i
, (void *) eordinals
);
573 pe_def_file
->exports
[s
].hint
= hint
++;
580 /************************************************************************
582 Gather all the relocations and build the .reloc section
584 ************************************************************************/
587 generate_reloc (abfd
, info
)
589 struct bfd_link_info
*info
;
592 /* for .reloc stuff */
593 bfd_vma
*reloc_addresses
;
594 int total_relocs
= 0;
596 unsigned long sec_page
= (unsigned long) (-1);
597 unsigned long page_ptr
, page_count
;
603 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
604 for (s
= b
->sections
; s
; s
= s
->next
)
605 total_relocs
+= s
->reloc_count
;
607 reloc_addresses
= (unsigned long *) xmalloc (total_relocs
* sizeof (unsigned long));
611 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
614 int relsize
, nrelocs
, i
;
616 for (s
= b
->sections
; s
; s
= s
->next
)
618 unsigned long sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
622 /* if it's not loaded, we don't need to relocate it this way */
623 if (!(s
->output_section
->flags
& SEC_LOAD
))
626 /* I don't know why there would be a reloc for these, but I've
627 seen it happen - DJ */
628 if (s
->output_section
== &bfd_abs_section
)
631 if (s
->output_section
->vma
== 0)
633 /* Huh? Shouldn't happen, but punt if it does */
634 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
635 s
->output_section
->name
, s
->output_section
->index
,
636 s
->output_section
->flags
);
640 symsize
= bfd_get_symtab_upper_bound (b
);
641 symbols
= (asymbol
**) xmalloc (symsize
);
642 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
644 relsize
= bfd_get_reloc_upper_bound (b
, s
);
645 relocs
= (arelent
**) xmalloc ((size_t) relsize
);
646 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
648 for (i
= 0; i
< nrelocs
; i
++)
650 if (!relocs
[i
]->howto
->pc_relative
651 && relocs
[i
]->howto
->type
!= R_IMAGEBASE
)
653 switch (relocs
[i
]->howto
->bitsize
)
656 reloc_addresses
[total_relocs
++] = sec_vma
+ relocs
[i
]->address
;
659 /* xgettext:c-format */
660 einfo (_("%XError: %d-bit reloc in dll\n"),
661 relocs
[i
]->howto
->bitsize
);
667 /* Warning: the allocated symbols are remembered in BFD and reused
668 later, so don't free them! */
669 /* free (symbols); */
673 /* At this point, we have total_relocs relocation addresses in
674 reloc_addresses, which are all suitable for the .reloc section.
675 We must now create the new sections. */
677 qsort (reloc_addresses
, total_relocs
, sizeof (unsigned long), reloc_sort
);
679 for (i
= 0; i
< total_relocs
; i
++)
681 unsigned long this_page
= (reloc_addresses
[i
] >> 12);
682 if (this_page
!= sec_page
)
684 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align */
686 sec_page
= this_page
;
690 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align */
692 reloc_d
= (unsigned char *) xmalloc (reloc_sz
);
694 sec_page
= (unsigned long) (-1);
696 page_ptr
= (unsigned long) (-1);
698 for (i
= 0; i
< total_relocs
; i
++)
700 unsigned long rva
= reloc_addresses
[i
] - image_base
;
701 unsigned long this_page
= (rva
& ~0xfff);
702 if (this_page
!= sec_page
)
705 reloc_d
[reloc_sz
++] = 0;
706 if (page_ptr
!= (unsigned long) (-1))
707 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
708 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
711 sec_page
= this_page
;
714 bfd_put_16 (abfd
, (rva
& 0xfff) + 0x3000, reloc_d
+ reloc_sz
);
719 reloc_d
[reloc_sz
++] = 0;
720 if (page_ptr
!= (unsigned long) (-1))
721 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
722 while (reloc_sz
< reloc_s
->_raw_size
)
723 reloc_d
[reloc_sz
++] = 0;
726 /************************************************************************
728 Given the exiting def_file structure, print out a .DEF file that
731 ************************************************************************/
734 quoteput (s
, f
, needs_quotes
)
740 for (cp
= s
; *cp
; cp
++)
741 if (*cp
== '\'' || *cp
== '"' || *cp
== '\\' || isspace (*cp
) || *cp
== ','
749 if (*s
== '"' || *s
== '\\')
761 pe_dll_generate_def_file (pe_out_def_filename
)
762 char *pe_out_def_filename
;
765 FILE *out
= fopen (pe_out_def_filename
, "w");
768 /* xgettext:c-format */
769 einfo (_("%s: Can't open output def file %s\n"),
770 program_name
, pe_out_def_filename
);
775 if (pe_def_file
->name
)
777 if (pe_def_file
->is_dll
)
778 fprintf (out
, "LIBRARY ");
780 fprintf (out
, "NAME ");
781 quoteput (pe_def_file
->name
, out
, 1);
782 if (pe_data (output_bfd
)->pe_opthdr
.ImageBase
)
783 fprintf (out
, " BASE=0x%x", pe_data (output_bfd
)->pe_opthdr
.ImageBase
);
787 if (pe_def_file
->description
)
789 fprintf (out
, "DESCRIPTION ");
790 quoteput (pe_def_file
->description
, out
, 1);
794 if (pe_def_file
->version_minor
!= -1)
795 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
796 pe_def_file
->version_minor
);
797 else if (pe_def_file
->version_major
!= -1)
798 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
800 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
803 if (pe_def_file
->stack_commit
!= -1)
804 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
805 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
806 else if (pe_def_file
->stack_reserve
!= -1)
807 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
808 if (pe_def_file
->heap_commit
!= -1)
809 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
810 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
811 else if (pe_def_file
->heap_reserve
!= -1)
812 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
814 if (pe_def_file
->num_section_defs
> 0)
816 fprintf (out
, "\nSECTIONS\n\n");
817 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
820 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
821 if (pe_def_file
->section_defs
[i
].class)
823 fprintf (out
, " CLASS ");
824 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
826 if (pe_def_file
->section_defs
[i
].flag_read
)
827 fprintf (out
, " READ");
828 if (pe_def_file
->section_defs
[i
].flag_write
)
829 fprintf (out
, " WRITE");
830 if (pe_def_file
->section_defs
[i
].flag_execute
)
831 fprintf (out
, " EXECUTE");
832 if (pe_def_file
->section_defs
[i
].flag_shared
)
833 fprintf (out
, " SHARED");
838 if (pe_def_file
->num_exports
> 0)
840 fprintf (out
, "\nEXPORTS\n\n");
841 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
843 def_file_export
*e
= pe_def_file
->exports
+ i
;
845 quoteput (e
->name
, out
, 0);
846 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
848 fprintf (out
, " = ");
849 quoteput (e
->internal_name
, out
, 0);
851 if (e
->ordinal
!= -1)
852 fprintf (out
, " @%d", e
->ordinal
);
854 fprintf (out
, " PRIVATE");
855 if (e
->flag_constant
)
856 fprintf (out
, " CONSTANT");
858 fprintf (out
, " NONAME");
860 fprintf (out
, " DATA");
866 if (pe_def_file
->num_imports
> 0)
868 fprintf (out
, "\nIMPORTS\n\n");
869 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
871 def_file_import
*im
= pe_def_file
->imports
+ i
;
873 if (im
->internal_name
874 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
876 quoteput (im
->internal_name
, out
, 0);
877 fprintf (out
, " = ");
879 quoteput (im
->module
->name
, out
, 0);
882 quoteput (im
->name
, out
, 0);
884 fprintf (out
, "%d", im
->ordinal
);
890 fprintf (out
, _("; no contents available\n"));
892 if (fclose (out
) == EOF
)
894 /* xgettext:c-format */
895 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
899 /************************************************************************
901 Generate the import library
903 ************************************************************************/
905 static asymbol
**symtab
;
908 static const char *dll_filename
;
909 static char *dll_symname
;
911 #define UNDSEC (asection *) &bfd_und_section
914 quick_section(abfd
, name
, flags
, align
)
923 sec
= bfd_make_section_old_way (abfd
, name
);
924 bfd_set_section_flags (abfd
, sec
, flags
929 bfd_set_section_alignment (abfd
, sec
, align
);
930 /* remember to undo this before trying to link internally! */
931 sec
->output_section
= sec
;
933 sym
= bfd_make_empty_symbol (abfd
);
934 symtab
[symptr
++] = sym
;
935 sym
->name
= sec
->name
;
937 sym
->flags
= BSF_LOCAL
;
944 quick_symbol (abfd
, n1
, n2
, n3
, sec
, flags
, addr
)
954 struct bfd_link_hash_entry
*blhe
;
955 char *name
= (char *) xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
959 sym
= bfd_make_empty_symbol (abfd
);
964 symtab
[symptr
++] = sym
;
967 static arelent
*reltab
= 0;
968 static int relcount
= 0, relsize
= 0;
971 quick_reloc (abfd
, address
, which_howto
, symidx
)
977 if (relcount
>= (relsize
-1))
981 reltab
= (arelent
*) xrealloc (reltab
, relsize
* sizeof (arelent
));
983 reltab
= (arelent
*) xmalloc (relsize
* sizeof (arelent
));
985 reltab
[relcount
].address
= address
;
986 reltab
[relcount
].addend
= 0;
987 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
988 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
993 save_relocs (asection
*sec
)
996 sec
->relocation
= reltab
;
997 sec
->reloc_count
= relcount
;
998 sec
->orelocation
= (arelent
**) xmalloc ((relcount
+1) * sizeof (arelent
*));
999 for (i
=0; i
<relcount
; i
++)
1000 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1001 sec
->orelocation
[relcount
] = 0;
1002 sec
->flags
|= SEC_RELOC
;
1004 relcount
= relsize
= 0;
1009 * .global __head_my_dll
1014 * .rva __my_dll_iname
1030 asection
*id2
, *id5
, *id4
;
1031 unsigned char *d2
, *d5
, *d4
;
1035 oname
= (char *) xmalloc (20);
1036 sprintf (oname
, "d%06d.o", tmp_seq
);
1039 abfd
= bfd_create (oname
, parent
);
1040 bfd_find_target ("pe-i386", abfd
);
1041 bfd_make_writable (abfd
);
1043 bfd_set_format (abfd
, bfd_object
);
1044 bfd_set_arch_mach (abfd
, bfd_arch_i386
, 0);
1047 symtab
= (asymbol
**) xmalloc (6 * sizeof (asymbol
*));
1048 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1049 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1050 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1051 quick_symbol (abfd
, "__head_", dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1052 quick_symbol (abfd
, "_", dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1054 bfd_set_section_size (abfd
, id2
, 20);
1055 d2
= (unsigned char *) xmalloc (20);
1058 d2
[0] = d2
[16] = 4; /* reloc addend */
1059 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1060 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1061 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1064 bfd_set_section_size (abfd
, id5
, 4);
1065 d5
= (unsigned char *) xmalloc (4);
1069 bfd_set_section_size (abfd
, id4
, 4);
1070 d4
= (unsigned char *) xmalloc (4);
1074 bfd_set_symtab (abfd
, symtab
, symptr
);
1076 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1077 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1078 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1080 bfd_make_readable (abfd
);
1090 * .global __my_dll_iname
1099 asection
*id4
, *id5
, *id7
;
1100 unsigned char *d4
, *d5
, *d7
;
1105 oname
= (char *) xmalloc (20);
1106 sprintf (oname
, "d%06d.o", tmp_seq
);
1109 abfd
= bfd_create (oname
, parent
);
1110 bfd_find_target ("pe-i386", abfd
);
1111 bfd_make_writable (abfd
);
1113 bfd_set_format (abfd
, bfd_object
);
1114 bfd_set_arch_mach (abfd
, bfd_arch_i386
, 0);
1117 symtab
= (asymbol
**) xmalloc (5 * sizeof (asymbol
*));
1118 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1119 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1120 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1121 quick_symbol (abfd
, "_", dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1123 bfd_set_section_size (abfd
, id4
, 4);
1124 d4
= (unsigned char *) xmalloc (4);
1128 bfd_set_section_size (abfd
, id5
, 4);
1129 d5
= (unsigned char *) xmalloc (4);
1133 len
= strlen (dll_filename
)+1;
1136 bfd_set_section_size (abfd
, id7
, len
);
1137 d7
= (unsigned char *) xmalloc (len
);
1139 strcpy (d7
, dll_filename
);
1141 bfd_set_symtab (abfd
, symtab
, symptr
);
1143 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1144 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1145 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1147 bfd_make_readable (abfd
);
1154 * .global ___imp_function
1155 * .global __imp__function
1157 * jmp *__imp__function:
1160 * .long __head_my_dll
1171 * .asciz "function" xlate? (add underscore, kill at)
1174 static unsigned char jmp_ix86_bytes
[] = {
1175 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1180 make_one (exp
, parent
)
1181 def_file_export
*exp
;
1184 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1185 unsigned char *td
, *d7
, *d5
, *d4
, *d6
;
1190 oname
= (char *) xmalloc (20);
1191 sprintf (oname
, "d%06d.o", tmp_seq
);
1194 abfd
= bfd_create (oname
, parent
);
1195 bfd_find_target ("pe-i386", abfd
);
1196 bfd_make_writable (abfd
);
1198 bfd_set_format (abfd
, bfd_object
);
1199 bfd_set_arch_mach (abfd
, bfd_arch_i386
, 0);
1202 symtab
= (asymbol
**) xmalloc (10 * sizeof (asymbol
*));
1203 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1204 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1205 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1206 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1207 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1208 quick_symbol (abfd
, "_", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1209 quick_symbol (abfd
, "__head_", dll_symname
, "", UNDSEC
, BSF_GLOBAL
, 0);
1210 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
, BSF_GLOBAL
, 0);
1211 quick_symbol (abfd
, "__imp__", exp
->internal_name
, "", id5
, BSF_GLOBAL
, 0);
1213 bfd_set_section_size (abfd
, tx
, 8);
1214 td
= (unsigned char *) xmalloc (8);
1216 memcpy (td
, jmp_ix86_bytes
, 8);
1217 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
1220 bfd_set_section_size (abfd
, id7
, 4);
1221 d7
= (unsigned char *) xmalloc (4);
1224 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 6);
1227 bfd_set_section_size (abfd
, id5
, 4);
1228 d5
= (unsigned char *) xmalloc (4);
1231 if (exp
->flag_noname
)
1233 d5
[0] = exp
->ordinal
;
1234 d5
[1] = exp
->ordinal
>> 8;
1239 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1243 bfd_set_section_size (abfd
, id4
, 4);
1244 d4
= (unsigned char *) xmalloc (4);
1247 if (exp
->flag_noname
)
1249 d5
[0] = exp
->ordinal
;
1250 d5
[1] = exp
->ordinal
>> 8;
1255 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1259 if (exp
->flag_noname
)
1262 bfd_set_section_size (abfd
, id6
, 0);
1266 len
= strlen (exp
->name
) + 3;
1269 bfd_set_section_size (abfd
, id6
, len
);
1270 d6
= (unsigned char *) xmalloc (len
);
1272 memset (d6
, 0, len
);
1273 d6
[0] = exp
->hint
& 0xff;
1274 d6
[1] = exp
->hint
>> 8;
1275 strcpy (d6
+2, exp
->name
);
1278 bfd_set_symtab (abfd
, symtab
, symptr
);
1280 bfd_set_section_contents (abfd
, tx
, td
, 0, 4);
1281 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
1282 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1283 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1284 if (!exp
->flag_noname
)
1285 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
1287 bfd_make_readable (abfd
);
1292 pe_dll_generate_implib (def
, impfilename
)
1302 dll_filename
= def
->name
;
1303 if (dll_filename
== 0)
1305 dll_filename
= dll_name
;
1306 for (i
=0; impfilename
[i
]; i
++)
1307 if (impfilename
[i
] == '/' || impfilename
[i
] == '\\')
1308 dll_filename
= impfilename
+1;
1310 dll_symname
= xstrdup (dll_filename
);
1311 for (i
=0; dll_symname
[i
]; i
++)
1312 if (!isalnum (dll_symname
[i
]))
1313 dll_symname
[i
] = '_';
1315 unlink (impfilename
);
1317 outarch
= bfd_openw (impfilename
, 0);
1321 /* xgettext:c-format */
1322 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
1326 /* xgettext:c-format */
1327 einfo (_("Creating library file: %s\n"), impfilename
);
1329 bfd_set_format (outarch
, bfd_archive
);
1330 outarch
->has_armap
= 1;
1332 /* Work out a reasonable size of things to put onto one line. */
1334 ar_head
= make_head (outarch
);
1335 ar_tail
= make_tail (outarch
);
1337 if (ar_head
== NULL
|| ar_tail
== NULL
)
1340 for (i
= 0; i
<def
->num_exports
; i
++)
1342 /* The import library doesn't know about the internal name */
1343 char *internal
= def
->exports
[i
].internal_name
;
1345 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
1346 n
= make_one (def
->exports
+i
, outarch
);
1349 def
->exports
[i
].internal_name
= internal
;
1352 /* Now stick them all into the archive */
1354 ar_head
->next
= head
;
1355 ar_tail
->next
= ar_head
;
1358 if (! bfd_set_archive_head (outarch
, head
))
1359 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
1361 if (! bfd_close (outarch
))
1362 einfo ("%Xbfd_close %s: %s\n", impfilename
, bfd_errmsg (bfd_get_error ()));
1364 while (head
!= NULL
)
1366 bfd
*n
= head
->next
;
1373 add_bfd_to_link (abfd
, name
, link_info
)
1376 struct bfd_link_info
*link_info
;
1378 lang_input_statement_type
*fake_file
;
1379 fake_file
= lang_add_input_file (name
,
1380 lang_input_file_is_fake_enum
,
1382 fake_file
->the_bfd
= abfd
;
1383 ldlang_add_file (fake_file
);
1384 if (!bfd_link_add_symbols (abfd
, link_info
))
1385 einfo ("%Xaddsym %s: %s\n", name
, bfd_errmsg (bfd_get_error ()));
1389 pe_process_import_defs (output_bfd
, link_info
)
1391 struct bfd_link_info
*link_info
;
1393 def_file_module
*module
;
1398 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
1404 dll_filename
= module
->name
;
1405 dll_symname
= xstrdup (module
->name
);
1406 for (i
=0; dll_symname
[i
]; i
++)
1407 if (!isalnum (dll_symname
[i
]))
1408 dll_symname
[i
] = '_';
1412 for (i
=0; i
<pe_def_file
->num_imports
; i
++)
1413 if (pe_def_file
->imports
[i
].module
== module
)
1415 def_file_export exp
;
1417 struct bfd_link_hash_entry
*blhe
;
1419 /* see if we need this import */
1420 char *name
= (char *) xmalloc (strlen (pe_def_file
->imports
[i
].internal_name
) + 2);
1421 sprintf (name
, "_%s", pe_def_file
->imports
[i
].internal_name
);
1422 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
1423 false, false, false);
1425 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
1431 bfd
*ar_head
= make_head (output_bfd
);
1432 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
1435 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
1436 exp
.name
= pe_def_file
->imports
[i
].name
;
1437 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
1438 exp
.hint
= exp
.ordinal
;
1439 exp
.flag_private
= 0;
1440 exp
.flag_constant
= 0;
1442 exp
.flag_noname
= exp
.name
? 0 : 1;
1443 one
= make_one (&exp
, output_bfd
);
1444 add_bfd_to_link (one
, one
->filename
, link_info
);
1449 bfd
*ar_tail
= make_tail (output_bfd
);
1450 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
1457 /************************************************************************
1459 We were handed a *.DLL file. Parse it and turn it into a set of
1460 IMPORTS directives in the def file. Return true if the file was
1461 handled, false if not.
1463 ************************************************************************/
1466 pe_get16 (abfd
, where
)
1471 bfd_seek (abfd
, where
, SEEK_SET
);
1472 bfd_read (b
, 1, 2, abfd
);
1473 return b
[0] + (b
[1]<<8);
1477 pe_get32 (abfd
, where
)
1482 bfd_seek (abfd
, where
, SEEK_SET
);
1483 bfd_read (b
, 1, 4, abfd
);
1484 return b
[0] + (b
[1]<<8) + (b
[2]<<16) + (b
[3]<<24);
1491 unsigned char *b
= ptr
;
1492 return b
[0] + (b
[1]<<8);
1499 unsigned char *b
= ptr
;
1500 return b
[0] + (b
[1]<<8) + (b
[2]<<16) + (b
[3]<<24);
1503 extern int bfd_pe_dll_not_recognized_hack
;
1506 pe_implied_import_dll (filename
)
1510 unsigned long pe_header_offset
, opthdr_ofs
, num_entries
, i
;
1511 unsigned long export_rva
, export_size
, nsections
, secptr
, expptr
;
1512 unsigned char *expdata
, *erva
;
1513 unsigned long name_rvas
, ordinals
, nexp
, ordbase
;
1516 /* No, I can't use bfd here. kernel32.dll puts its export table in
1517 the middle of the .rdata section. */
1519 bfd_pe_dll_not_recognized_hack
= 0;
1520 dll
= bfd_openr (filename
, "pei-i386");
1523 einfo ("%Xopen %s: %s\n", filename
, bfd_errmsg (bfd_get_error ()));
1524 bfd_pe_dll_not_recognized_hack
= 1;
1527 /* PEI dlls seem to be bfd_objects */
1528 if (!bfd_check_format (dll
, bfd_object
))
1530 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
1531 bfd_pe_dll_not_recognized_hack
= 1;
1534 bfd_pe_dll_not_recognized_hack
= 1;
1535 printf("dj: importing dll %s at %x\n", filename
, dll
->where
);
1537 dll_name
= filename
;
1538 for (i
=0; filename
[i
]; i
++)
1539 if (filename
[i
] == '/' || filename
[i
] == '\\' || filename
[i
] == ':')
1540 dll_name
= filename
+ i
+ 1;
1542 pe_header_offset
= pe_get32 (dll
, 0x3c);
1543 opthdr_ofs
= pe_header_offset
+ 4 + 20;
1544 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
1545 if (num_entries
< 1) /* no exports */
1547 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
1548 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
1549 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
1550 secptr
= (pe_header_offset
+ 4 + 20 +
1551 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
1553 printf("export: rva=%08x size=%08x secptr=%08x\n",
1554 export_rva
, export_size
, secptr
);
1555 for (i
=0; i
<nsections
; i
++)
1558 unsigned long secptr1
= secptr
+ 40 * i
;
1559 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
1560 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 16);
1561 unsigned long fptr
= pe_get32 (dll
, secptr1
+ 20);
1562 bfd_seek(dll
, secptr1
, SEEK_SET
);
1563 bfd_read(sname
, 1, 8, dll
);
1564 printf("sec: %.8s addr=%08x size=%08x fptr=%08x\n",
1565 sname
, vaddr
, vsize
, fptr
);
1566 if (vaddr
<= export_rva
&& vaddr
+vsize
> export_rva
)
1568 expptr
= fptr
+ (export_rva
- vaddr
);
1569 if (export_rva
+ export_size
> vaddr
+ vsize
)
1570 export_size
= vsize
- (export_rva
- vaddr
);
1574 printf("expptr=%08x size=%08x\n", expptr
, export_size
);
1576 expdata
= (unsigned char *) xmalloc (export_size
);
1577 bfd_seek (dll
, expptr
, SEEK_SET
);
1578 bfd_read (expdata
, 1, export_size
, dll
);
1579 erva
= expdata
- export_rva
;
1581 if (pe_def_file
== 0)
1582 pe_def_file
= def_file_empty();
1584 nexp
= pe_as32 (expdata
+24);
1585 name_rvas
= pe_as32 (expdata
+32);
1586 ordinals
= pe_as32 (expdata
+36);
1587 ordbase
= pe_as32 (expdata
+16);
1588 printf("%d exports ob=%d\n", nexp
, ordbase
);
1589 for (i
=0; i
<nexp
; i
++)
1591 unsigned long name_rva
= pe_as32 (erva
+name_rvas
+i
*4);
1592 def_file_import
*imp
;
1593 imp
= def_file_add_import (pe_def_file
, erva
+name_rva
, dll_name
,
1600 /************************************************************************
1602 These are the main functions, called from the emulation. The first
1603 is called after the bfds are read, so we can guess at how much space
1604 we need. The second is called after everything is placed, so we
1605 can put the right values in place.
1607 ************************************************************************/
1610 pe_dll_build_sections (abfd
, info
)
1612 struct bfd_link_info
*info
;
1614 process_def_file (abfd
, info
);
1616 generate_edata (abfd
, info
);
1617 build_filler_bfd ();
1621 pe_dll_fill_sections (abfd
, info
)
1623 struct bfd_link_info
*info
;
1625 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
1627 generate_reloc (abfd
, info
);
1630 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
1632 /* Resize the sections. */
1633 lang_size_sections (stat_ptr
->head
, abs_output_section
,
1634 &stat_ptr
->head
, 0, (bfd_vma
) 0, false);
1636 /* Redo special stuff. */
1637 ldemul_after_allocation ();
1639 /* Do the assignments again. */
1640 lang_do_assignments (stat_ptr
->head
,
1642 (fill_type
) 0, (bfd_vma
) 0);
1645 fill_edata (abfd
, info
);
1647 pe_data (abfd
)->dll
= 1;
1649 edata_s
->contents
= edata_d
;
1650 reloc_s
->contents
= reloc_d
;