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 */
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
++;
347 /* xgettext:c-format */
348 einfo (_("%XCannot export %s: symbol wrong type\n"),
349 pe_def_file
->exports
[i
].internal_name
);
353 /* xgettext:c-format */
354 einfo (_("%XCannot export %s: symbol not found\n"),
355 pe_def_file
->exports
[i
].internal_name
);
361 /* For now, just export all global functions. Read DEF files later */
362 for (i
= 0; i
< num_input_bfds
; i
++)
364 for (j
= 0; j
< symtab
[i
].nsyms
; j
++)
366 if ((symtab
[i
].symbols
[j
]->flags
& (BSF_FUNCTION
| BSF_GLOBAL
))
367 == (BSF_FUNCTION
| BSF_GLOBAL
))
368 symtab
[i
].exported
[j
] = 1;
374 /************************************************************************
376 Build the bfd that will contain .edata and .reloc sections
378 ************************************************************************/
383 static lang_input_statement_type
*filler_file
;
384 filler_file
= lang_add_input_file ("dll stuff",
385 lang_input_file_is_fake_enum
,
387 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff", output_bfd
);
388 if (filler_bfd
== NULL
389 || !bfd_set_arch_mach (filler_bfd
,
390 bfd_get_arch (output_bfd
),
391 bfd_get_mach (output_bfd
)))
393 einfo ("%X%P: can not create BFD %E\n");
397 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
399 || !bfd_set_section_flags (filler_bfd
, edata_s
,
406 einfo ("%X%P: can not create .edata section: %E\n");
409 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
411 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
413 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
420 einfo ("%X%P: can not create .reloc section: %E\n");
423 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
425 ldlang_add_file (filler_file
);
428 /************************************************************************
430 Gather all the exported symbols and build the .edata section
432 ************************************************************************/
435 generate_edata (abfd
, info
)
437 struct bfd_link_info
*info
;
439 int i
, j
, next_ordinal
;
440 int name_table_size
= 0;
443 /* First, we need to know how many exported symbols there are,
444 and what the range of ordinals is. */
446 if (pe_def_file
->name
)
448 dll_name
= pe_def_file
->name
;
452 dll_name
= abfd
->filename
;
453 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
455 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
460 if (count_with_ordinals
&& max_ordinal
> count_exported
)
462 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
463 min_ordinal
= max_ordinal
- count_exported
+ 1;
468 max_ordinal
= count_exported
;
470 export_table_size
= max_ordinal
- min_ordinal
+ 1;
472 exported_symbols
= (int *) xmalloc (export_table_size
* sizeof (int));
473 for (i
= 0; i
< export_table_size
; i
++)
474 exported_symbols
[i
] = -1;
476 /* Now we need to assign ordinals to those that don't have them */
477 for (i
= 0; i
< NE
; i
++)
479 if (exported_symbol_sections
[i
])
481 if (pe_def_file
->exports
[i
].ordinal
!= -1)
483 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
484 int pi
= exported_symbols
[ei
];
487 /* xgettext:c-format */
488 einfo (_("%XError, oridinal used twice: %d (%s vs %s)\n"),
489 pe_def_file
->exports
[i
].ordinal
,
490 pe_def_file
->exports
[i
].name
,
491 pe_def_file
->exports
[pi
].name
);
493 exported_symbols
[ei
] = i
;
495 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
499 next_ordinal
= min_ordinal
;
500 for (i
= 0; i
< NE
; i
++)
501 if (exported_symbol_sections
[i
])
502 if (pe_def_file
->exports
[i
].ordinal
== -1)
504 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
506 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
507 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
510 /* OK, now we can allocate some memory */
512 edata_sz
= (40 /* directory */
513 + 4 * export_table_size
/* addresses */
514 + 4 * count_exported_byname
/* name ptrs */
515 + 2 * count_exported_byname
/* ordinals */
516 + name_table_size
+ strlen (dll_name
) + 1);
520 fill_edata (abfd
, info
)
522 struct bfd_link_info
*info
;
525 unsigned char *edirectory
;
526 unsigned long *eaddresses
;
527 unsigned long *enameptrs
;
528 unsigned short *eordinals
;
529 unsigned char *enamestr
;
531 edata_d
= (unsigned char *) xmalloc (edata_sz
);
533 /* Note use of array pointer math here */
534 edirectory
= edata_d
;
535 eaddresses
= (unsigned long *) (edata_d
+ 40);
536 enameptrs
= eaddresses
+ export_table_size
;
537 eordinals
= (unsigned short *) (enameptrs
+ count_exported_byname
);
538 enamestr
= (char *) (eordinals
+ count_exported_byname
);
540 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
542 memset (edata_d
, 0, 40);
543 if (pe_def_file
->version_major
!= -1)
545 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
546 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
548 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
549 strcpy (enamestr
, dll_name
);
550 enamestr
+= strlen (enamestr
) + 1;
551 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
552 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
553 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
554 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
555 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
556 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
558 /* Ok, now for the filling in part */
559 for (i
= 0; i
< export_table_size
; i
++)
561 int s
= exported_symbols
[i
];
564 struct sec
*ssec
= exported_symbol_sections
[s
];
565 unsigned long srva
= (exported_symbol_offsets
[s
]
566 + ssec
->output_section
->vma
567 + ssec
->output_offset
);
569 bfd_put_32 (abfd
, srva
- image_base
, (void *) (eaddresses
+ i
));
570 if (!pe_def_file
->exports
[s
].flag_noname
)
572 char *ename
= pe_def_file
->exports
[s
].name
;
573 bfd_put_32 (abfd
, ERVA (enamestr
), (void *) enameptrs
);
574 strcpy (enamestr
, ename
[0] == '_' ? ename
+ 1 : ename
);
575 enamestr
+= strlen (enamestr
) + 1;
576 bfd_put_16 (abfd
, i
, (void *) eordinals
);
584 /************************************************************************
586 Gather all the relocations and build the .reloc section
588 ************************************************************************/
591 generate_reloc (abfd
, info
)
593 struct bfd_link_info
*info
;
596 /* for .reloc stuff */
597 bfd_vma
*reloc_addresses
;
598 int total_relocs
= 0;
600 unsigned long sec_page
= (unsigned long) (-1);
601 unsigned long page_ptr
, page_count
;
607 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
608 for (s
= b
->sections
; s
; s
= s
->next
)
609 total_relocs
+= s
->reloc_count
;
611 reloc_addresses
= (unsigned long *) xmalloc (total_relocs
* sizeof (unsigned long));
615 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
618 int relsize
, nrelocs
, i
;
620 for (s
= b
->sections
; s
; s
= s
->next
)
622 unsigned long sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
626 symsize
= bfd_get_symtab_upper_bound (b
);
627 symbols
= (asymbol
**) xmalloc (symsize
);
628 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
630 relsize
= bfd_get_reloc_upper_bound (b
, s
);
631 relocs
= (arelent
**) xmalloc ((size_t) relsize
);
632 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
634 for (i
= 0; i
< nrelocs
; i
++)
636 if (!relocs
[i
]->howto
->pc_relative
)
638 switch (relocs
[i
]->howto
->bitsize
)
641 reloc_addresses
[total_relocs
++] = sec_vma
+ relocs
[i
]->address
;
644 /* xgettext:c-format */
645 einfo (_("%XError: %d-bit reloc in dll\n"),
646 relocs
[i
]->howto
->bitsize
);
652 /* Warning: the allocated symbols are remembered in BFD and reused
653 later, so don't free them! */
658 /* At this point, we have total_relocs relocation addresses in
659 reloc_addresses, which are all suitable for the .reloc section.
660 We must now create the new sections. */
662 qsort (reloc_addresses
, total_relocs
, sizeof (unsigned long), reloc_sort
);
664 for (i
= 0; i
< total_relocs
; i
++)
666 unsigned long this_page
= (reloc_addresses
[i
] >> 12);
667 if (this_page
!= sec_page
)
669 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align */
671 sec_page
= this_page
;
675 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align */
677 reloc_d
= (unsigned char *) xmalloc (reloc_sz
);
679 sec_page
= (unsigned long) (-1);
681 page_ptr
= (unsigned long) (-1);
683 for (i
= 0; i
< total_relocs
; i
++)
685 unsigned long rva
= reloc_addresses
[i
] - image_base
;
686 unsigned long this_page
= (rva
& ~0xfff);
687 if (this_page
!= sec_page
)
690 reloc_d
[reloc_sz
++] = 0;
691 if (page_ptr
!= (unsigned long) (-1))
692 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
693 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
696 sec_page
= this_page
;
699 bfd_put_16 (abfd
, (rva
& 0xfff) + 0x3000, reloc_d
+ reloc_sz
);
704 reloc_d
[reloc_sz
++] = 0;
705 if (page_ptr
!= (unsigned long) (-1))
706 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
707 while (reloc_sz
< reloc_s
->_raw_size
)
708 reloc_d
[reloc_sz
++] = 0;
711 /************************************************************************
713 Given the exiting def_file structure, print out a .DEF file that
716 ************************************************************************/
719 quoteput (s
, f
, needs_quotes
)
725 for (cp
= s
; *cp
; cp
++)
726 if (*cp
== '\'' || *cp
== '"' || *cp
== '\\' || isspace (*cp
) || *cp
== ','
734 if (*s
== '"' || *s
== '\\')
746 pe_dll_generate_def_file (pe_out_def_filename
)
747 char *pe_out_def_filename
;
750 FILE *out
= fopen (pe_out_def_filename
, "w");
753 /* xgettext:c-format */
754 einfo (_("%s: Can't open output def file %s\n"),
755 program_name
, pe_out_def_filename
);
758 if (pe_def_file
->name
)
760 if (pe_def_file
->is_dll
)
761 fprintf (out
, "LIBRARY ");
763 fprintf (out
, "NAME ");
764 quoteput (pe_def_file
->name
, out
, 1);
765 if (pe_def_file
->base_address
!= (bfd_vma
) (-1))
766 fprintf (out
, " BASE=0x%x", pe_def_file
->base_address
);
770 if (pe_def_file
->description
)
772 fprintf (out
, "DESCRIPTION ");
773 quoteput (pe_def_file
->description
, out
, 1);
777 if (pe_def_file
->version_minor
)
778 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
779 pe_def_file
->version_minor
);
781 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
783 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
786 if (pe_def_file
->stack_commit
!= -1)
787 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
788 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
789 else if (pe_def_file
->stack_reserve
!= -1)
790 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
791 if (pe_def_file
->heap_commit
!= -1)
792 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
793 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
794 else if (pe_def_file
->heap_reserve
!= -1)
795 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
797 if (pe_def_file
->num_section_defs
> 0)
799 fprintf (out
, "\nSECTIONS\n\n");
800 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
803 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
804 if (pe_def_file
->section_defs
[i
].class)
806 fprintf (out
, " CLASS ");
807 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
809 if (pe_def_file
->section_defs
[i
].flag_read
)
810 fprintf (out
, " READ");
811 if (pe_def_file
->section_defs
[i
].flag_write
)
812 fprintf (out
, " WRITE");
813 if (pe_def_file
->section_defs
[i
].flag_execute
)
814 fprintf (out
, " EXECUTE");
815 if (pe_def_file
->section_defs
[i
].flag_shared
)
816 fprintf (out
, " SHARED");
821 if (pe_def_file
->num_exports
> 0)
823 fprintf (out
, "\nEXPORTS\n\n");
824 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
826 def_file_export
*e
= pe_def_file
->exports
+ i
;
828 quoteput (e
->name
, out
, 0);
829 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
831 fprintf (out
, " = ");
832 quoteput (e
->internal_name
, out
, 0);
834 if (e
->ordinal
!= -1)
835 fprintf (out
, " @%d", e
->ordinal
);
837 fprintf (out
, " PRIVATE");
838 if (e
->flag_constant
)
839 fprintf (out
, " CONSTANT");
841 fprintf (out
, " NONAME");
843 fprintf (out
, " DATA");
849 if (pe_def_file
->num_imports
> 0)
851 fprintf (out
, "\nIMPORTS\n\n");
852 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
854 def_file_import
*im
= pe_def_file
->imports
+ i
;
856 if (im
->internal_name
857 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
859 quoteput (im
->internal_name
, out
, 0);
860 fprintf (out
, " = ");
862 quoteput (im
->module
, out
, 0);
865 quoteput (im
->name
, out
, 0);
867 fprintf (out
, "%d", im
->ordinal
);
872 if (fclose (out
) == EOF
)
874 /* xgettext:c-format */
875 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
879 /************************************************************************
881 These are the main functions, called from the emulation. The first
882 is called after the bfds are read, so we can guess at how much space
883 we need. The second is called after everything is placed, so we
884 can put the right values in place.
886 ************************************************************************/
889 pe_dll_build_sections (abfd
, info
)
891 struct bfd_link_info
*info
;
893 process_def_file (abfd
, info
);
895 generate_edata (abfd
, info
);
900 pe_dll_fill_sections (abfd
, info
)
902 struct bfd_link_info
*info
;
904 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
906 generate_reloc (abfd
, info
);
909 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
911 /* Resize the sections. */
912 lang_size_sections (stat_ptr
->head
, abs_output_section
,
913 &stat_ptr
->head
, 0, (bfd_vma
) 0, false);
915 /* Redo special stuff. */
916 ldemul_after_allocation ();
918 /* Do the assignments again. */
919 lang_do_assignments (stat_ptr
->head
,
921 (fill_type
) 0, (bfd_vma
) 0);
924 fill_edata (abfd
, info
);
926 pe_data (abfd
)->dll
= 1;
928 edata_s
->contents
= edata_d
;
929 reloc_s
->contents
= reloc_d
;