2007-09-09 H.J. Lu <hongjiu.lu@intel.com>
[binutils.git] / ld / pe-dll.c
blobcdbfa70f0e346bc10d6db1796bc50fb04c232d21
1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Written by DJ Delorie <dj@cygnus.com>
6 This file is part of the GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libiberty.h"
27 #include "safe-ctype.h"
29 #include <time.h>
31 #include "ld.h"
32 #include "ldexp.h"
33 #include "ldlang.h"
34 #include "ldwrite.h"
35 #include "ldmisc.h"
36 #include <ldgram.h>
37 #include "ldmain.h"
38 #include "ldfile.h"
39 #include "ldemul.h"
40 #include "coff/internal.h"
41 #include "../bfd/libcoff.h"
42 #include "deffile.h"
43 #include "pe-dll.h"
45 #ifdef pe_use_x86_64
47 #define PE_IDATA4_SIZE 8
48 #define PE_IDATA5_SIZE 8
49 #include "pep-dll.h"
50 #undef AOUTSZ
51 #define AOUTSZ PEPAOUTSZ
52 #define PEAOUTHDR PEPAOUTHDR
54 #else
56 #include "pe-dll.h"
58 #endif
60 #ifndef PE_IDATA4_SIZE
61 #define PE_IDATA4_SIZE 4
62 #endif
64 #ifndef PE_IDATA5_SIZE
65 #define PE_IDATA5_SIZE 4
66 #endif
68 /* This file turns a regular Windows PE image into a DLL. Because of
69 the complexity of this operation, it has been broken down into a
70 number of separate modules which are all called by the main function
71 at the end of this file. This function is not re-entrant and is
72 normally only called once, so static variables are used to reduce
73 the number of parameters and return values required.
75 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
77 /* Auto-import feature by Paul Sokolovsky
79 Quick facts:
81 1. With this feature on, DLL clients can import variables from DLL
82 without any concern from their side (for example, without any source
83 code modifications).
85 2. This is done completely in bounds of the PE specification (to be fair,
86 there's a place where it pokes nose out of, but in practice it works).
87 So, resulting module can be used with any other PE compiler/linker.
89 3. Auto-import is fully compatible with standard import method and they
90 can be mixed together.
92 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
93 reference to it; load time: negligible; virtual/physical memory: should be
94 less than effect of DLL relocation, and I sincerely hope it doesn't affect
95 DLL sharability (too much).
97 Idea
99 The obvious and only way to get rid of dllimport insanity is to make client
100 access variable directly in the DLL, bypassing extra dereference. I.e.,
101 whenever client contains something like
103 mov dll_var,%eax,
105 address of dll_var in the command should be relocated to point into loaded
106 DLL. The aim is to make OS loader do so, and than make ld help with that.
107 Import section of PE made following way: there's a vector of structures
108 each describing imports from particular DLL. Each such structure points
109 to two other parallel vectors: one holding imported names, and one which
110 will hold address of corresponding imported name. So, the solution is
111 de-vectorize these structures, making import locations be sparse and
112 pointing directly into code. Before continuing, it is worth a note that,
113 while authors strives to make PE act ELF-like, there're some other people
114 make ELF act PE-like: elfvector, ;-) .
116 Implementation
118 For each reference of data symbol to be imported from DLL (to set of which
119 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
120 import fixup entry is generated. That entry is of type
121 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
122 fixup entry contains pointer to symbol's address within .text section
123 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
124 (so, DLL name is referenced by multiple entries), and pointer to symbol
125 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
126 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
127 containing imported name. Here comes that "on the edge" problem mentioned
128 above: PE specification rambles that name vector (OriginalFirstThunk)
129 should run in parallel with addresses vector (FirstThunk), i.e. that they
130 should have same number of elements and terminated with zero. We violate
131 this, since FirstThunk points directly into machine code. But in practice,
132 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
133 puts addresses to FirstThunk, not something else. It once again should be
134 noted that dll and symbol name structures are reused across fixup entries
135 and should be there anyway to support standard import stuff, so sustained
136 overhead is 20 bytes per reference. Other question is whether having several
137 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
138 done even by native compiler/linker (libth32's functions are in fact reside
139 in windows9x kernel32.dll, so if you use it, you have two
140 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
141 referencing the same PE structures several times is valid. The answer is why
142 not, prohibiting that (detecting violation) would require more work on
143 behalf of loader than not doing it.
145 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
147 static void add_bfd_to_link (bfd *, const char *, struct bfd_link_info *);
149 /* For emultempl/pe.em. */
151 def_file * pe_def_file = 0;
152 int pe_dll_export_everything = 0;
153 int pe_dll_do_default_excludes = 1;
154 int pe_dll_kill_ats = 0;
155 int pe_dll_stdcall_aliases = 0;
156 int pe_dll_warn_dup_exports = 0;
157 int pe_dll_compat_implib = 0;
158 int pe_dll_extra_pe_debug = 0;
160 /* Static variables and types. */
162 static bfd_vma image_base;
163 static bfd *filler_bfd;
164 static struct bfd_section *edata_s, *reloc_s;
165 static unsigned char *edata_d, *reloc_d;
166 static size_t edata_sz, reloc_sz;
167 static int runtime_pseudo_relocs_created = 0;
169 typedef struct
171 const char *name;
172 int len;
174 autofilter_entry_type;
176 typedef struct
178 const char *target_name;
179 const char *object_target;
180 unsigned int imagebase_reloc;
181 int pe_arch;
182 int bfd_arch;
183 bfd_boolean underscored;
184 const autofilter_entry_type* autofilter_symbollist;
186 pe_details_type;
188 static const autofilter_entry_type autofilter_symbollist_generic[] =
190 { STRING_COMMA_LEN (".text") },
191 /* Entry point symbols. */
192 { STRING_COMMA_LEN ("DllMain") },
193 { STRING_COMMA_LEN ("DllMainCRTStartup") },
194 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
195 /* Runtime pseudo-reloc. */
196 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
197 { STRING_COMMA_LEN ("do_pseudo_reloc") },
198 { STRING_COMMA_LEN (NULL) }
201 static const autofilter_entry_type autofilter_symbollist_i386[] =
203 { STRING_COMMA_LEN (".text") },
204 /* Entry point symbols, and entry hooks. */
205 { STRING_COMMA_LEN ("cygwin_crt0") },
206 #ifdef pe_use_x86_64
207 { STRING_COMMA_LEN ("DllMain") },
208 { STRING_COMMA_LEN ("DllEntryPoint") },
209 { STRING_COMMA_LEN ("DllMainCRTStartup") },
210 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
211 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
212 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
213 #else
214 { STRING_COMMA_LEN ("DllMain@12") },
215 { STRING_COMMA_LEN ("DllEntryPoint@0") },
216 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
217 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
218 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
219 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
220 { STRING_COMMA_LEN ("cygwin_attach_dll") },
221 #endif
222 { STRING_COMMA_LEN ("cygwin_premain0") },
223 { STRING_COMMA_LEN ("cygwin_premain1") },
224 { STRING_COMMA_LEN ("cygwin_premain2") },
225 { STRING_COMMA_LEN ("cygwin_premain3") },
226 /* Runtime pseudo-reloc. */
227 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
228 { STRING_COMMA_LEN ("do_pseudo_reloc") },
229 /* Global vars that should not be exported. */
230 { STRING_COMMA_LEN ("impure_ptr") },
231 { STRING_COMMA_LEN ("_impure_ptr") },
232 { STRING_COMMA_LEN ("_fmode") },
233 { STRING_COMMA_LEN ("environ") },
234 { STRING_COMMA_LEN (NULL) }
237 #define PE_ARCH_i386 1
238 #define PE_ARCH_sh 2
239 #define PE_ARCH_mips 3
240 #define PE_ARCH_arm 4
241 #define PE_ARCH_arm_epoc 5
242 #define PE_ARCH_arm_wince 6
244 static const pe_details_type pe_detail_list[] =
247 #ifdef pe_use_x86_64
248 "pei-x86-64",
249 "pe-x86-64",
250 3 /* R_IMAGEBASE */,
251 #else
252 "pei-i386",
253 "pe-i386",
254 7 /* R_IMAGEBASE */,
255 #endif
256 PE_ARCH_i386,
257 bfd_arch_i386,
258 TRUE,
259 autofilter_symbollist_i386
262 "pei-shl",
263 "pe-shl",
264 16 /* R_SH_IMAGEBASE */,
265 PE_ARCH_sh,
266 bfd_arch_sh,
267 TRUE,
268 autofilter_symbollist_generic
271 "pei-mips",
272 "pe-mips",
273 34 /* MIPS_R_RVA */,
274 PE_ARCH_mips,
275 bfd_arch_mips,
276 FALSE,
277 autofilter_symbollist_generic
280 "pei-arm-little",
281 "pe-arm-little",
282 11 /* ARM_RVA32 */,
283 PE_ARCH_arm,
284 bfd_arch_arm,
285 TRUE,
286 autofilter_symbollist_generic
289 "epoc-pei-arm-little",
290 "epoc-pe-arm-little",
291 11 /* ARM_RVA32 */,
292 PE_ARCH_arm_epoc,
293 bfd_arch_arm,
294 FALSE,
295 autofilter_symbollist_generic
298 "pei-arm-wince-little",
299 "pe-arm-wince-little",
300 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
301 PE_ARCH_arm_wince,
302 bfd_arch_arm,
303 FALSE,
304 autofilter_symbollist_generic
306 { NULL, NULL, 0, 0, 0, FALSE, NULL }
309 static const pe_details_type *pe_details;
311 /* Do not specify library suffix explicitly, to allow for dllized versions. */
312 static const autofilter_entry_type autofilter_liblist[] =
314 { STRING_COMMA_LEN ("libcegcc") },
315 { STRING_COMMA_LEN ("libcygwin") },
316 { STRING_COMMA_LEN ("libgcc") },
317 { STRING_COMMA_LEN ("libstdc++") },
318 { STRING_COMMA_LEN ("libmingw32") },
319 { STRING_COMMA_LEN ("libmingwex") },
320 { STRING_COMMA_LEN ("libg2c") },
321 { STRING_COMMA_LEN ("libsupc++") },
322 { STRING_COMMA_LEN ("libobjc") },
323 { STRING_COMMA_LEN ("libgcj") },
324 { STRING_COMMA_LEN (NULL) }
327 static const autofilter_entry_type autofilter_objlist[] =
329 { STRING_COMMA_LEN ("crt0.o") },
330 { STRING_COMMA_LEN ("crt1.o") },
331 { STRING_COMMA_LEN ("crt2.o") },
332 { STRING_COMMA_LEN ("dllcrt1.o") },
333 { STRING_COMMA_LEN ("dllcrt2.o") },
334 { STRING_COMMA_LEN ("gcrt0.o") },
335 { STRING_COMMA_LEN ("gcrt1.o") },
336 { STRING_COMMA_LEN ("gcrt2.o") },
337 { STRING_COMMA_LEN ("crtbegin.o") },
338 { STRING_COMMA_LEN ("crtend.o") },
339 { STRING_COMMA_LEN (NULL) }
342 static const autofilter_entry_type autofilter_symbolprefixlist[] =
344 /* _imp_ is treated specially, as it is always underscored. */
345 /* { STRING_COMMA_LEN ("_imp_") }, */
346 /* Don't export some c++ symbols. */
347 { STRING_COMMA_LEN ("__rtti_") },
348 { STRING_COMMA_LEN ("__builtin_") },
349 /* Don't re-export auto-imported symbols. */
350 { STRING_COMMA_LEN ("_nm_") },
351 /* Don't export symbols specifying internal DLL layout. */
352 { STRING_COMMA_LEN ("_head_") },
353 { STRING_COMMA_LEN (NULL) }
356 static const autofilter_entry_type autofilter_symbolsuffixlist[] =
358 { STRING_COMMA_LEN ("_iname") },
359 { STRING_COMMA_LEN (NULL) }
362 #define U(str) (pe_details->underscored ? "_" str : str)
364 void
365 pe_dll_id_target (const char *target)
367 int i;
369 for (i = 0; pe_detail_list[i].target_name; i++)
370 if (strcmp (pe_detail_list[i].target_name, target) == 0
371 || strcmp (pe_detail_list[i].object_target, target) == 0)
373 pe_details = pe_detail_list + i;
374 return;
376 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
377 exit (1);
380 /* Helper functions for qsort. Relocs must be sorted so that we can write
381 them out by pages. */
383 typedef struct
385 bfd_vma vma;
386 char type;
387 short extra;
389 reloc_data_type;
391 static int
392 reloc_sort (const void *va, const void *vb)
394 bfd_vma a = ((const reloc_data_type *) va)->vma;
395 bfd_vma b = ((const reloc_data_type *) vb)->vma;
397 return (a > b) ? 1 : ((a < b) ? -1 : 0);
400 static int
401 pe_export_sort (const void *va, const void *vb)
403 const def_file_export *a = va;
404 const def_file_export *b = vb;
406 return strcmp (a->name, b->name);
409 /* Read and process the .DEF file. */
411 /* These correspond to the entries in pe_def_file->exports[]. I use
412 exported_symbol_sections[i] to tag whether or not the symbol was
413 defined, since we can't export symbols we don't have. */
415 static bfd_vma *exported_symbol_offsets;
416 static struct bfd_section **exported_symbol_sections;
417 static int export_table_size;
418 static int count_exported;
419 static int count_exported_byname;
420 static int count_with_ordinals;
421 static const char *dll_name;
422 static int min_ordinal, max_ordinal;
423 static int *exported_symbols;
425 typedef struct exclude_list_struct
427 char *string;
428 struct exclude_list_struct *next;
429 int type;
431 exclude_list_struct;
433 static struct exclude_list_struct *excludes = 0;
435 void
436 pe_dll_add_excludes (const char *new_excludes, const int type)
438 char *local_copy;
439 char *exclude_string;
441 local_copy = xstrdup (new_excludes);
443 exclude_string = strtok (local_copy, ",:");
444 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
446 struct exclude_list_struct *new_exclude;
448 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
449 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
450 strcpy (new_exclude->string, exclude_string);
451 new_exclude->type = type;
452 new_exclude->next = excludes;
453 excludes = new_exclude;
456 free (local_copy);
459 static bfd_boolean
460 is_import (const char* n)
462 return (CONST_STRNEQ (n, "__imp_"));
465 /* abfd is a bfd containing n (or NULL)
466 It can be used for contextual checks. */
468 static int
469 auto_export (bfd *abfd, def_file *d, const char *n)
471 int i;
472 struct exclude_list_struct *ex;
473 const autofilter_entry_type *afptr;
474 const char * libname = 0;
475 if (abfd && abfd->my_archive)
476 libname = lbasename (abfd->my_archive->filename);
478 for (i = 0; i < d->num_exports; i++)
479 if (strcmp (d->exports[i].name, n) == 0)
480 return 0;
482 if (pe_dll_do_default_excludes)
484 const char * p;
485 int len;
487 if (pe_dll_extra_pe_debug)
488 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
489 n, abfd, abfd->my_archive);
491 /* First of all, make context checks:
492 Don't export anything from standard libs. */
493 if (libname)
495 afptr = autofilter_liblist;
497 while (afptr->name)
499 if (strncmp (libname, afptr->name, afptr->len) == 0 )
500 return 0;
501 afptr++;
505 /* Next, exclude symbols from certain startup objects. */
507 if (abfd && (p = lbasename (abfd->filename)))
509 afptr = autofilter_objlist;
510 while (afptr->name)
512 if (strcmp (p, afptr->name) == 0)
513 return 0;
514 afptr++;
518 /* Don't try to blindly exclude all symbols
519 that begin with '__'; this was tried and
520 it is too restrictive. Instead we have
521 a target specific list to use: */
522 afptr = pe_details->autofilter_symbollist;
524 while (afptr->name)
526 if (strcmp (n, afptr->name) == 0)
527 return 0;
529 afptr++;
532 /* Next, exclude symbols starting with ... */
533 afptr = autofilter_symbolprefixlist;
534 while (afptr->name)
536 if (strncmp (n, afptr->name, afptr->len) == 0)
537 return 0;
539 afptr++;
542 /* Finally, exclude symbols ending with ... */
543 len = strlen (n);
544 afptr = autofilter_symbolsuffixlist;
545 while (afptr->name)
547 if ((len >= afptr->len)
548 /* Add 1 to insure match with trailing '\0'. */
549 && strncmp (n + len - afptr->len, afptr->name,
550 afptr->len + 1) == 0)
551 return 0;
553 afptr++;
557 for (ex = excludes; ex; ex = ex->next)
559 if (ex->type == 1) /* exclude-libs */
561 if (libname
562 && ((strcmp (libname, ex->string) == 0)
563 || (strcasecmp ("ALL", ex->string) == 0)))
564 return 0;
566 else if (strcmp (n, ex->string) == 0)
567 return 0;
570 return 1;
573 static void
574 process_def_file (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
576 int i, j;
577 struct bfd_link_hash_entry *blhe;
578 bfd *b;
579 struct bfd_section *s;
580 def_file_export *e = 0;
582 if (!pe_def_file)
583 pe_def_file = def_file_empty ();
585 /* First, run around to all the objects looking for the .drectve
586 sections, and push those into the def file too. */
587 for (b = info->input_bfds; b; b = b->link_next)
589 s = bfd_get_section_by_name (b, ".drectve");
590 if (s)
592 long size = s->size;
593 char *buf = xmalloc (size);
595 bfd_get_section_contents (b, s, buf, 0, size);
596 def_file_add_directive (pe_def_file, buf, size);
597 free (buf);
601 /* If we are not building a DLL, when there are no exports
602 we do not build an export table at all. */
603 if (!pe_dll_export_everything && pe_def_file->num_exports == 0
604 && info->executable)
605 return;
607 /* Now, maybe export everything else the default way. */
608 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
610 for (b = info->input_bfds; b; b = b->link_next)
612 asymbol **symbols;
613 int nsyms, symsize;
615 symsize = bfd_get_symtab_upper_bound (b);
616 symbols = xmalloc (symsize);
617 nsyms = bfd_canonicalize_symtab (b, symbols);
619 for (j = 0; j < nsyms; j++)
621 /* We should export symbols which are either global or not
622 anything at all. (.bss data is the latter)
623 We should not export undefined symbols. */
624 if (symbols[j]->section != &bfd_und_section
625 && ((symbols[j]->flags & BSF_GLOBAL)
626 || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
628 const char *sn = symbols[j]->name;
630 /* We should not re-export imported stuff. */
632 char *name;
633 if (is_import (sn))
634 continue;
636 name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
637 sprintf (name, "%s%s", "__imp_", sn);
639 blhe = bfd_link_hash_lookup (info->hash, name,
640 FALSE, FALSE, FALSE);
641 free (name);
643 if (blhe && blhe->type == bfd_link_hash_defined)
644 continue;
647 if (pe_details->underscored && *sn == '_')
648 sn++;
650 if (auto_export (b, pe_def_file, sn))
652 def_file_export *p;
653 p=def_file_add_export (pe_def_file, sn, 0, -1);
654 /* Fill data flag properly, from dlltool.c. */
655 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
662 #undef NE
663 #define NE pe_def_file->num_exports
665 /* Canonicalize the export list. */
666 if (pe_dll_kill_ats)
668 for (i = 0; i < NE; i++)
670 if (strchr (pe_def_file->exports[i].name, '@'))
672 /* This will preserve internal_name, which may have been
673 pointing to the same memory as name, or might not
674 have. */
675 int lead_at = (*pe_def_file->exports[i].name == '@');
676 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
677 char *tmp_at = strchr (tmp, '@');
679 if (tmp_at)
680 *tmp_at = 0;
681 else
682 einfo (_("%XCannot export %s: invalid export name\n"),
683 pe_def_file->exports[i].name);
684 pe_def_file->exports[i].name = tmp;
689 if (pe_dll_stdcall_aliases)
691 for (i = 0; i < NE; i++)
693 if (is_import (pe_def_file->exports[i].name))
694 continue;
696 if (strchr (pe_def_file->exports[i].name, '@'))
698 int lead_at = (*pe_def_file->exports[i].name == '@');
699 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
701 *(strchr (tmp, '@')) = 0;
702 if (auto_export (NULL, pe_def_file, tmp))
703 def_file_add_export (pe_def_file, tmp,
704 pe_def_file->exports[i].internal_name,
705 -1);
706 else
707 free (tmp);
712 /* Convenience, but watch out for it changing. */
713 e = pe_def_file->exports;
715 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
716 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
718 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
719 max_ordinal = 0;
720 min_ordinal = 65536;
721 count_exported = 0;
722 count_exported_byname = 0;
723 count_with_ordinals = 0;
725 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
726 pe_export_sort);
727 for (i = 0, j = 0; i < NE; i++)
729 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
731 /* This is a duplicate. */
732 if (e[j - 1].ordinal != -1
733 && e[i].ordinal != -1
734 && e[j - 1].ordinal != e[i].ordinal)
736 if (pe_dll_warn_dup_exports)
737 /* xgettext:c-format */
738 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
739 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
741 else
743 if (pe_dll_warn_dup_exports)
744 /* xgettext:c-format */
745 einfo (_("Warning, duplicate EXPORT: %s\n"),
746 e[j - 1].name);
749 if (e[i].ordinal != -1)
750 e[j - 1].ordinal = e[i].ordinal;
751 e[j - 1].flag_private |= e[i].flag_private;
752 e[j - 1].flag_constant |= e[i].flag_constant;
753 e[j - 1].flag_noname |= e[i].flag_noname;
754 e[j - 1].flag_data |= e[i].flag_data;
756 else
758 if (i != j)
759 e[j] = e[i];
760 j++;
763 pe_def_file->num_exports = j; /* == NE */
765 for (i = 0; i < NE; i++)
767 char *name;
769 /* Check for forward exports */
770 if (strchr (pe_def_file->exports[i].internal_name, '.'))
772 count_exported++;
773 if (!pe_def_file->exports[i].flag_noname)
774 count_exported_byname++;
776 pe_def_file->exports[i].flag_forward = 1;
778 if (pe_def_file->exports[i].ordinal != -1)
780 if (max_ordinal < pe_def_file->exports[i].ordinal)
781 max_ordinal = pe_def_file->exports[i].ordinal;
782 if (min_ordinal > pe_def_file->exports[i].ordinal)
783 min_ordinal = pe_def_file->exports[i].ordinal;
784 count_with_ordinals++;
787 continue;
790 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
791 if (pe_details->underscored
792 && (*pe_def_file->exports[i].internal_name != '@'))
794 *name = '_';
795 strcpy (name + 1, pe_def_file->exports[i].internal_name);
797 else
798 strcpy (name, pe_def_file->exports[i].internal_name);
800 blhe = bfd_link_hash_lookup (info->hash,
801 name,
802 FALSE, FALSE, TRUE);
804 if (blhe
805 && (blhe->type == bfd_link_hash_defined
806 || (blhe->type == bfd_link_hash_common)))
808 count_exported++;
809 if (!pe_def_file->exports[i].flag_noname)
810 count_exported_byname++;
812 /* Only fill in the sections. The actual offsets are computed
813 in fill_exported_offsets() after common symbols are laid
814 out. */
815 if (blhe->type == bfd_link_hash_defined)
816 exported_symbol_sections[i] = blhe->u.def.section;
817 else
818 exported_symbol_sections[i] = blhe->u.c.p->section;
820 if (pe_def_file->exports[i].ordinal != -1)
822 if (max_ordinal < pe_def_file->exports[i].ordinal)
823 max_ordinal = pe_def_file->exports[i].ordinal;
824 if (min_ordinal > pe_def_file->exports[i].ordinal)
825 min_ordinal = pe_def_file->exports[i].ordinal;
826 count_with_ordinals++;
829 else if (blhe && blhe->type == bfd_link_hash_undefined)
831 /* xgettext:c-format */
832 einfo (_("%XCannot export %s: symbol not defined\n"),
833 pe_def_file->exports[i].internal_name);
835 else if (blhe)
837 /* xgettext:c-format */
838 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
839 pe_def_file->exports[i].internal_name,
840 blhe->type, bfd_link_hash_defined);
842 else
844 /* xgettext:c-format */
845 einfo (_("%XCannot export %s: symbol not found\n"),
846 pe_def_file->exports[i].internal_name);
848 free (name);
852 /* Build the bfd that will contain .edata and .reloc sections. */
854 static void
855 build_filler_bfd (int include_edata)
857 lang_input_statement_type *filler_file;
858 filler_file = lang_add_input_file ("dll stuff",
859 lang_input_file_is_fake_enum,
860 NULL);
861 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
862 if (filler_bfd == NULL
863 || !bfd_set_arch_mach (filler_bfd,
864 bfd_get_arch (output_bfd),
865 bfd_get_mach (output_bfd)))
867 einfo ("%X%P: can not create BFD: %E\n");
868 return;
871 if (include_edata)
873 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
874 if (edata_s == NULL
875 || !bfd_set_section_flags (filler_bfd, edata_s,
876 (SEC_HAS_CONTENTS
877 | SEC_ALLOC
878 | SEC_LOAD
879 | SEC_KEEP
880 | SEC_IN_MEMORY)))
882 einfo ("%X%P: can not create .edata section: %E\n");
883 return;
885 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
888 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
889 if (reloc_s == NULL
890 || !bfd_set_section_flags (filler_bfd, reloc_s,
891 (SEC_HAS_CONTENTS
892 | SEC_ALLOC
893 | SEC_LOAD
894 | SEC_KEEP
895 | SEC_IN_MEMORY)))
897 einfo ("%X%P: can not create .reloc section: %E\n");
898 return;
901 bfd_set_section_size (filler_bfd, reloc_s, 0);
903 ldlang_add_file (filler_file);
906 /* Gather all the exported symbols and build the .edata section. */
908 static void
909 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
911 int i, next_ordinal;
912 int name_table_size = 0;
913 const char *dlnp;
915 /* First, we need to know how many exported symbols there are,
916 and what the range of ordinals is. */
917 if (pe_def_file->name)
918 dll_name = pe_def_file->name;
919 else
921 dll_name = abfd->filename;
923 for (dlnp = dll_name; *dlnp; dlnp++)
924 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
925 dll_name = dlnp + 1;
928 if (count_with_ordinals && max_ordinal > count_exported)
930 if (min_ordinal > max_ordinal - count_exported + 1)
931 min_ordinal = max_ordinal - count_exported + 1;
933 else
935 min_ordinal = 1;
936 max_ordinal = count_exported;
939 export_table_size = max_ordinal - min_ordinal + 1;
940 exported_symbols = xmalloc (export_table_size * sizeof (int));
941 for (i = 0; i < export_table_size; i++)
942 exported_symbols[i] = -1;
944 /* Now we need to assign ordinals to those that don't have them. */
945 for (i = 0; i < NE; i++)
947 if (exported_symbol_sections[i] ||
948 pe_def_file->exports[i].flag_forward)
950 if (pe_def_file->exports[i].ordinal != -1)
952 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
953 int pi = exported_symbols[ei];
955 if (pi != -1)
957 /* xgettext:c-format */
958 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
959 pe_def_file->exports[i].ordinal,
960 pe_def_file->exports[i].name,
961 pe_def_file->exports[pi].name);
963 exported_symbols[ei] = i;
965 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
968 /* Reserve space for the forward name. */
969 if (pe_def_file->exports[i].flag_forward)
971 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
975 next_ordinal = min_ordinal;
976 for (i = 0; i < NE; i++)
977 if ((exported_symbol_sections[i] ||
978 pe_def_file->exports[i].flag_forward) &&
979 pe_def_file->exports[i].ordinal == -1)
981 while (exported_symbols[next_ordinal - min_ordinal] != -1)
982 next_ordinal++;
984 exported_symbols[next_ordinal - min_ordinal] = i;
985 pe_def_file->exports[i].ordinal = next_ordinal;
988 /* OK, now we can allocate some memory. */
989 edata_sz = (40 /* directory */
990 + 4 * export_table_size /* addresses */
991 + 4 * count_exported_byname /* name ptrs */
992 + 2 * count_exported_byname /* ordinals */
993 + name_table_size + strlen (dll_name) + 1);
996 /* Fill the exported symbol offsets. The preliminary work has already
997 been done in process_def_file(). */
999 static void
1000 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
1002 int i;
1003 struct bfd_link_hash_entry *blhe;
1005 for (i = 0; i < pe_def_file->num_exports; i++)
1007 char *name;
1009 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
1010 if (pe_details->underscored
1011 && *pe_def_file->exports[i].internal_name != '@')
1013 *name = '_';
1014 strcpy (name + 1, pe_def_file->exports[i].internal_name);
1016 else
1017 strcpy (name, pe_def_file->exports[i].internal_name);
1019 blhe = bfd_link_hash_lookup (info->hash,
1020 name,
1021 FALSE, FALSE, TRUE);
1023 if (blhe && blhe->type == bfd_link_hash_defined)
1024 exported_symbol_offsets[i] = blhe->u.def.value;
1026 free (name);
1030 static void
1031 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1033 int s, hint;
1034 unsigned char *edirectory;
1035 unsigned char *eaddresses;
1036 unsigned char *enameptrs;
1037 unsigned char *eordinals;
1038 char *enamestr;
1039 time_t now;
1041 time (&now);
1043 edata_d = xmalloc (edata_sz);
1045 /* Note use of array pointer math here. */
1046 edirectory = edata_d;
1047 eaddresses = edata_d + 40;
1048 enameptrs = eaddresses + 4 * export_table_size;
1049 eordinals = enameptrs + 4 * count_exported_byname;
1050 enamestr = (char *) eordinals + 2 * count_exported_byname;
1052 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1053 + edata_s->output_section->vma - image_base)
1055 memset (edata_d, 0, edata_sz);
1056 bfd_put_32 (abfd, now, edata_d + 4);
1057 if (pe_def_file->version_major != -1)
1059 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1060 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1063 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1064 strcpy (enamestr, dll_name);
1065 enamestr += strlen (enamestr) + 1;
1066 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1067 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1068 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1069 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1070 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1071 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1073 fill_exported_offsets (abfd, info);
1075 /* Ok, now for the filling in part.
1076 Scan alphabetically - ie the ordering in the exports[] table,
1077 rather than by ordinal - the ordering in the exported_symbol[]
1078 table. See dlltool.c and:
1079 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1080 for more information. */
1081 hint = 0;
1082 for (s = 0; s < NE; s++)
1084 struct bfd_section *ssec = exported_symbol_sections[s];
1085 if (pe_def_file->exports[s].ordinal != -1 &&
1086 (pe_def_file->exports[s].flag_forward || ssec != NULL))
1088 int ord = pe_def_file->exports[s].ordinal;
1090 if (pe_def_file->exports[s].flag_forward)
1092 bfd_put_32 (abfd, ERVA (enamestr),
1093 eaddresses + 4 * (ord - min_ordinal));
1095 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1096 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1098 else
1100 unsigned long srva = (exported_symbol_offsets[s]
1101 + ssec->output_section->vma
1102 + ssec->output_offset);
1104 bfd_put_32 (abfd, srva - image_base,
1105 eaddresses + 4 * (ord - min_ordinal));
1108 if (!pe_def_file->exports[s].flag_noname)
1110 char *ename = pe_def_file->exports[s].name;
1112 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1113 enameptrs += 4;
1114 strcpy (enamestr, ename);
1115 enamestr += strlen (enamestr) + 1;
1116 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1117 eordinals += 2;
1118 pe_def_file->exports[s].hint = hint++;
1125 static struct bfd_section *current_sec;
1127 void
1128 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1129 const char *name,
1130 int (*cb) (arelent *, asection *))
1132 bfd *b;
1133 asection *s;
1135 for (b = info->input_bfds; b; b = b->link_next)
1137 asymbol **symbols;
1138 int nsyms, symsize;
1140 symsize = bfd_get_symtab_upper_bound (b);
1141 symbols = xmalloc (symsize);
1142 nsyms = bfd_canonicalize_symtab (b, symbols);
1144 for (s = b->sections; s; s = s->next)
1146 arelent **relocs;
1147 int relsize, nrelocs, i;
1148 int flags = bfd_get_section_flags (b, s);
1150 /* Skip discarded linkonce sections. */
1151 if (flags & SEC_LINK_ONCE
1152 && s->output_section == bfd_abs_section_ptr)
1153 continue;
1155 current_sec = s;
1157 relsize = bfd_get_reloc_upper_bound (b, s);
1158 relocs = xmalloc (relsize);
1159 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1161 for (i = 0; i < nrelocs; i++)
1163 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1165 if (!strcmp (name, sym->name))
1166 cb (relocs[i], s);
1169 free (relocs);
1171 /* Warning: the allocated symbols are remembered in BFD and reused
1172 later, so don't free them! */
1173 /* free (symbols); */
1178 /* Gather all the relocations and build the .reloc section. */
1180 static void
1181 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1184 /* For .reloc stuff. */
1185 reloc_data_type *reloc_data;
1186 int total_relocs = 0;
1187 int i;
1188 unsigned long sec_page = (unsigned long) -1;
1189 unsigned long page_ptr, page_count;
1190 int bi;
1191 bfd *b;
1192 struct bfd_section *s;
1194 total_relocs = 0;
1195 for (b = info->input_bfds; b; b = b->link_next)
1196 for (s = b->sections; s; s = s->next)
1197 total_relocs += s->reloc_count;
1199 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1201 total_relocs = 0;
1202 bi = 0;
1203 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1205 arelent **relocs;
1206 int relsize, nrelocs, i;
1208 for (s = b->sections; s; s = s->next)
1210 unsigned long sec_vma = s->output_section->vma + s->output_offset;
1211 asymbol **symbols;
1212 int nsyms, symsize;
1214 /* If it's not loaded, we don't need to relocate it this way. */
1215 if (!(s->output_section->flags & SEC_LOAD))
1216 continue;
1218 /* I don't know why there would be a reloc for these, but I've
1219 seen it happen - DJ */
1220 if (s->output_section == &bfd_abs_section)
1221 continue;
1223 if (s->output_section->vma == 0)
1225 /* Huh? Shouldn't happen, but punt if it does. */
1226 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1227 s->output_section->name, s->output_section->index,
1228 s->output_section->flags);
1229 continue;
1232 symsize = bfd_get_symtab_upper_bound (b);
1233 symbols = xmalloc (symsize);
1234 nsyms = bfd_canonicalize_symtab (b, symbols);
1236 relsize = bfd_get_reloc_upper_bound (b, s);
1237 relocs = xmalloc (relsize);
1238 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1240 for (i = 0; i < nrelocs; i++)
1242 if (pe_dll_extra_pe_debug)
1244 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1245 printf ("rel: %s\n", sym->name);
1247 if (!relocs[i]->howto->pc_relative
1248 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1250 bfd_vma sym_vma;
1251 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1253 sym_vma = (relocs[i]->addend
1254 + sym->value
1255 + sym->section->vma
1256 + sym->section->output_offset
1257 + sym->section->output_section->vma);
1258 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1260 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1262 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1263 relocs[i]->howto->rightshift)
1265 #ifdef pe_use_x86_64
1266 case BITS_AND_SHIFT (64, 0):
1267 reloc_data[total_relocs].type = 10;
1268 total_relocs++;
1269 break;
1270 #endif
1271 case BITS_AND_SHIFT (32, 0):
1272 reloc_data[total_relocs].type = 3;
1273 total_relocs++;
1274 break;
1275 case BITS_AND_SHIFT (16, 0):
1276 reloc_data[total_relocs].type = 2;
1277 total_relocs++;
1278 break;
1279 case BITS_AND_SHIFT (16, 16):
1280 reloc_data[total_relocs].type = 4;
1281 /* FIXME: we can't know the symbol's right value
1282 yet, but we probably can safely assume that
1283 CE will relocate us in 64k blocks, so leaving
1284 it zero is safe. */
1285 reloc_data[total_relocs].extra = 0;
1286 total_relocs++;
1287 break;
1288 case BITS_AND_SHIFT (26, 2):
1289 reloc_data[total_relocs].type = 5;
1290 total_relocs++;
1291 break;
1292 case BITS_AND_SHIFT (24, 2):
1293 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1294 Those ARM_xxx definitions should go in proper
1295 header someday. */
1296 if (relocs[i]->howto->type == 0
1297 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1298 || relocs[i]->howto->type == 5)
1299 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1300 that has already been fully processed during a
1301 previous link stage, so ignore it here. */
1302 break;
1303 /* Fall through. */
1304 default:
1305 /* xgettext:c-format */
1306 einfo (_("%XError: %d-bit reloc in dll\n"),
1307 relocs[i]->howto->bitsize);
1308 break;
1312 free (relocs);
1313 /* Warning: the allocated symbols are remembered in BFD and
1314 reused later, so don't free them! */
1318 /* At this point, we have total_relocs relocation addresses in
1319 reloc_addresses, which are all suitable for the .reloc section.
1320 We must now create the new sections. */
1321 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1323 for (i = 0; i < total_relocs; i++)
1325 unsigned long this_page = (reloc_data[i].vma >> 12);
1327 if (this_page != sec_page)
1329 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1330 reloc_sz += 8;
1331 sec_page = this_page;
1334 reloc_sz += 2;
1336 if (reloc_data[i].type == 4)
1337 reloc_sz += 2;
1340 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1341 reloc_d = xmalloc (reloc_sz);
1342 sec_page = (unsigned long) -1;
1343 reloc_sz = 0;
1344 page_ptr = (unsigned long) -1;
1345 page_count = 0;
1347 for (i = 0; i < total_relocs; i++)
1349 unsigned long rva = reloc_data[i].vma - image_base;
1350 unsigned long this_page = (rva & ~0xfff);
1352 if (this_page != sec_page)
1354 while (reloc_sz & 3)
1355 reloc_d[reloc_sz++] = 0;
1357 if (page_ptr != (unsigned long) -1)
1358 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1360 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1361 page_ptr = reloc_sz;
1362 reloc_sz += 8;
1363 sec_page = this_page;
1364 page_count = 0;
1367 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1368 reloc_d + reloc_sz);
1369 reloc_sz += 2;
1371 if (reloc_data[i].type == 4)
1373 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1374 reloc_sz += 2;
1377 page_count++;
1380 while (reloc_sz & 3)
1381 reloc_d[reloc_sz++] = 0;
1383 if (page_ptr != (unsigned long) -1)
1384 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1386 while (reloc_sz < reloc_s->size)
1387 reloc_d[reloc_sz++] = 0;
1390 /* Given the exiting def_file structure, print out a .DEF file that
1391 corresponds to it. */
1393 static void
1394 quoteput (char *s, FILE *f, int needs_quotes)
1396 char *cp;
1398 for (cp = s; *cp; cp++)
1399 if (*cp == '\''
1400 || *cp == '"'
1401 || *cp == '\\'
1402 || ISSPACE (*cp)
1403 || *cp == ','
1404 || *cp == ';')
1405 needs_quotes = 1;
1407 if (needs_quotes)
1409 putc ('"', f);
1411 while (*s)
1413 if (*s == '"' || *s == '\\')
1414 putc ('\\', f);
1416 putc (*s, f);
1417 s++;
1420 putc ('"', f);
1422 else
1423 fputs (s, f);
1426 void
1427 pe_dll_generate_def_file (const char *pe_out_def_filename)
1429 int i;
1430 FILE *out = fopen (pe_out_def_filename, "w");
1432 if (out == NULL)
1433 /* xgettext:c-format */
1434 einfo (_("%s: Can't open output def file %s\n"),
1435 program_name, pe_out_def_filename);
1437 if (pe_def_file)
1439 if (pe_def_file->name)
1441 if (pe_def_file->is_dll)
1442 fprintf (out, "LIBRARY ");
1443 else
1444 fprintf (out, "NAME ");
1446 quoteput (pe_def_file->name, out, 1);
1448 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
1449 fprintf (out, " BASE=0x%lx",
1450 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
1451 fprintf (out, "\n");
1454 if (pe_def_file->description)
1456 fprintf (out, "DESCRIPTION ");
1457 quoteput (pe_def_file->description, out, 1);
1458 fprintf (out, "\n");
1461 if (pe_def_file->version_minor != -1)
1462 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1463 pe_def_file->version_minor);
1464 else if (pe_def_file->version_major != -1)
1465 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1467 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1468 fprintf (out, "\n");
1470 if (pe_def_file->stack_commit != -1)
1471 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1472 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1473 else if (pe_def_file->stack_reserve != -1)
1474 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1476 if (pe_def_file->heap_commit != -1)
1477 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1478 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1479 else if (pe_def_file->heap_reserve != -1)
1480 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1482 if (pe_def_file->num_section_defs > 0)
1484 fprintf (out, "\nSECTIONS\n\n");
1486 for (i = 0; i < pe_def_file->num_section_defs; i++)
1488 fprintf (out, " ");
1489 quoteput (pe_def_file->section_defs[i].name, out, 0);
1491 if (pe_def_file->section_defs[i].class)
1493 fprintf (out, " CLASS ");
1494 quoteput (pe_def_file->section_defs[i].class, out, 0);
1497 if (pe_def_file->section_defs[i].flag_read)
1498 fprintf (out, " READ");
1500 if (pe_def_file->section_defs[i].flag_write)
1501 fprintf (out, " WRITE");
1503 if (pe_def_file->section_defs[i].flag_execute)
1504 fprintf (out, " EXECUTE");
1506 if (pe_def_file->section_defs[i].flag_shared)
1507 fprintf (out, " SHARED");
1509 fprintf (out, "\n");
1513 if (pe_def_file->num_exports > 0)
1515 fprintf (out, "EXPORTS\n");
1517 for (i = 0; i < pe_def_file->num_exports; i++)
1519 def_file_export *e = pe_def_file->exports + i;
1520 fprintf (out, " ");
1521 quoteput (e->name, out, 0);
1523 if (e->internal_name && strcmp (e->internal_name, e->name))
1525 fprintf (out, " = ");
1526 quoteput (e->internal_name, out, 0);
1529 if (e->ordinal != -1)
1530 fprintf (out, " @%d", e->ordinal);
1532 if (e->flag_private)
1533 fprintf (out, " PRIVATE");
1535 if (e->flag_constant)
1536 fprintf (out, " CONSTANT");
1538 if (e->flag_noname)
1539 fprintf (out, " NONAME");
1541 if (e->flag_data)
1542 fprintf (out, " DATA");
1544 fprintf (out, "\n");
1548 if (pe_def_file->num_imports > 0)
1550 fprintf (out, "\nIMPORTS\n\n");
1552 for (i = 0; i < pe_def_file->num_imports; i++)
1554 def_file_import *im = pe_def_file->imports + i;
1555 fprintf (out, " ");
1557 if (im->internal_name
1558 && (!im->name || strcmp (im->internal_name, im->name)))
1560 quoteput (im->internal_name, out, 0);
1561 fprintf (out, " = ");
1564 quoteput (im->module->name, out, 0);
1565 fprintf (out, ".");
1567 if (im->name)
1568 quoteput (im->name, out, 0);
1569 else
1570 fprintf (out, "%d", im->ordinal);
1572 fprintf (out, "\n");
1576 else
1577 fprintf (out, _("; no contents available\n"));
1579 if (fclose (out) == EOF)
1580 /* xgettext:c-format */
1581 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1584 /* Generate the import library. */
1586 static asymbol **symtab;
1587 static int symptr;
1588 static int tmp_seq;
1589 static const char *dll_filename;
1590 static char *dll_symname;
1592 #define UNDSEC (asection *) &bfd_und_section
1594 static asection *
1595 quick_section (bfd *abfd, const char *name, int flags, int align)
1597 asection *sec;
1598 asymbol *sym;
1600 sec = bfd_make_section_old_way (abfd, name);
1601 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1602 bfd_set_section_alignment (abfd, sec, align);
1603 /* Remember to undo this before trying to link internally! */
1604 sec->output_section = sec;
1606 sym = bfd_make_empty_symbol (abfd);
1607 symtab[symptr++] = sym;
1608 sym->name = sec->name;
1609 sym->section = sec;
1610 sym->flags = BSF_LOCAL;
1611 sym->value = 0;
1613 return sec;
1616 static void
1617 quick_symbol (bfd *abfd,
1618 const char *n1,
1619 const char *n2,
1620 const char *n3,
1621 asection *sec,
1622 int flags,
1623 int addr)
1625 asymbol *sym;
1626 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1628 strcpy (name, n1);
1629 strcat (name, n2);
1630 strcat (name, n3);
1631 sym = bfd_make_empty_symbol (abfd);
1632 sym->name = name;
1633 sym->section = sec;
1634 sym->flags = flags;
1635 sym->value = addr;
1636 symtab[symptr++] = sym;
1639 static arelent *reltab = 0;
1640 static int relcount = 0, relsize = 0;
1642 static void
1643 quick_reloc (bfd *abfd, int address, int which_howto, int symidx)
1645 if (relcount >= relsize - 1)
1647 relsize += 10;
1648 if (reltab)
1649 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1650 else
1651 reltab = xmalloc (relsize * sizeof (arelent));
1653 reltab[relcount].address = address;
1654 reltab[relcount].addend = 0;
1655 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1656 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1657 relcount++;
1660 static void
1661 save_relocs (asection *sec)
1663 int i;
1665 sec->relocation = reltab;
1666 sec->reloc_count = relcount;
1667 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1668 for (i = 0; i < relcount; i++)
1669 sec->orelocation[i] = sec->relocation + i;
1670 sec->orelocation[relcount] = 0;
1671 sec->flags |= SEC_RELOC;
1672 reltab = 0;
1673 relcount = relsize = 0;
1676 /* .section .idata$2
1677 .global __head_my_dll
1678 __head_my_dll:
1679 .rva hname
1680 .long 0
1681 .long 0
1682 .rva __my_dll_iname
1683 .rva fthunk
1685 .section .idata$5
1686 .long 0
1687 fthunk:
1689 .section .idata$4
1690 .long 0
1691 hname: */
1693 static bfd *
1694 make_head (bfd *parent)
1696 asection *id2, *id5, *id4;
1697 unsigned char *d2, *d5, *d4;
1698 char *oname;
1699 bfd *abfd;
1701 oname = xmalloc (20);
1702 sprintf (oname, "d%06d.o", tmp_seq);
1703 tmp_seq++;
1705 abfd = bfd_create (oname, parent);
1706 bfd_find_target (pe_details->object_target, abfd);
1707 bfd_make_writable (abfd);
1709 bfd_set_format (abfd, bfd_object);
1710 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1712 symptr = 0;
1713 symtab = xmalloc (6 * sizeof (asymbol *));
1714 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1715 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1716 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1717 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1718 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1720 /* OK, pay attention here. I got confused myself looking back at
1721 it. We create a four-byte section to mark the beginning of the
1722 list, and we include an offset of 4 in the section, so that the
1723 pointer to the list points to the *end* of this section, which is
1724 the start of the list of sections from other objects. */
1726 bfd_set_section_size (abfd, id2, 20);
1727 d2 = xmalloc (20);
1728 id2->contents = d2;
1729 memset (d2, 0, 20);
1730 d2[0] = d2[16] = 4; /* Reloc addend. */
1731 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1732 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1733 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1734 save_relocs (id2);
1736 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1737 d5 = xmalloc (PE_IDATA5_SIZE);
1738 id5->contents = d5;
1739 memset (d5, 0, PE_IDATA5_SIZE);
1741 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1742 d4 = xmalloc (PE_IDATA4_SIZE);
1743 id4->contents = d4;
1744 memset (d4, 0, PE_IDATA4_SIZE);
1746 bfd_set_symtab (abfd, symtab, symptr);
1748 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1749 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1750 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1752 bfd_make_readable (abfd);
1753 return abfd;
1756 /* .section .idata$4
1757 .long 0
1758 [.long 0] for PE+
1759 .section .idata$5
1760 .long 0
1761 [.long 0] for PE+
1762 .section idata$7
1763 .global __my_dll_iname
1764 __my_dll_iname:
1765 .asciz "my.dll" */
1767 static bfd *
1768 make_tail (bfd *parent)
1770 asection *id4, *id5, *id7;
1771 unsigned char *d4, *d5, *d7;
1772 int len;
1773 char *oname;
1774 bfd *abfd;
1776 oname = xmalloc (20);
1777 sprintf (oname, "d%06d.o", tmp_seq);
1778 tmp_seq++;
1780 abfd = bfd_create (oname, parent);
1781 bfd_find_target (pe_details->object_target, abfd);
1782 bfd_make_writable (abfd);
1784 bfd_set_format (abfd, bfd_object);
1785 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1787 symptr = 0;
1788 symtab = xmalloc (5 * sizeof (asymbol *));
1789 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1790 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1791 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1792 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1794 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1795 d4 = xmalloc (PE_IDATA4_SIZE);
1796 id4->contents = d4;
1797 memset (d4, 0, PE_IDATA4_SIZE);
1799 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1800 d5 = xmalloc (PE_IDATA5_SIZE);
1801 id5->contents = d5;
1802 memset (d5, 0, PE_IDATA5_SIZE);
1804 len = strlen (dll_filename) + 1;
1805 if (len & 1)
1806 len++;
1807 bfd_set_section_size (abfd, id7, len);
1808 d7 = xmalloc (len);
1809 id7->contents = d7;
1810 strcpy ((char *) d7, dll_filename);
1811 /* If len was odd, the above
1812 strcpy leaves behind an undefined byte. That is harmless,
1813 but we set it to 0 just so the binary dumps are pretty. */
1814 d7[len - 1] = 0;
1816 bfd_set_symtab (abfd, symtab, symptr);
1818 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1819 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1820 bfd_set_section_contents (abfd, id7, d7, 0, len);
1822 bfd_make_readable (abfd);
1823 return abfd;
1826 /* .text
1827 .global _function
1828 .global ___imp_function
1829 .global __imp__function
1830 _function:
1831 jmp *__imp__function:
1833 .section idata$7
1834 .long __head_my_dll
1836 .section .idata$5
1837 ___imp_function:
1838 __imp__function:
1839 iat?
1840 .section .idata$4
1841 iat?
1842 .section .idata$6
1843 ID<ordinal>:
1844 .short <hint>
1845 .asciz "function" xlate? (add underscore, kill at) */
1847 static const unsigned char jmp_ix86_bytes[] =
1849 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1852 /* _function:
1853 mov.l ip+8,r0
1854 mov.l @r0,r0
1855 jmp @r0
1857 .dw __imp_function */
1859 static const unsigned char jmp_sh_bytes[] =
1861 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1864 /* _function:
1865 lui $t0,<high:__imp_function>
1866 lw $t0,<low:__imp_function>
1867 jr $t0
1868 nop */
1870 static const unsigned char jmp_mips_bytes[] =
1872 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1873 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1876 static const unsigned char jmp_arm_bytes[] =
1878 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1879 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1880 0, 0, 0, 0
1884 static bfd *
1885 make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
1887 asection *tx, *id7, *id5, *id4, *id6;
1888 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1889 int len;
1890 char *oname;
1891 bfd *abfd;
1892 const unsigned char *jmp_bytes = NULL;
1893 int jmp_byte_count = 0;
1895 /* Include the jump stub section only if it is needed. A jump
1896 stub is needed if the symbol being imported <sym> is a function
1897 symbol and there is at least one undefined reference to that
1898 symbol. In other words, if all the import references to <sym> are
1899 explicitly through _declspec(dllimport) then the jump stub is not
1900 needed. */
1901 if (include_jmp_stub)
1903 switch (pe_details->pe_arch)
1905 case PE_ARCH_i386:
1906 jmp_bytes = jmp_ix86_bytes;
1907 jmp_byte_count = sizeof (jmp_ix86_bytes);
1908 break;
1909 case PE_ARCH_sh:
1910 jmp_bytes = jmp_sh_bytes;
1911 jmp_byte_count = sizeof (jmp_sh_bytes);
1912 break;
1913 case PE_ARCH_mips:
1914 jmp_bytes = jmp_mips_bytes;
1915 jmp_byte_count = sizeof (jmp_mips_bytes);
1916 break;
1917 case PE_ARCH_arm:
1918 case PE_ARCH_arm_epoc:
1919 case PE_ARCH_arm_wince:
1920 jmp_bytes = jmp_arm_bytes;
1921 jmp_byte_count = sizeof (jmp_arm_bytes);
1922 break;
1923 default:
1924 abort ();
1928 oname = xmalloc (20);
1929 sprintf (oname, "d%06d.o", tmp_seq);
1930 tmp_seq++;
1932 abfd = bfd_create (oname, parent);
1933 bfd_find_target (pe_details->object_target, abfd);
1934 bfd_make_writable (abfd);
1936 bfd_set_format (abfd, bfd_object);
1937 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1939 symptr = 0;
1940 symtab = xmalloc (11 * sizeof (asymbol *));
1941 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1942 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1943 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1944 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1945 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1947 if (*exp->internal_name == '@')
1949 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1950 BSF_GLOBAL, 0);
1951 if (include_jmp_stub)
1952 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
1953 quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
1954 BSF_GLOBAL, 0);
1955 /* Fastcall applies only to functions,
1956 so no need for auto-import symbol. */
1958 else
1960 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
1961 BSF_GLOBAL, 0);
1962 if (include_jmp_stub)
1963 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
1964 BSF_GLOBAL, 0);
1965 quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
1966 BSF_GLOBAL, 0);
1967 /* Symbol to reference ord/name of imported
1968 data symbol, used to implement auto-import. */
1969 if (exp->flag_data)
1970 quick_symbol (abfd, U ("_nm_"), U (""), exp->internal_name, id6,
1971 BSF_GLOBAL,0);
1973 if (pe_dll_compat_implib)
1974 quick_symbol (abfd, U ("__imp_"), exp->internal_name, "", id5,
1975 BSF_GLOBAL, 0);
1977 if (include_jmp_stub)
1979 bfd_set_section_size (abfd, tx, jmp_byte_count);
1980 td = xmalloc (jmp_byte_count);
1981 tx->contents = td;
1982 memcpy (td, jmp_bytes, jmp_byte_count);
1984 switch (pe_details->pe_arch)
1986 case PE_ARCH_i386:
1987 #ifdef pe_use_x86_64
1988 quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
1989 #else
1990 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1991 #endif
1992 break;
1993 case PE_ARCH_sh:
1994 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1995 break;
1996 case PE_ARCH_mips:
1997 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1998 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1999 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2000 break;
2001 case PE_ARCH_arm:
2002 case PE_ARCH_arm_epoc:
2003 case PE_ARCH_arm_wince:
2004 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2005 break;
2006 default:
2007 abort ();
2009 save_relocs (tx);
2011 else
2012 bfd_set_section_size (abfd, tx, 0);
2014 bfd_set_section_size (abfd, id7, 4);
2015 d7 = xmalloc (4);
2016 id7->contents = d7;
2017 memset (d7, 0, 4);
2018 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2019 save_relocs (id7);
2021 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2022 d5 = xmalloc (PE_IDATA5_SIZE);
2023 id5->contents = d5;
2024 memset (d5, 0, PE_IDATA5_SIZE);
2026 if (exp->flag_noname)
2028 d5[0] = exp->ordinal;
2029 d5[1] = exp->ordinal >> 8;
2030 d5[PE_IDATA5_SIZE - 1] = 0x80;
2032 else
2034 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2035 save_relocs (id5);
2038 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2039 d4 = xmalloc (PE_IDATA4_SIZE);
2040 id4->contents = d4;
2041 memset (d4, 0, PE_IDATA4_SIZE);
2043 if (exp->flag_noname)
2045 d4[0] = exp->ordinal;
2046 d4[1] = exp->ordinal >> 8;
2047 d4[PE_IDATA4_SIZE - 1] = 0x80;
2049 else
2051 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2052 save_relocs (id4);
2055 if (exp->flag_noname)
2057 len = 0;
2058 bfd_set_section_size (abfd, id6, 0);
2060 else
2062 /* { short, asciz } */
2063 len = 2 + strlen (exp->name) + 1;
2064 if (len & 1)
2065 len++;
2066 bfd_set_section_size (abfd, id6, len);
2067 d6 = xmalloc (len);
2068 id6->contents = d6;
2069 memset (d6, 0, len);
2070 d6[0] = exp->hint & 0xff;
2071 d6[1] = exp->hint >> 8;
2072 strcpy ((char *) d6 + 2, exp->name);
2075 bfd_set_symtab (abfd, symtab, symptr);
2077 if (include_jmp_stub)
2078 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2079 bfd_set_section_contents (abfd, id7, d7, 0, 4);
2080 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2081 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2082 if (!exp->flag_noname)
2083 bfd_set_section_contents (abfd, id6, d6, 0, len);
2085 bfd_make_readable (abfd);
2086 return abfd;
2089 static bfd *
2090 make_singleton_name_thunk (const char *import, bfd *parent)
2092 /* Name thunks go to idata$4. */
2093 asection *id4;
2094 unsigned char *d4;
2095 char *oname;
2096 bfd *abfd;
2098 oname = xmalloc (20);
2099 sprintf (oname, "nmth%06d.o", tmp_seq);
2100 tmp_seq++;
2102 abfd = bfd_create (oname, parent);
2103 bfd_find_target (pe_details->object_target, abfd);
2104 bfd_make_writable (abfd);
2106 bfd_set_format (abfd, bfd_object);
2107 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2109 symptr = 0;
2110 symtab = xmalloc (3 * sizeof (asymbol *));
2111 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2112 quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
2113 quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
2115 /* We need space for the real thunk and for the null terminator. */
2116 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2117 d4 = xmalloc (PE_IDATA4_SIZE * 2);
2118 id4->contents = d4;
2119 memset (d4, 0, PE_IDATA4_SIZE * 2);
2120 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2121 save_relocs (id4);
2123 bfd_set_symtab (abfd, symtab, symptr);
2125 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2127 bfd_make_readable (abfd);
2128 return abfd;
2131 static char *
2132 make_import_fixup_mark (arelent *rel)
2134 /* We convert reloc to symbol, for later reference. */
2135 static int counter;
2136 static char *fixup_name = NULL;
2137 static size_t buffer_len = 0;
2139 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2141 bfd *abfd = bfd_asymbol_bfd (sym);
2142 struct bfd_link_hash_entry *bh;
2144 if (!fixup_name)
2146 fixup_name = xmalloc (384);
2147 buffer_len = 384;
2150 if (strlen (sym->name) + 25 > buffer_len)
2151 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2152 bigger than 20 digits long, we've got worse problems than
2153 overflowing this buffer... */
2155 free (fixup_name);
2156 /* New buffer size is length of symbol, plus 25, but
2157 then rounded up to the nearest multiple of 128. */
2158 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2159 fixup_name = xmalloc (buffer_len);
2162 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2164 bh = NULL;
2165 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2166 current_sec, /* sym->section, */
2167 rel->address, NULL, TRUE, FALSE, &bh);
2169 return fixup_name;
2172 /* .section .idata$2
2173 .rva __nm_thnk_SYM (singleton thunk with name of func)
2174 .long 0
2175 .long 0
2176 .rva __my_dll_iname (name of dll)
2177 .rva __fuNN_SYM (pointer to reference (address) in text) */
2179 static bfd *
2180 make_import_fixup_entry (const char *name,
2181 const char *fixup_name,
2182 const char *dll_symname,
2183 bfd *parent)
2185 asection *id2;
2186 unsigned char *d2;
2187 char *oname;
2188 bfd *abfd;
2190 oname = xmalloc (20);
2191 sprintf (oname, "fu%06d.o", tmp_seq);
2192 tmp_seq++;
2194 abfd = bfd_create (oname, parent);
2195 bfd_find_target (pe_details->object_target, abfd);
2196 bfd_make_writable (abfd);
2198 bfd_set_format (abfd, bfd_object);
2199 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2201 symptr = 0;
2202 symtab = xmalloc (6 * sizeof (asymbol *));
2203 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2205 quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2206 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2207 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2209 bfd_set_section_size (abfd, id2, 20);
2210 d2 = xmalloc (20);
2211 id2->contents = d2;
2212 memset (d2, 0, 20);
2214 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2215 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2216 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2217 save_relocs (id2);
2219 bfd_set_symtab (abfd, symtab, symptr);
2221 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2223 bfd_make_readable (abfd);
2224 return abfd;
2227 /* .section .rdata_runtime_pseudo_reloc
2228 .long addend
2229 .rva __fuNN_SYM (pointer to reference (address) in text) */
2231 static bfd *
2232 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2233 const char *fixup_name,
2234 int addend,
2235 bfd *parent)
2237 asection *rt_rel;
2238 unsigned char *rt_rel_d;
2239 char *oname;
2240 bfd *abfd;
2242 oname = xmalloc (20);
2243 sprintf (oname, "rtr%06d.o", tmp_seq);
2244 tmp_seq++;
2246 abfd = bfd_create (oname, parent);
2247 bfd_find_target (pe_details->object_target, abfd);
2248 bfd_make_writable (abfd);
2250 bfd_set_format (abfd, bfd_object);
2251 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2253 symptr = 0;
2254 symtab = xmalloc (2 * sizeof (asymbol *));
2255 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2256 SEC_HAS_CONTENTS, 2);
2258 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2260 bfd_set_section_size (abfd, rt_rel, 8);
2261 rt_rel_d = xmalloc (8);
2262 rt_rel->contents = rt_rel_d;
2263 memset (rt_rel_d, 0, 8);
2264 bfd_put_32 (abfd, addend, rt_rel_d);
2266 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2267 save_relocs (rt_rel);
2269 bfd_set_symtab (abfd, symtab, symptr);
2271 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2273 bfd_make_readable (abfd);
2274 return abfd;
2277 /* .section .rdata
2278 .rva __pei386_runtime_relocator */
2280 static bfd *
2281 pe_create_runtime_relocator_reference (bfd *parent)
2283 asection *extern_rt_rel;
2284 unsigned char *extern_rt_rel_d;
2285 char *oname;
2286 bfd *abfd;
2288 oname = xmalloc (20);
2289 sprintf (oname, "ertr%06d.o", tmp_seq);
2290 tmp_seq++;
2292 abfd = bfd_create (oname, parent);
2293 bfd_find_target (pe_details->object_target, abfd);
2294 bfd_make_writable (abfd);
2296 bfd_set_format (abfd, bfd_object);
2297 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2299 symptr = 0;
2300 symtab = xmalloc (2 * sizeof (asymbol *));
2301 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2303 quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2304 BSF_NO_FLAGS, 0);
2306 bfd_set_section_size (abfd, extern_rt_rel, 4);
2307 extern_rt_rel_d = xmalloc (4);
2308 extern_rt_rel->contents = extern_rt_rel_d;
2310 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2311 save_relocs (extern_rt_rel);
2313 bfd_set_symtab (abfd, symtab, symptr);
2315 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
2317 bfd_make_readable (abfd);
2318 return abfd;
2321 void
2322 pe_create_import_fixup (arelent *rel, asection *s, int addend)
2324 char buf[300];
2325 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2326 struct bfd_link_hash_entry *name_thunk_sym;
2327 const char *name = sym->name;
2328 char *fixup_name = make_import_fixup_mark (rel);
2329 bfd *b;
2331 sprintf (buf, U ("_nm_thnk_%s"), name);
2333 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2335 if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2337 bfd *b = make_singleton_name_thunk (name, output_bfd);
2338 add_bfd_to_link (b, b->filename, &link_info);
2340 /* If we ever use autoimport, we have to cast text section writable. */
2341 config.text_read_only = FALSE;
2342 output_bfd->flags &= ~WP_TEXT;
2345 if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2347 extern char * pe_data_import_dll;
2348 char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2350 b = make_import_fixup_entry (name, fixup_name, dll_symname, output_bfd);
2351 add_bfd_to_link (b, b->filename, &link_info);
2354 if (addend != 0)
2356 if (link_info.pei386_runtime_pseudo_reloc)
2358 if (pe_dll_extra_pe_debug)
2359 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2360 fixup_name, addend);
2361 b = make_runtime_pseudo_reloc (name, fixup_name, addend, output_bfd);
2362 add_bfd_to_link (b, b->filename, &link_info);
2364 if (runtime_pseudo_relocs_created == 0)
2366 b = pe_create_runtime_relocator_reference (output_bfd);
2367 add_bfd_to_link (b, b->filename, &link_info);
2369 runtime_pseudo_relocs_created++;
2371 else
2373 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2374 s->owner, s, rel->address, sym->name);
2375 einfo ("%X");
2381 void
2382 pe_dll_generate_implib (def_file *def, const char *impfilename)
2384 int i;
2385 bfd *ar_head;
2386 bfd *ar_tail;
2387 bfd *outarch;
2388 bfd *head = 0;
2390 dll_filename = (def->name) ? def->name : dll_name;
2391 dll_symname = xstrdup (dll_filename);
2392 for (i = 0; dll_symname[i]; i++)
2393 if (!ISALNUM (dll_symname[i]))
2394 dll_symname[i] = '_';
2396 unlink_if_ordinary (impfilename);
2398 outarch = bfd_openw (impfilename, 0);
2400 if (!outarch)
2402 /* xgettext:c-format */
2403 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2404 return;
2407 /* xgettext:c-format */
2408 info_msg (_("Creating library file: %s\n"), impfilename);
2410 bfd_set_format (outarch, bfd_archive);
2411 outarch->has_armap = 1;
2413 /* Work out a reasonable size of things to put onto one line. */
2414 ar_head = make_head (outarch);
2416 for (i = 0; i < def->num_exports; i++)
2418 /* The import library doesn't know about the internal name. */
2419 char *internal = def->exports[i].internal_name;
2420 bfd *n;
2422 /* Don't add PRIVATE entries to import lib. */
2423 if (pe_def_file->exports[i].flag_private)
2424 continue;
2425 def->exports[i].internal_name = def->exports[i].name;
2426 n = make_one (def->exports + i, outarch,
2427 ! (def->exports + i)->flag_data);
2428 n->archive_next = head;
2429 head = n;
2430 def->exports[i].internal_name = internal;
2433 ar_tail = make_tail (outarch);
2435 if (ar_head == NULL || ar_tail == NULL)
2436 return;
2438 /* Now stick them all into the archive. */
2439 ar_head->archive_next = head;
2440 ar_tail->archive_next = ar_head;
2441 head = ar_tail;
2443 if (! bfd_set_archive_head (outarch, head))
2444 einfo ("%Xbfd_set_archive_head: %E\n");
2446 if (! bfd_close (outarch))
2447 einfo ("%Xbfd_close %s: %E\n", impfilename);
2449 while (head != NULL)
2451 bfd *n = head->archive_next;
2452 bfd_close (head);
2453 head = n;
2457 static void
2458 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *link_info)
2460 lang_input_statement_type *fake_file;
2462 fake_file = lang_add_input_file (name,
2463 lang_input_file_is_fake_enum,
2464 NULL);
2465 fake_file->the_bfd = abfd;
2466 ldlang_add_file (fake_file);
2468 if (!bfd_link_add_symbols (abfd, link_info))
2469 einfo ("%Xaddsym %s: %E\n", name);
2472 void
2473 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *link_info)
2475 def_file_module *module;
2477 pe_dll_id_target (bfd_get_target (output_bfd));
2479 if (!pe_def_file)
2480 return;
2482 for (module = pe_def_file->modules; module; module = module->next)
2484 int i, do_this_dll;
2486 dll_filename = module->name;
2487 dll_symname = xstrdup (module->name);
2488 for (i = 0; dll_symname[i]; i++)
2489 if (!ISALNUM (dll_symname[i]))
2490 dll_symname[i] = '_';
2492 do_this_dll = 0;
2494 for (i = 0; i < pe_def_file->num_imports; i++)
2495 if (pe_def_file->imports[i].module == module)
2497 def_file_export exp;
2498 struct bfd_link_hash_entry *blhe;
2499 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2500 /* See if we need this import. */
2501 size_t len = strlen (pe_def_file->imports[i].internal_name);
2502 char *name = xmalloc (len + 2 + 6);
2503 bfd_boolean include_jmp_stub = FALSE;
2505 if (lead_at)
2506 sprintf (name, "%s",
2507 pe_def_file->imports[i].internal_name);
2508 else
2509 sprintf (name, "%s%s",U (""),
2510 pe_def_file->imports[i].internal_name);
2512 blhe = bfd_link_hash_lookup (link_info->hash, name,
2513 FALSE, FALSE, FALSE);
2515 /* Include the jump stub for <sym> only if the <sym>
2516 is undefined. */
2517 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2519 if (lead_at)
2520 sprintf (name, "%s%s", "__imp_",
2521 pe_def_file->imports[i].internal_name);
2522 else
2523 sprintf (name, "%s%s%s", "__imp_", U (""),
2524 pe_def_file->imports[i].internal_name);
2526 blhe = bfd_link_hash_lookup (link_info->hash, name,
2527 FALSE, FALSE, FALSE);
2529 else
2530 include_jmp_stub = TRUE;
2532 free (name);
2534 if (blhe && blhe->type == bfd_link_hash_undefined)
2536 bfd *one;
2537 /* We do. */
2538 if (!do_this_dll)
2540 bfd *ar_head = make_head (output_bfd);
2541 add_bfd_to_link (ar_head, ar_head->filename, link_info);
2542 do_this_dll = 1;
2544 exp.internal_name = pe_def_file->imports[i].internal_name;
2545 exp.name = pe_def_file->imports[i].name;
2546 exp.ordinal = pe_def_file->imports[i].ordinal;
2547 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2548 exp.flag_private = 0;
2549 exp.flag_constant = 0;
2550 exp.flag_data = pe_def_file->imports[i].data;
2551 exp.flag_noname = exp.name ? 0 : 1;
2552 one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
2553 add_bfd_to_link (one, one->filename, link_info);
2556 if (do_this_dll)
2558 bfd *ar_tail = make_tail (output_bfd);
2559 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2562 free (dll_symname);
2566 /* We were handed a *.DLL file. Parse it and turn it into a set of
2567 IMPORTS directives in the def file. Return TRUE if the file was
2568 handled, FALSE if not. */
2570 static unsigned int
2571 pe_get16 (bfd *abfd, int where)
2573 unsigned char b[2];
2575 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2576 bfd_bread (b, (bfd_size_type) 2, abfd);
2577 return b[0] + (b[1] << 8);
2580 static unsigned int
2581 pe_get32 (bfd *abfd, int where)
2583 unsigned char b[4];
2585 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2586 bfd_bread (b, (bfd_size_type) 4, abfd);
2587 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2590 static unsigned int
2591 pe_as32 (void *ptr)
2593 unsigned char *b = ptr;
2595 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2598 bfd_boolean
2599 pe_implied_import_dll (const char *filename)
2601 bfd *dll;
2602 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
2603 unsigned long export_rva, export_size, nsections, secptr, expptr;
2604 unsigned long exp_funcbase;
2605 unsigned char *expdata;
2606 char *erva;
2607 unsigned long name_rvas, ordinals, nexp, ordbase;
2608 const char *dll_name;
2609 /* Initialization with start > end guarantees that is_data
2610 will not be set by mistake, and avoids compiler warning. */
2611 unsigned long data_start = 1;
2612 unsigned long data_end = 0;
2613 unsigned long rdata_start = 1;
2614 unsigned long rdata_end = 0;
2615 unsigned long bss_start = 1;
2616 unsigned long bss_end = 0;
2618 /* No, I can't use bfd here. kernel32.dll puts its export table in
2619 the middle of the .rdata section. */
2620 dll = bfd_openr (filename, pe_details->target_name);
2621 if (!dll)
2623 einfo ("%Xopen %s: %E\n", filename);
2624 return FALSE;
2627 /* PEI dlls seem to be bfd_objects. */
2628 if (!bfd_check_format (dll, bfd_object))
2630 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2631 return FALSE;
2634 /* Get pe_header, optional header and numbers of export entries. */
2635 pe_header_offset = pe_get32 (dll, 0x3c);
2636 opthdr_ofs = pe_header_offset + 4 + 20;
2637 #ifdef pe_use_x86_64
2638 num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2639 #else
2640 num_entries = pe_get32 (dll, opthdr_ofs + 92);
2641 #endif
2643 if (num_entries < 1) /* No exports. */
2644 return FALSE;
2646 #ifdef pe_use_x86_64
2647 export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
2648 export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
2649 #else
2650 export_rva = pe_get32 (dll, opthdr_ofs + 96);
2651 export_size = pe_get32 (dll, opthdr_ofs + 100);
2652 #endif
2654 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2655 secptr = (pe_header_offset + 4 + 20 +
2656 pe_get16 (dll, pe_header_offset + 4 + 16));
2657 expptr = 0;
2659 /* Get the rva and size of the export section. */
2660 for (i = 0; i < nsections; i++)
2662 char sname[8];
2663 unsigned long secptr1 = secptr + 40 * i;
2664 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2665 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
2666 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
2668 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2669 bfd_bread (sname, (bfd_size_type) 8, dll);
2671 if (vaddr <= export_rva && vaddr + vsize > export_rva)
2673 expptr = fptr + (export_rva - vaddr);
2674 if (export_rva + export_size > vaddr + vsize)
2675 export_size = vsize - (export_rva - vaddr);
2676 break;
2680 /* Scan sections and store the base and size of the
2681 data and bss segments in data/base_start/end. */
2682 for (i = 0; i < nsections; i++)
2684 unsigned long secptr1 = secptr + 40 * i;
2685 unsigned long vsize = pe_get32 (dll, secptr1 + 8);
2686 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2687 unsigned long flags = pe_get32 (dll, secptr1 + 36);
2688 char sec_name[9];
2690 sec_name[8] = '\0';
2691 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
2692 bfd_bread (sec_name, (bfd_size_type) 8, dll);
2694 if (strcmp(sec_name,".data") == 0)
2696 data_start = vaddr;
2697 data_end = vaddr + vsize;
2699 if (pe_dll_extra_pe_debug)
2700 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2701 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2703 else if (strcmp(sec_name,".rdata") == 0)
2705 rdata_start = vaddr;
2706 rdata_end = vaddr + vsize;
2708 if (pe_dll_extra_pe_debug)
2709 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2710 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2712 else if (strcmp (sec_name,".bss") == 0)
2714 bss_start = vaddr;
2715 bss_end = vaddr + vsize;
2717 if (pe_dll_extra_pe_debug)
2718 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2719 __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2723 expdata = xmalloc (export_size);
2724 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2725 bfd_bread (expdata, (bfd_size_type) export_size, dll);
2726 erva = (char *) expdata - export_rva;
2728 if (pe_def_file == 0)
2729 pe_def_file = def_file_empty ();
2731 nexp = pe_as32 (expdata + 24);
2732 name_rvas = pe_as32 (expdata + 32);
2733 ordinals = pe_as32 (expdata + 36);
2734 ordbase = pe_as32 (expdata + 16);
2735 exp_funcbase = pe_as32 (expdata + 28);
2737 /* Use internal dll name instead of filename
2738 to enable symbolic dll linking. */
2739 dll_name = erva + pe_as32 (expdata + 12);
2741 /* Check to see if the dll has already been added to
2742 the definition list and if so return without error.
2743 This avoids multiple symbol definitions. */
2744 if (def_get_module (pe_def_file, dll_name))
2746 if (pe_dll_extra_pe_debug)
2747 printf ("%s is already loaded\n", dll_name);
2748 return TRUE;
2751 /* Iterate through the list of symbols. */
2752 for (i = 0; i < nexp; i++)
2754 /* Pointer to the names vector. */
2755 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
2756 def_file_import *imp;
2757 /* Pointer to the function address vector. */
2758 unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
2759 int is_data = 0;
2761 /* Skip unwanted symbols, which are
2762 exported in buggy auto-import releases. */
2763 if (! CONST_STRNEQ (erva + name_rva, "_nm_"))
2765 /* is_data is true if the address is in the data, rdata or bss
2766 segment. */
2767 is_data =
2768 (func_rva >= data_start && func_rva < data_end)
2769 || (func_rva >= rdata_start && func_rva < rdata_end)
2770 || (func_rva >= bss_start && func_rva < bss_end);
2772 imp = def_file_add_import (pe_def_file, erva + name_rva,
2773 dll_name, i, 0);
2774 /* Mark symbol type. */
2775 imp->data = is_data;
2777 if (pe_dll_extra_pe_debug)
2778 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2779 __FUNCTION__, dll_name, erva + name_rva,
2780 func_rva, is_data ? "(data)" : "");
2784 return TRUE;
2787 /* These are the main functions, called from the emulation. The first
2788 is called after the bfds are read, so we can guess at how much space
2789 we need. The second is called after everything is placed, so we
2790 can put the right values in place. */
2792 void
2793 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
2795 pe_dll_id_target (bfd_get_target (abfd));
2796 process_def_file (abfd, info);
2798 if (pe_def_file->num_exports == 0 && !info->shared)
2799 return;
2801 generate_edata (abfd, info);
2802 build_filler_bfd (1);
2805 void
2806 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2808 pe_dll_id_target (bfd_get_target (abfd));
2809 build_filler_bfd (0);
2812 void
2813 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
2815 pe_dll_id_target (bfd_get_target (abfd));
2816 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2818 generate_reloc (abfd, info);
2819 if (reloc_sz > 0)
2821 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2823 /* Resize the sections. */
2824 lang_reset_memory_regions ();
2825 lang_size_sections (NULL, TRUE);
2827 /* Redo special stuff. */
2828 ldemul_after_allocation ();
2830 /* Do the assignments again. */
2831 lang_do_assignments ();
2834 fill_edata (abfd, info);
2836 if (info->shared && !info->pie)
2837 pe_data (abfd)->dll = 1;
2839 edata_s->contents = edata_d;
2840 reloc_s->contents = reloc_d;
2843 void
2844 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
2846 pe_dll_id_target (bfd_get_target (abfd));
2847 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2849 generate_reloc (abfd, info);
2850 if (reloc_sz > 0)
2852 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2854 /* Resize the sections. */
2855 lang_reset_memory_regions ();
2856 lang_size_sections (NULL, TRUE);
2858 /* Redo special stuff. */
2859 ldemul_after_allocation ();
2861 /* Do the assignments again. */
2862 lang_do_assignments ();
2864 reloc_s->contents = reloc_d;
2867 bfd_boolean
2868 pe_bfd_is_dll (bfd *abfd)
2870 return (bfd_get_format (abfd) == bfd_object
2871 && obj_pe (abfd)
2872 && pe_data (abfd)->dll);