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 */
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! */
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_def_file
->base_address
!= (bfd_vma
) (-1))
783 fprintf (out
, " BASE=0x%x", pe_def_file
->base_address
);
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
)
795 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
796 pe_def_file
->version_minor
);
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
;
912 quick_section(abfd
, name
, flags
, align
)
921 sec
= bfd_make_section_old_way(abfd
, name
);
922 sec
->output_section
= sec
;
923 bfd_set_section_flags (abfd
, sec
, flags
);
924 bfd_set_section_alignment (abfd
, sec
, align
);
926 sym
= bfd_make_empty_symbol(abfd
);
927 symtab
[symptr
++] = sym
;
928 sym
->name
= sec
->name
;
930 sym
->flags
= BSF_LOCAL
;
937 quick_symbol (abfd
, n1
, n2
, n3
, sec
, flags
, addr
)
946 asymbol
*sym
= bfd_make_empty_symbol(abfd
);
947 char *name
= (char *) xmalloc (strlen(n1
) + strlen(n2
) + strlen(n3
) + 1);
955 symtab
[symptr
++] = sym
;
958 static arelent
**reltab
= 0;
959 static int relcount
= 0, relsize
= 0;
962 quick_reloc (abfd
, address
, which_howto
, symidx
)
968 if (relcount
>= (relsize
-1))
972 reltab
= (arelent
**) xrealloc (reltab
, relsize
* sizeof (arelent
*));
974 reltab
= (arelent
**) xmalloc (relsize
* sizeof (arelent
*));
976 reltab
[relcount
] = (arelent
*) xmalloc (sizeof (arelent
));
977 reltab
[relcount
]->address
= address
;
978 reltab
[relcount
]->addend
= 0;
979 reltab
[relcount
]->howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
980 reltab
[relcount
]->sym_ptr_ptr
= symtab
+ symidx
;
985 save_relocs (asection
*sec
)
987 reltab
[relcount
] = 0;
988 sec
->orelocation
= reltab
;
989 sec
->reloc_count
= relcount
;
991 relcount
= relsize
= 0;
994 #define UNDSEC (asection *) &bfd_und_section
998 * .global __head_my_dll
1003 * .rva __my_dll_iname
1015 #define BFD_OPEN_OLDWAY 0
1021 asection
*id2
, *id5
, *id4
;
1022 unsigned char *d2
, *d5
, *d4
;
1025 bfd
*abfd
= bfd_openw ("dh.o", 0);
1027 bfd
*abfd
= bfd_create ("dh.o", parent
);
1028 bfd_make_writable (abfd
);
1030 bfd_set_format (abfd
, bfd_object
);
1031 bfd_set_arch_mach (abfd
, bfd_arch_i386
, 0);
1034 symtab
= (asymbol
**) xmalloc (6 * sizeof (asymbol
*));
1035 id2
= quick_section(abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1036 id5
= quick_section(abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1037 id4
= quick_section(abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1038 quick_symbol (abfd
, "__head_", dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1039 quick_symbol (abfd
, "_", dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1041 bfd_set_section_size(abfd
, id2
, 20);
1042 d2
= (unsigned char *) xmalloc (20);
1044 d2
[0] = d2
[16] = 4; /* reloc addend */
1045 quick_reloc(abfd
, 0, BFD_RELOC_RVA
, 2);
1046 quick_reloc(abfd
, 12, BFD_RELOC_RVA
, 4);
1047 quick_reloc(abfd
, 16, BFD_RELOC_RVA
, 1);
1050 bfd_set_section_size (abfd
, id5
, 4);
1051 d5
= (unsigned char *) xmalloc (4);
1054 bfd_set_section_size (abfd
, id4
, 4);
1055 d4
= (unsigned char *) xmalloc (4);
1058 bfd_set_symtab(abfd
, symtab
, symptr
);
1060 bfd_set_section_contents(abfd
, id2
, d2
, 0, 20);
1061 bfd_set_section_contents(abfd
, id5
, d5
, 0, 4);
1062 bfd_set_section_contents(abfd
, id4
, d4
, 0, 4);
1066 return bfd_openr("dh.o", 0);
1068 bfd_make_readable (abfd
);
1079 * .global __my_dll_iname
1088 asection
*id4
, *id5
, *id7
;
1089 unsigned char *d4
, *d5
, *d7
;
1093 bfd
*abfd
= bfd_openw ("dt.o", 0);
1095 bfd
*abfd
= bfd_create ("dt.o", parent
);
1096 bfd_make_writable (abfd
);
1098 bfd_set_format (abfd
, bfd_object
);
1099 bfd_set_arch_mach (abfd
, bfd_arch_i386
, 0);
1102 symtab
= (asymbol
**) xmalloc (5 * sizeof (asymbol
*));
1103 id4
= quick_section(abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1104 id5
= quick_section(abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1105 id7
= quick_section(abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1106 quick_symbol (abfd
, "_", dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1108 bfd_set_section_size(abfd
, id4
, 4);
1109 d4
= (unsigned char *) xmalloc (4);
1112 bfd_set_section_size (abfd
, id5
, 4);
1113 d5
= (unsigned char *) xmalloc (4);
1116 len
= strlen(dll_filename
)+1;
1119 bfd_set_section_size (abfd
, id7
, len
);
1120 d7
= (unsigned char *) xmalloc (len
);
1121 strcpy (d7
, dll_filename
);
1123 bfd_set_symtab(abfd
, symtab
, symptr
);
1125 bfd_set_section_contents(abfd
, id4
, d4
, 0, 4);
1126 bfd_set_section_contents(abfd
, id5
, d5
, 0, 4);
1127 bfd_set_section_contents(abfd
, id7
, d7
, 0, len
);
1131 return bfd_openr ("dt.o", 0);
1133 bfd_make_readable (abfd
);
1141 * .global ___imp_function
1142 * .global __imp__function
1144 * jmp *__imp__function:
1147 * .long __head_my_dll
1158 * .asciz "function" xlate? (add underscore, kill at)
1161 unsigned char jmp_ix86_bytes
[] = {
1162 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1167 make_one (exp
, parent
)
1168 def_file_export
*exp
;
1171 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1172 unsigned char *td
, *d7
, *d5
, *d4
, *d6
;
1177 oname
= (char *) xmalloc (20);
1178 sprintf(oname
, "ds%d.o", tmp_seq
);
1181 abfd
= bfd_openw (oname
, 0);
1183 abfd
= bfd_create (oname
, parent
);
1184 bfd_make_writable (abfd
);
1186 bfd_set_format (abfd
, bfd_object
);
1187 bfd_set_arch_mach (abfd
, bfd_arch_i386
, 0);
1190 symtab
= (asymbol
**) xmalloc (10 * sizeof (asymbol
*));
1191 tx
= quick_section(abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1192 id7
= quick_section(abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1193 id5
= quick_section(abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1194 id4
= quick_section(abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1195 id6
= quick_section(abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1196 quick_symbol (abfd
, "_", exp
->name
, "", tx
, BSF_GLOBAL
, 0);
1197 quick_symbol (abfd
, "__head_", dll_symname
, "", UNDSEC
, BSF_GLOBAL
, 0);
1198 quick_symbol (abfd
, "___imp_", exp
->name
, "", id5
, BSF_GLOBAL
, 0);
1199 quick_symbol (abfd
, "__imp__", exp
->name
, "", id5
, BSF_GLOBAL
, 0);
1201 bfd_set_section_size (abfd
, tx
, 8);
1202 td
= (unsigned char *) xmalloc (8);
1203 memcpy (td
, jmp_ix86_bytes
, 8);
1204 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
1207 bfd_set_section_size(abfd
, id7
, 4);
1208 d7
= (unsigned char *) xmalloc (4);
1210 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 6);
1213 bfd_set_section_size (abfd
, id5
, 4);
1214 d5
= (unsigned char *) xmalloc (4);
1216 if (exp
->flag_noname
)
1218 d5
[0] = exp
->ordinal
;
1219 d5
[1] = exp
->ordinal
>> 8;
1224 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1228 bfd_set_section_size (abfd
, id4
, 4);
1229 d4
= (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 if (exp
->flag_noname
)
1246 bfd_set_section_size(abfd
, id6
, 0);
1250 len
= strlen(exp
->name
) + 3;
1253 bfd_set_section_size(abfd
, id6
, len
);
1254 d6
= (unsigned char *) xmalloc (len
);
1255 memset (d6
, 0, len
);
1256 d6
[0] = exp
->hint
& 0xff;
1257 d6
[1] = exp
->hint
>> 8;
1258 strcpy(d6
+2, exp
->name
);
1261 bfd_set_symtab(abfd
, symtab
, symptr
);
1263 bfd_set_section_contents(abfd
, tx
, td
, 0, 8);
1264 bfd_set_section_contents(abfd
, id7
, d7
, 0, 4);
1265 bfd_set_section_contents(abfd
, id5
, d5
, 0, 4);
1266 bfd_set_section_contents(abfd
, id4
, d4
, 0, 4);
1267 bfd_set_section_contents(abfd
, id6
, d6
, 0, len
);
1271 return bfd_openr(oname
, 0);
1273 bfd_make_readable (abfd
);
1279 pe_dll_generate_implib (def
, impfilename
)
1284 /*export_type *exp;*/
1290 dll_filename
= def
->name
;
1291 if (dll_filename
== 0)
1293 dll_filename
= dll_name
;
1294 for (i
=0; impfilename
[i
]; i
++)
1295 if (impfilename
[i
] == '/' || impfilename
[i
] == '\\')
1296 dll_filename
= impfilename
+1;
1298 dll_symname
= xstrdup (dll_filename
);
1299 for (i
=0; dll_symname
[i
]; i
++)
1300 if (!isalnum (dll_symname
[i
]))
1301 dll_symname
[i
] = '_';
1303 unlink (impfilename
);
1305 outarch
= bfd_openw (impfilename
, 0);
1309 /* xgettext:c-format */
1310 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
1314 /* xgettext:c-format */
1315 einfo (_("Creating library file: %s\n"), impfilename
);
1317 bfd_set_format (outarch
, bfd_archive
);
1318 outarch
->has_armap
= 1;
1320 /* Work out a reasonable size of things to put onto one line. */
1322 ar_head
= make_head (outarch
);
1323 ar_tail
= make_tail (outarch
);
1325 if (ar_head
== NULL
|| ar_tail
== NULL
)
1328 for (i
= 0; i
<def
->num_exports
; i
++)
1330 bfd
*n
= make_one (def
->exports
+i
, outarch
);
1335 /* Now stick them all into the archive */
1337 ar_head
->next
= head
;
1338 ar_tail
->next
= ar_head
;
1341 if (! bfd_set_archive_head (outarch
, head
))
1342 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
1344 if (! bfd_close (outarch
))
1345 einfo ("%Xbfd_close %s: %s\n", impfilename
, bfd_errmsg (bfd_get_error ()));
1347 while (head
!= NULL
)
1349 bfd
*n
= head
->next
;
1357 for (i
=0; i
<tmp_seq
; i
++)
1360 sprintf (buf
, "ds%d.o", i
);
1366 /************************************************************************
1368 These are the main functions, called from the emulation. The first
1369 is called after the bfds are read, so we can guess at how much space
1370 we need. The second is called after everything is placed, so we
1371 can put the right values in place.
1373 ************************************************************************/
1376 pe_dll_build_sections (abfd
, info
)
1378 struct bfd_link_info
*info
;
1380 process_def_file (abfd
, info
);
1382 generate_edata (abfd
, info
);
1383 build_filler_bfd ();
1387 pe_dll_fill_sections (abfd
, info
)
1389 struct bfd_link_info
*info
;
1391 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
1393 generate_reloc (abfd
, info
);
1396 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
1398 /* Resize the sections. */
1399 lang_size_sections (stat_ptr
->head
, abs_output_section
,
1400 &stat_ptr
->head
, 0, (bfd_vma
) 0, false);
1402 /* Redo special stuff. */
1403 ldemul_after_allocation ();
1405 /* Do the assignments again. */
1406 lang_do_assignments (stat_ptr
->head
,
1408 (fill_type
) 0, (bfd_vma
) 0);
1411 fill_edata (abfd
, info
);
1413 pe_data (abfd
)->dll
= 1;
1415 edata_s
->contents
= edata_d
;
1416 reloc_s
->contents
= reloc_d
;