1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008 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. */
26 #include "libiberty.h"
27 #include "safe-ctype.h"
40 #include "coff/internal.h"
41 #include "../bfd/libcoff.h"
46 #define PE_IDATA4_SIZE 8
47 #define PE_IDATA5_SIZE 8
50 #define AOUTSZ PEPAOUTSZ
51 #define PEAOUTHDR PEPAOUTHDR
59 #ifndef PE_IDATA4_SIZE
60 #define PE_IDATA4_SIZE 4
63 #ifndef PE_IDATA5_SIZE
64 #define PE_IDATA5_SIZE 4
67 /* This file turns a regular Windows PE image into a DLL. Because of
68 the complexity of this operation, it has been broken down into a
69 number of separate modules which are all called by the main function
70 at the end of this file. This function is not re-entrant and is
71 normally only called once, so static variables are used to reduce
72 the number of parameters and return values required.
74 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
76 /* Auto-import feature by Paul Sokolovsky
80 1. With this feature on, DLL clients can import variables from DLL
81 without any concern from their side (for example, without any source
84 2. This is done completely in bounds of the PE specification (to be fair,
85 there's a place where it pokes nose out of, but in practice it works).
86 So, resulting module can be used with any other PE compiler/linker.
88 3. Auto-import is fully compatible with standard import method and they
89 can be mixed together.
91 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
92 reference to it; load time: negligible; virtual/physical memory: should be
93 less than effect of DLL relocation, and I sincerely hope it doesn't affect
94 DLL sharability (too much).
98 The obvious and only way to get rid of dllimport insanity is to make client
99 access variable directly in the DLL, bypassing extra dereference. I.e.,
100 whenever client contains something like
104 address of dll_var in the command should be relocated to point into loaded
105 DLL. The aim is to make OS loader do so, and than make ld help with that.
106 Import section of PE made following way: there's a vector of structures
107 each describing imports from particular DLL. Each such structure points
108 to two other parallel vectors: one holding imported names, and one which
109 will hold address of corresponding imported name. So, the solution is
110 de-vectorize these structures, making import locations be sparse and
111 pointing directly into code. Before continuing, it is worth a note that,
112 while authors strives to make PE act ELF-like, there're some other people
113 make ELF act PE-like: elfvector, ;-) .
117 For each reference of data symbol to be imported from DLL (to set of which
118 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
119 import fixup entry is generated. That entry is of type
120 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
121 fixup entry contains pointer to symbol's address within .text section
122 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
123 (so, DLL name is referenced by multiple entries), and pointer to symbol
124 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
125 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
126 containing imported name. Here comes that "on the edge" problem mentioned
127 above: PE specification rambles that name vector (OriginalFirstThunk)
128 should run in parallel with addresses vector (FirstThunk), i.e. that they
129 should have same number of elements and terminated with zero. We violate
130 this, since FirstThunk points directly into machine code. But in practice,
131 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
132 puts addresses to FirstThunk, not something else. It once again should be
133 noted that dll and symbol name structures are reused across fixup entries
134 and should be there anyway to support standard import stuff, so sustained
135 overhead is 20 bytes per reference. Other question is whether having several
136 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
137 done even by native compiler/linker (libth32's functions are in fact reside
138 in windows9x kernel32.dll, so if you use it, you have two
139 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
140 referencing the same PE structures several times is valid. The answer is why
141 not, prohibiting that (detecting violation) would require more work on
142 behalf of loader than not doing it.
144 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
146 static void add_bfd_to_link (bfd
*, const char *, struct bfd_link_info
*);
148 /* For emultempl/pe.em. */
150 def_file
* pe_def_file
= 0;
151 int pe_dll_export_everything
= 0;
152 int pe_dll_do_default_excludes
= 1;
153 int pe_dll_kill_ats
= 0;
154 int pe_dll_stdcall_aliases
= 0;
155 int pe_dll_warn_dup_exports
= 0;
156 int pe_dll_compat_implib
= 0;
157 int pe_dll_extra_pe_debug
= 0;
158 int pe_use_nul_prefixed_import_tables
= 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;
168 static int runtime_pseudp_reloc_v2_init
= 0;
175 autofilter_entry_type
;
179 const char *target_name
;
180 const char *object_target
;
181 unsigned int imagebase_reloc
;
184 bfd_boolean underscored
;
185 const autofilter_entry_type
* autofilter_symbollist
;
189 static const autofilter_entry_type autofilter_symbollist_generic
[] =
191 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
192 /* Entry point symbols. */
193 { STRING_COMMA_LEN ("DllMain") },
194 { STRING_COMMA_LEN ("DllMainCRTStartup") },
195 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
196 /* Runtime pseudo-reloc. */
197 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
198 { STRING_COMMA_LEN ("do_pseudo_reloc") },
202 static const autofilter_entry_type autofilter_symbollist_i386
[] =
204 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
205 /* Entry point symbols, and entry hooks. */
206 { STRING_COMMA_LEN ("cygwin_crt0") },
208 { STRING_COMMA_LEN ("DllMain") },
209 { STRING_COMMA_LEN ("DllEntryPoint") },
210 { STRING_COMMA_LEN ("DllMainCRTStartup") },
211 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
212 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
213 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
215 { STRING_COMMA_LEN ("DllMain@12") },
216 { STRING_COMMA_LEN ("DllEntryPoint@0") },
217 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
218 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
219 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
220 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
221 { STRING_COMMA_LEN ("cygwin_attach_dll") },
223 { STRING_COMMA_LEN ("cygwin_premain0") },
224 { STRING_COMMA_LEN ("cygwin_premain1") },
225 { STRING_COMMA_LEN ("cygwin_premain2") },
226 { STRING_COMMA_LEN ("cygwin_premain3") },
227 /* Runtime pseudo-reloc. */
228 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
229 { STRING_COMMA_LEN ("do_pseudo_reloc") },
230 /* Global vars that should not be exported. */
231 { STRING_COMMA_LEN ("impure_ptr") },
232 { STRING_COMMA_LEN ("_impure_ptr") },
233 { STRING_COMMA_LEN ("_fmode") },
234 { STRING_COMMA_LEN ("environ") },
238 #define PE_ARCH_i386 1
240 #define PE_ARCH_mips 3
241 #define PE_ARCH_arm 4
242 #define PE_ARCH_arm_epoc 5
243 #define PE_ARCH_arm_wince 6
245 static const pe_details_type pe_detail_list
[] =
260 autofilter_symbollist_i386
265 16 /* R_SH_IMAGEBASE */,
269 autofilter_symbollist_generic
278 autofilter_symbollist_generic
287 autofilter_symbollist_generic
290 "epoc-pei-arm-little",
291 "epoc-pe-arm-little",
296 autofilter_symbollist_generic
299 "pei-arm-wince-little",
300 "pe-arm-wince-little",
301 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
305 autofilter_symbollist_generic
307 { NULL
, NULL
, 0, 0, 0, FALSE
, NULL
}
310 static const pe_details_type
*pe_details
;
312 /* Do not specify library suffix explicitly, to allow for dllized versions. */
313 static const autofilter_entry_type autofilter_liblist
[] =
315 { STRING_COMMA_LEN ("libcegcc") },
316 { STRING_COMMA_LEN ("libcygwin") },
317 { STRING_COMMA_LEN ("libgcc") },
318 { STRING_COMMA_LEN ("libgcc_s") },
319 { STRING_COMMA_LEN ("libstdc++") },
320 { STRING_COMMA_LEN ("libmingw32") },
321 { STRING_COMMA_LEN ("libmingwex") },
322 { STRING_COMMA_LEN ("libg2c") },
323 { STRING_COMMA_LEN ("libsupc++") },
324 { STRING_COMMA_LEN ("libobjc") },
325 { STRING_COMMA_LEN ("libgcj") },
329 /* Regardless of the suffix issue mentioned above, we must ensure that
330 we do not falsely match on a leading substring, such as when libtool
331 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
332 This routine ensures that the leading part of the name matches and that
333 it is followed by only an optional version suffix and a file extension,
334 returning zero if so or -1 if not. */
335 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
337 if (strncmp (libname
, afptr
->name
, afptr
->len
))
340 libname
+= afptr
->len
;
342 /* Be liberal in interpreting what counts as a version suffix; we
343 accept anything that has a dash to separate it from the name and
344 begins with a digit. */
345 if (libname
[0] == '-')
347 if (!ISDIGIT (*++libname
))
349 /* Ensure the filename has an extension. */
350 while (*++libname
!= '.')
354 else if (libname
[0] != '.')
360 static const autofilter_entry_type autofilter_objlist
[] =
362 { STRING_COMMA_LEN ("crt0.o") },
363 { STRING_COMMA_LEN ("crt1.o") },
364 { STRING_COMMA_LEN ("crt2.o") },
365 { STRING_COMMA_LEN ("dllcrt1.o") },
366 { STRING_COMMA_LEN ("dllcrt2.o") },
367 { STRING_COMMA_LEN ("gcrt0.o") },
368 { STRING_COMMA_LEN ("gcrt1.o") },
369 { STRING_COMMA_LEN ("gcrt2.o") },
370 { STRING_COMMA_LEN ("crtbegin.o") },
371 { STRING_COMMA_LEN ("crtend.o") },
375 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
377 /* _imp_ is treated specially, as it is always underscored. */
378 /* { STRING_COMMA_LEN ("_imp_") }, */
379 /* Don't export some c++ symbols. */
380 { STRING_COMMA_LEN ("__rtti_") },
381 { STRING_COMMA_LEN ("__builtin_") },
382 /* Don't re-export auto-imported symbols. */
383 { STRING_COMMA_LEN ("_nm_") },
384 /* Don't export symbols specifying internal DLL layout. */
385 { STRING_COMMA_LEN ("_head_") },
386 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
387 /* Don't export section labels or artificial symbols
389 { STRING_COMMA_LEN (".") },
393 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
395 { STRING_COMMA_LEN ("_iname") },
396 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
400 #define U(str) (pe_details->underscored ? "_" str : str)
403 pe_dll_id_target (const char *target
)
407 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
408 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
409 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
411 pe_details
= pe_detail_list
+ i
;
414 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
418 /* Helper functions for qsort. Relocs must be sorted so that we can write
419 them out by pages. */
430 reloc_sort (const void *va
, const void *vb
)
432 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
433 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
435 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
439 pe_export_sort (const void *va
, const void *vb
)
441 const def_file_export
*a
= va
;
442 const def_file_export
*b
= vb
;
444 return strcmp (a
->name
, b
->name
);
447 /* Read and process the .DEF file. */
449 /* These correspond to the entries in pe_def_file->exports[]. I use
450 exported_symbol_sections[i] to tag whether or not the symbol was
451 defined, since we can't export symbols we don't have. */
453 static bfd_vma
*exported_symbol_offsets
;
454 static struct bfd_section
**exported_symbol_sections
;
455 static int export_table_size
;
456 static int count_exported
;
457 static int count_exported_byname
;
458 static int count_with_ordinals
;
459 static const char *dll_name
;
460 static int min_ordinal
, max_ordinal
;
461 static int *exported_symbols
;
463 typedef struct exclude_list_struct
466 struct exclude_list_struct
*next
;
471 static struct exclude_list_struct
*excludes
= 0;
474 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
477 char *exclude_string
;
479 local_copy
= xstrdup (new_excludes
);
481 exclude_string
= strtok (local_copy
, ",:");
482 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
484 struct exclude_list_struct
*new_exclude
;
486 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
487 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
488 strcpy (new_exclude
->string
, exclude_string
);
489 new_exclude
->type
= type
;
490 new_exclude
->next
= excludes
;
491 excludes
= new_exclude
;
498 is_import (const char* n
)
500 return (CONST_STRNEQ (n
, "__imp_"));
503 /* abfd is a bfd containing n (or NULL)
504 It can be used for contextual checks. */
507 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
510 struct exclude_list_struct
*ex
;
511 const autofilter_entry_type
*afptr
;
512 const char * libname
= 0;
513 if (abfd
&& abfd
->my_archive
)
514 libname
= lbasename (abfd
->my_archive
->filename
);
516 for (i
= 0; i
< d
->num_exports
; i
++)
517 if (strcmp (d
->exports
[i
].name
, n
) == 0)
520 if (pe_dll_do_default_excludes
)
525 if (pe_dll_extra_pe_debug
)
526 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
527 n
, abfd
, abfd
->my_archive
);
529 /* First of all, make context checks:
530 Don't export anything from standard libs. */
533 afptr
= autofilter_liblist
;
537 if (libnamencmp (libname
, afptr
) == 0 )
543 /* Next, exclude symbols from certain startup objects. */
545 if (abfd
&& (p
= lbasename (abfd
->filename
)))
547 afptr
= autofilter_objlist
;
550 if (strcmp (p
, afptr
->name
) == 0)
556 /* Don't try to blindly exclude all symbols
557 that begin with '__'; this was tried and
558 it is too restrictive. Instead we have
559 a target specific list to use: */
560 afptr
= pe_details
->autofilter_symbollist
;
564 if (strcmp (n
, afptr
->name
) == 0)
570 /* Next, exclude symbols starting with ... */
571 afptr
= autofilter_symbolprefixlist
;
574 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
580 /* Finally, exclude symbols ending with ... */
582 afptr
= autofilter_symbolsuffixlist
;
585 if ((len
>= afptr
->len
)
586 /* Add 1 to insure match with trailing '\0'. */
587 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
588 afptr
->len
+ 1) == 0)
595 for (ex
= excludes
; ex
; ex
= ex
->next
)
597 if (ex
->type
== EXCLUDELIBS
)
600 && ((strcmp (libname
, ex
->string
) == 0)
601 || (strcasecmp ("ALL", ex
->string
) == 0)))
604 else if (ex
->type
== EXCLUDEFORIMPLIB
)
606 if (strcmp (abfd
->filename
, ex
->string
) == 0)
609 else if (strcmp (n
, ex
->string
) == 0)
617 process_def_file (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
620 struct bfd_link_hash_entry
*blhe
;
622 struct bfd_section
*s
;
623 def_file_export
*e
= 0;
626 pe_def_file
= def_file_empty ();
628 /* First, run around to all the objects looking for the .drectve
629 sections, and push those into the def file too. */
630 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
632 s
= bfd_get_section_by_name (b
, ".drectve");
636 char *buf
= xmalloc (size
);
638 bfd_get_section_contents (b
, s
, buf
, 0, size
);
639 def_file_add_directive (pe_def_file
, buf
, size
);
644 /* If we are not building a DLL, when there are no exports
645 we do not build an export table at all. */
646 if (!pe_dll_export_everything
&& pe_def_file
->num_exports
== 0
650 /* Now, maybe export everything else the default way. */
651 if (pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
653 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
658 if (!bfd_generic_link_read_symbols (b
))
660 einfo (_("%B%F: could not read symbols: %E\n"), b
);
664 symbols
= bfd_get_outsymbols (b
);
665 nsyms
= bfd_get_symcount (b
);
667 for (j
= 0; j
< nsyms
; j
++)
669 /* We should export symbols which are either global or not
670 anything at all. (.bss data is the latter)
671 We should not export undefined symbols. */
672 if (symbols
[j
]->section
!= &bfd_und_section
673 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
674 || (symbols
[j
]->flags
== 0)))
676 const char *sn
= symbols
[j
]->name
;
678 /* We should not re-export imported stuff. */
684 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
685 sprintf (name
, "%s%s", "__imp_", sn
);
687 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
688 FALSE
, FALSE
, FALSE
);
691 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
695 if (pe_details
->underscored
&& *sn
== '_')
698 if (auto_export (b
, pe_def_file
, sn
))
701 p
=def_file_add_export (pe_def_file
, sn
, 0, -1);
702 /* Fill data flag properly, from dlltool.c. */
703 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
711 #define NE pe_def_file->num_exports
713 /* Canonicalize the export list. */
716 for (i
= 0; i
< NE
; i
++)
718 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
720 /* This will preserve internal_name, which may have been
721 pointing to the same memory as name, or might not
723 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
724 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
725 char *tmp_at
= strchr (tmp
, '@');
730 einfo (_("%XCannot export %s: invalid export name\n"),
731 pe_def_file
->exports
[i
].name
);
732 pe_def_file
->exports
[i
].name
= tmp
;
737 if (pe_dll_stdcall_aliases
)
739 for (i
= 0; i
< NE
; i
++)
741 if (is_import (pe_def_file
->exports
[i
].name
))
744 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
746 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
747 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
749 *(strchr (tmp
, '@')) = 0;
750 if (auto_export (NULL
, pe_def_file
, tmp
))
751 def_file_add_export (pe_def_file
, tmp
,
752 pe_def_file
->exports
[i
].internal_name
,
760 /* Convenience, but watch out for it changing. */
761 e
= pe_def_file
->exports
;
763 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
764 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
766 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
770 count_exported_byname
= 0;
771 count_with_ordinals
= 0;
773 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
775 for (i
= 0, j
= 0; i
< NE
; i
++)
777 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
779 /* This is a duplicate. */
780 if (e
[j
- 1].ordinal
!= -1
781 && e
[i
].ordinal
!= -1
782 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
784 if (pe_dll_warn_dup_exports
)
785 /* xgettext:c-format */
786 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
787 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
791 if (pe_dll_warn_dup_exports
)
792 /* xgettext:c-format */
793 einfo (_("Warning, duplicate EXPORT: %s\n"),
797 if (e
[i
].ordinal
!= -1)
798 e
[j
- 1].ordinal
= e
[i
].ordinal
;
799 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
800 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
801 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
802 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
811 pe_def_file
->num_exports
= j
; /* == NE */
813 for (i
= 0; i
< NE
; i
++)
817 /* Check for forward exports */
818 if (strchr (pe_def_file
->exports
[i
].internal_name
, '.'))
821 if (!pe_def_file
->exports
[i
].flag_noname
)
822 count_exported_byname
++;
824 pe_def_file
->exports
[i
].flag_forward
= 1;
826 if (pe_def_file
->exports
[i
].ordinal
!= -1)
828 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
829 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
830 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
831 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
832 count_with_ordinals
++;
838 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
839 if (pe_details
->underscored
840 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
843 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
846 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
848 blhe
= bfd_link_hash_lookup (info
->hash
,
853 && (blhe
->type
== bfd_link_hash_defined
854 || (blhe
->type
== bfd_link_hash_common
)))
857 if (!pe_def_file
->exports
[i
].flag_noname
)
858 count_exported_byname
++;
860 /* Only fill in the sections. The actual offsets are computed
861 in fill_exported_offsets() after common symbols are laid
863 if (blhe
->type
== bfd_link_hash_defined
)
864 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
866 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
868 if (pe_def_file
->exports
[i
].ordinal
!= -1)
870 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
871 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
872 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
873 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
874 count_with_ordinals
++;
877 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
879 /* xgettext:c-format */
880 einfo (_("%XCannot export %s: symbol not defined\n"),
881 pe_def_file
->exports
[i
].internal_name
);
885 /* xgettext:c-format */
886 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
887 pe_def_file
->exports
[i
].internal_name
,
888 blhe
->type
, bfd_link_hash_defined
);
892 /* xgettext:c-format */
893 einfo (_("%XCannot export %s: symbol not found\n"),
894 pe_def_file
->exports
[i
].internal_name
);
900 /* Build the bfd that will contain .edata and .reloc sections. */
903 build_filler_bfd (int include_edata
)
905 lang_input_statement_type
*filler_file
;
906 filler_file
= lang_add_input_file ("dll stuff",
907 lang_input_file_is_fake_enum
,
909 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
910 link_info
.output_bfd
);
911 if (filler_bfd
== NULL
912 || !bfd_set_arch_mach (filler_bfd
,
913 bfd_get_arch (link_info
.output_bfd
),
914 bfd_get_mach (link_info
.output_bfd
)))
916 einfo ("%X%P: can not create BFD: %E\n");
922 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
924 || !bfd_set_section_flags (filler_bfd
, edata_s
,
931 einfo ("%X%P: can not create .edata section: %E\n");
934 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
937 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
939 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
946 einfo ("%X%P: can not create .reloc section: %E\n");
950 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
952 ldlang_add_file (filler_file
);
955 /* Gather all the exported symbols and build the .edata section. */
958 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
961 int name_table_size
= 0;
964 /* First, we need to know how many exported symbols there are,
965 and what the range of ordinals is. */
966 if (pe_def_file
->name
)
967 dll_name
= pe_def_file
->name
;
970 dll_name
= abfd
->filename
;
972 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
973 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
977 if (count_with_ordinals
&& max_ordinal
> count_exported
)
979 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
980 min_ordinal
= max_ordinal
- count_exported
+ 1;
985 max_ordinal
= count_exported
;
988 export_table_size
= max_ordinal
- min_ordinal
+ 1;
989 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
990 for (i
= 0; i
< export_table_size
; i
++)
991 exported_symbols
[i
] = -1;
993 /* Now we need to assign ordinals to those that don't have them. */
994 for (i
= 0; i
< NE
; i
++)
996 if (exported_symbol_sections
[i
] ||
997 pe_def_file
->exports
[i
].flag_forward
)
999 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1001 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1002 int pi
= exported_symbols
[ei
];
1006 /* xgettext:c-format */
1007 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1008 pe_def_file
->exports
[i
].ordinal
,
1009 pe_def_file
->exports
[i
].name
,
1010 pe_def_file
->exports
[pi
].name
);
1012 exported_symbols
[ei
] = i
;
1014 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1017 /* Reserve space for the forward name. */
1018 if (pe_def_file
->exports
[i
].flag_forward
)
1020 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1024 next_ordinal
= min_ordinal
;
1025 for (i
= 0; i
< NE
; i
++)
1026 if ((exported_symbol_sections
[i
] ||
1027 pe_def_file
->exports
[i
].flag_forward
) &&
1028 pe_def_file
->exports
[i
].ordinal
== -1)
1030 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1033 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1034 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1037 /* OK, now we can allocate some memory. */
1038 edata_sz
= (40 /* directory */
1039 + 4 * export_table_size
/* addresses */
1040 + 4 * count_exported_byname
/* name ptrs */
1041 + 2 * count_exported_byname
/* ordinals */
1042 + name_table_size
+ strlen (dll_name
) + 1);
1045 /* Fill the exported symbol offsets. The preliminary work has already
1046 been done in process_def_file(). */
1049 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1052 struct bfd_link_hash_entry
*blhe
;
1054 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1058 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1059 if (pe_details
->underscored
1060 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1063 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1066 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1068 blhe
= bfd_link_hash_lookup (info
->hash
,
1070 FALSE
, FALSE
, TRUE
);
1072 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1073 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1080 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1083 unsigned char *edirectory
;
1084 unsigned char *eaddresses
;
1085 unsigned char *enameptrs
;
1086 unsigned char *eordinals
;
1092 edata_d
= xmalloc (edata_sz
);
1094 /* Note use of array pointer math here. */
1095 edirectory
= edata_d
;
1096 eaddresses
= edata_d
+ 40;
1097 enameptrs
= eaddresses
+ 4 * export_table_size
;
1098 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1099 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1101 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1102 + edata_s->output_section->vma - image_base)
1104 memset (edata_d
, 0, edata_sz
);
1105 bfd_put_32 (abfd
, now
, edata_d
+ 4);
1106 if (pe_def_file
->version_major
!= -1)
1108 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1109 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1112 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1113 strcpy (enamestr
, dll_name
);
1114 enamestr
+= strlen (enamestr
) + 1;
1115 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1116 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1117 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1118 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1119 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1120 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1122 fill_exported_offsets (abfd
, info
);
1124 /* Ok, now for the filling in part.
1125 Scan alphabetically - ie the ordering in the exports[] table,
1126 rather than by ordinal - the ordering in the exported_symbol[]
1127 table. See dlltool.c and:
1128 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1129 for more information. */
1131 for (s
= 0; s
< NE
; s
++)
1133 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1134 if (pe_def_file
->exports
[s
].ordinal
!= -1 &&
1135 (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1137 int ord
= pe_def_file
->exports
[s
].ordinal
;
1139 if (pe_def_file
->exports
[s
].flag_forward
)
1141 bfd_put_32 (abfd
, ERVA (enamestr
),
1142 eaddresses
+ 4 * (ord
- min_ordinal
));
1144 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1145 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1149 bfd_vma srva
= (exported_symbol_offsets
[s
]
1150 + ssec
->output_section
->vma
1151 + ssec
->output_offset
);
1153 bfd_put_32 (abfd
, srva
- image_base
,
1154 eaddresses
+ 4 * (ord
- min_ordinal
));
1157 if (!pe_def_file
->exports
[s
].flag_noname
)
1159 char *ename
= pe_def_file
->exports
[s
].name
;
1161 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1163 strcpy (enamestr
, ename
);
1164 enamestr
+= strlen (enamestr
) + 1;
1165 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1167 pe_def_file
->exports
[s
].hint
= hint
++;
1174 static struct bfd_section
*current_sec
;
1177 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1179 int (*cb
) (arelent
*, asection
*))
1184 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1189 if (!bfd_generic_link_read_symbols (b
))
1191 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1195 symbols
= bfd_get_outsymbols (b
);
1196 nsyms
= bfd_get_symcount (b
);
1198 for (s
= b
->sections
; s
; s
= s
->next
)
1201 int relsize
, nrelocs
, i
;
1202 int flags
= bfd_get_section_flags (b
, s
);
1204 /* Skip discarded linkonce sections. */
1205 if (flags
& SEC_LINK_ONCE
1206 && s
->output_section
== bfd_abs_section_ptr
)
1211 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1212 relocs
= xmalloc (relsize
);
1213 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1215 for (i
= 0; i
< nrelocs
; i
++)
1217 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1219 if (!strcmp (name
, sym
->name
))
1225 /* Warning: the allocated symbols are remembered in BFD and reused
1226 later, so don't free them! */
1227 /* free (symbols); */
1232 /* Gather all the relocations and build the .reloc section. */
1235 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1238 /* For .reloc stuff. */
1239 reloc_data_type
*reloc_data
;
1240 int total_relocs
= 0;
1242 bfd_vma sec_page
= (bfd_vma
) -1;
1243 bfd_vma page_ptr
, page_count
;
1246 struct bfd_section
*s
;
1249 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1250 for (s
= b
->sections
; s
; s
= s
->next
)
1251 total_relocs
+= s
->reloc_count
;
1253 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1257 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1260 int relsize
, nrelocs
, i
;
1262 for (s
= b
->sections
; s
; s
= s
->next
)
1264 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1268 /* If it's not loaded, we don't need to relocate it this way. */
1269 if (!(s
->output_section
->flags
& SEC_LOAD
))
1272 /* I don't know why there would be a reloc for these, but I've
1273 seen it happen - DJ */
1274 if (s
->output_section
== &bfd_abs_section
)
1277 if (s
->output_section
->vma
== 0)
1279 /* Huh? Shouldn't happen, but punt if it does. */
1280 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1281 s
->output_section
->name
, s
->output_section
->index
,
1282 s
->output_section
->flags
);
1286 if (!bfd_generic_link_read_symbols (b
))
1288 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1292 symbols
= bfd_get_outsymbols (b
);
1293 nsyms
= bfd_get_symcount (b
);
1294 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1295 relocs
= xmalloc (relsize
);
1296 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1298 for (i
= 0; i
< nrelocs
; i
++)
1300 if (pe_dll_extra_pe_debug
)
1302 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1303 printf ("rel: %s\n", sym
->name
);
1305 if (!relocs
[i
]->howto
->pc_relative
1306 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1309 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1311 /* Don't create relocs for undefined weak symbols. */
1312 if (sym
->flags
== BSF_WEAK
)
1314 struct bfd_link_hash_entry
*blhe
1315 = bfd_link_hash_lookup (info
->hash
, sym
->name
,
1316 FALSE
, FALSE
, FALSE
);
1317 if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1321 sym_vma
= (relocs
[i
]->addend
1324 + sym
->section
->output_offset
1325 + sym
->section
->output_section
->vma
);
1326 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1328 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1330 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1331 relocs
[i
]->howto
->rightshift
)
1333 #ifdef pe_use_x86_64
1334 case BITS_AND_SHIFT (64, 0):
1335 reloc_data
[total_relocs
].type
= 10;
1339 case BITS_AND_SHIFT (32, 0):
1340 reloc_data
[total_relocs
].type
= 3;
1343 case BITS_AND_SHIFT (16, 0):
1344 reloc_data
[total_relocs
].type
= 2;
1347 case BITS_AND_SHIFT (16, 16):
1348 reloc_data
[total_relocs
].type
= 4;
1349 /* FIXME: we can't know the symbol's right value
1350 yet, but we probably can safely assume that
1351 CE will relocate us in 64k blocks, so leaving
1353 reloc_data
[total_relocs
].extra
= 0;
1356 case BITS_AND_SHIFT (26, 2):
1357 reloc_data
[total_relocs
].type
= 5;
1360 case BITS_AND_SHIFT (24, 2):
1361 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1362 Those ARM_xxx definitions should go in proper
1364 if (relocs
[i
]->howto
->type
== 0
1365 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1366 || relocs
[i
]->howto
->type
== 5)
1367 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1368 that has already been fully processed during a
1369 previous link stage, so ignore it here. */
1373 /* xgettext:c-format */
1374 einfo (_("%XError: %d-bit reloc in dll\n"),
1375 relocs
[i
]->howto
->bitsize
);
1381 /* Warning: the allocated symbols are remembered in BFD and
1382 reused later, so don't free them! */
1386 /* At this point, we have total_relocs relocation addresses in
1387 reloc_addresses, which are all suitable for the .reloc section.
1388 We must now create the new sections. */
1389 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1391 for (i
= 0; i
< total_relocs
; i
++)
1393 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1395 if (this_page
!= sec_page
)
1397 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1399 sec_page
= this_page
;
1404 if (reloc_data
[i
].type
== 4)
1408 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1409 reloc_d
= xmalloc (reloc_sz
);
1410 sec_page
= (bfd_vma
) -1;
1412 page_ptr
= (bfd_vma
) -1;
1415 for (i
= 0; i
< total_relocs
; i
++)
1417 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1418 bfd_vma this_page
= (rva
& ~0xfff);
1420 if (this_page
!= sec_page
)
1422 while (reloc_sz
& 3)
1423 reloc_d
[reloc_sz
++] = 0;
1425 if (page_ptr
!= (bfd_vma
) -1)
1426 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1428 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1429 page_ptr
= reloc_sz
;
1431 sec_page
= this_page
;
1435 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1436 reloc_d
+ reloc_sz
);
1439 if (reloc_data
[i
].type
== 4)
1441 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1448 while (reloc_sz
& 3)
1449 reloc_d
[reloc_sz
++] = 0;
1451 if (page_ptr
!= (bfd_vma
) -1)
1452 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1454 while (reloc_sz
< reloc_s
->size
)
1455 reloc_d
[reloc_sz
++] = 0;
1458 /* Given the exiting def_file structure, print out a .DEF file that
1459 corresponds to it. */
1462 quoteput (char *s
, FILE *f
, int needs_quotes
)
1466 for (cp
= s
; *cp
; cp
++)
1481 if (*s
== '"' || *s
== '\\')
1495 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1498 FILE *out
= fopen (pe_out_def_filename
, "w");
1501 /* xgettext:c-format */
1502 einfo (_("%s: Can't open output def file %s\n"),
1503 program_name
, pe_out_def_filename
);
1507 if (pe_def_file
->name
)
1509 if (pe_def_file
->is_dll
)
1510 fprintf (out
, "LIBRARY ");
1512 fprintf (out
, "NAME ");
1514 quoteput (pe_def_file
->name
, out
, 1);
1516 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1518 fprintf (out
, " BASE=0x");
1519 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1521 fprintf (out
, "\n");
1524 if (pe_def_file
->description
)
1526 fprintf (out
, "DESCRIPTION ");
1527 quoteput (pe_def_file
->description
, out
, 1);
1528 fprintf (out
, "\n");
1531 if (pe_def_file
->version_minor
!= -1)
1532 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1533 pe_def_file
->version_minor
);
1534 else if (pe_def_file
->version_major
!= -1)
1535 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1537 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1538 fprintf (out
, "\n");
1540 if (pe_def_file
->stack_commit
!= -1)
1541 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1542 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1543 else if (pe_def_file
->stack_reserve
!= -1)
1544 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1546 if (pe_def_file
->heap_commit
!= -1)
1547 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1548 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1549 else if (pe_def_file
->heap_reserve
!= -1)
1550 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1552 if (pe_def_file
->num_section_defs
> 0)
1554 fprintf (out
, "\nSECTIONS\n\n");
1556 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1559 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1561 if (pe_def_file
->section_defs
[i
].class)
1563 fprintf (out
, " CLASS ");
1564 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1567 if (pe_def_file
->section_defs
[i
].flag_read
)
1568 fprintf (out
, " READ");
1570 if (pe_def_file
->section_defs
[i
].flag_write
)
1571 fprintf (out
, " WRITE");
1573 if (pe_def_file
->section_defs
[i
].flag_execute
)
1574 fprintf (out
, " EXECUTE");
1576 if (pe_def_file
->section_defs
[i
].flag_shared
)
1577 fprintf (out
, " SHARED");
1579 fprintf (out
, "\n");
1583 if (pe_def_file
->num_exports
> 0)
1585 fprintf (out
, "EXPORTS\n");
1587 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1589 def_file_export
*e
= pe_def_file
->exports
+ i
;
1591 quoteput (e
->name
, out
, 0);
1593 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1595 fprintf (out
, " = ");
1596 quoteput (e
->internal_name
, out
, 0);
1599 if (e
->ordinal
!= -1)
1600 fprintf (out
, " @%d", e
->ordinal
);
1602 if (e
->flag_private
)
1603 fprintf (out
, " PRIVATE");
1605 if (e
->flag_constant
)
1606 fprintf (out
, " CONSTANT");
1609 fprintf (out
, " NONAME");
1612 fprintf (out
, " DATA");
1614 fprintf (out
, "\n");
1618 if (pe_def_file
->num_imports
> 0)
1620 fprintf (out
, "\nIMPORTS\n\n");
1622 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1624 def_file_import
*im
= pe_def_file
->imports
+ i
;
1627 if (im
->internal_name
1628 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1630 quoteput (im
->internal_name
, out
, 0);
1631 fprintf (out
, " = ");
1634 quoteput (im
->module
->name
, out
, 0);
1638 quoteput (im
->name
, out
, 0);
1640 fprintf (out
, "%d", im
->ordinal
);
1642 fprintf (out
, "\n");
1647 fprintf (out
, _("; no contents available\n"));
1649 if (fclose (out
) == EOF
)
1650 /* xgettext:c-format */
1651 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1654 /* Generate the import library. */
1656 static asymbol
**symtab
;
1659 static int tmp_seq2
;
1660 static const char *dll_filename
;
1661 static char *dll_symname
;
1663 #define UNDSEC (asection *) &bfd_und_section
1666 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1671 sec
= bfd_make_section_old_way (abfd
, name
);
1672 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1673 bfd_set_section_alignment (abfd
, sec
, align
);
1674 /* Remember to undo this before trying to link internally! */
1675 sec
->output_section
= sec
;
1677 sym
= bfd_make_empty_symbol (abfd
);
1678 symtab
[symptr
++] = sym
;
1679 sym
->name
= sec
->name
;
1681 sym
->flags
= BSF_LOCAL
;
1688 quick_symbol (bfd
*abfd
,
1697 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1702 sym
= bfd_make_empty_symbol (abfd
);
1707 symtab
[symptr
++] = sym
;
1710 static arelent
*reltab
= 0;
1711 static int relcount
= 0, relsize
= 0;
1714 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1716 if (relcount
>= relsize
- 1)
1720 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1722 reltab
= xmalloc (relsize
* sizeof (arelent
));
1724 reltab
[relcount
].address
= address
;
1725 reltab
[relcount
].addend
= 0;
1726 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1727 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1732 save_relocs (asection
*sec
)
1736 sec
->relocation
= reltab
;
1737 sec
->reloc_count
= relcount
;
1738 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1739 for (i
= 0; i
< relcount
; i
++)
1740 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1741 sec
->orelocation
[relcount
] = 0;
1742 sec
->flags
|= SEC_RELOC
;
1744 relcount
= relsize
= 0;
1747 /* .section .idata$2
1748 .global __head_my_dll
1765 make_head (bfd
*parent
)
1767 asection
*id2
, *id5
, *id4
;
1768 unsigned char *d2
, *d5
, *d4
;
1772 oname
= xmalloc (20);
1773 sprintf (oname
, "d%06d.o", tmp_seq
);
1776 abfd
= bfd_create (oname
, parent
);
1777 bfd_find_target (pe_details
->object_target
, abfd
);
1778 bfd_make_writable (abfd
);
1780 bfd_set_format (abfd
, bfd_object
);
1781 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1784 symtab
= xmalloc (6 * sizeof (asymbol
*));
1785 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1786 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1787 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1788 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1789 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1791 /* OK, pay attention here. I got confused myself looking back at
1792 it. We create a four-byte section to mark the beginning of the
1793 list, and we include an offset of 4 in the section, so that the
1794 pointer to the list points to the *end* of this section, which is
1795 the start of the list of sections from other objects. */
1797 bfd_set_section_size (abfd
, id2
, 20);
1801 if (pe_use_nul_prefixed_import_tables
)
1802 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
1803 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1804 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1805 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1808 if (pe_use_nul_prefixed_import_tables
)
1809 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1811 bfd_set_section_size (abfd
, id5
, 0);
1812 d5
= xmalloc (PE_IDATA5_SIZE
);
1814 memset (d5
, 0, PE_IDATA5_SIZE
);
1815 if (pe_use_nul_prefixed_import_tables
)
1816 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1818 bfd_set_section_size (abfd
, id4
, 0);
1819 d4
= xmalloc (PE_IDATA4_SIZE
);
1821 memset (d4
, 0, PE_IDATA4_SIZE
);
1823 bfd_set_symtab (abfd
, symtab
, symptr
);
1825 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1826 if (pe_use_nul_prefixed_import_tables
)
1828 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1829 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1833 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
1834 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
1837 bfd_make_readable (abfd
);
1841 /* .section .idata$4
1848 .global __my_dll_iname
1853 make_tail (bfd
*parent
)
1855 asection
*id4
, *id5
, *id7
;
1856 unsigned char *d4
, *d5
, *d7
;
1861 oname
= xmalloc (20);
1862 sprintf (oname
, "d%06d.o", tmp_seq
);
1865 abfd
= bfd_create (oname
, parent
);
1866 bfd_find_target (pe_details
->object_target
, abfd
);
1867 bfd_make_writable (abfd
);
1869 bfd_set_format (abfd
, bfd_object
);
1870 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1873 symtab
= xmalloc (5 * sizeof (asymbol
*));
1874 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1875 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1876 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1877 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1879 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1880 d4
= xmalloc (PE_IDATA4_SIZE
);
1882 memset (d4
, 0, PE_IDATA4_SIZE
);
1884 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1885 d5
= xmalloc (PE_IDATA5_SIZE
);
1887 memset (d5
, 0, PE_IDATA5_SIZE
);
1889 len
= strlen (dll_filename
) + 1;
1892 bfd_set_section_size (abfd
, id7
, len
);
1895 strcpy ((char *) d7
, dll_filename
);
1896 /* If len was odd, the above
1897 strcpy leaves behind an undefined byte. That is harmless,
1898 but we set it to 0 just so the binary dumps are pretty. */
1901 bfd_set_symtab (abfd
, symtab
, symptr
);
1903 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1904 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1905 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1907 bfd_make_readable (abfd
);
1913 .global ___imp_function
1914 .global __imp__function
1916 jmp *__imp__function:
1930 .asciz "function" xlate? (add underscore, kill at) */
1932 static const unsigned char jmp_ix86_bytes
[] =
1934 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1942 .dw __imp_function */
1944 static const unsigned char jmp_sh_bytes
[] =
1946 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1950 lui $t0,<high:__imp_function>
1951 lw $t0,<low:__imp_function>
1955 static const unsigned char jmp_mips_bytes
[] =
1957 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1958 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1961 static const unsigned char jmp_arm_bytes
[] =
1963 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1964 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1970 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
1972 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1973 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1977 const unsigned char *jmp_bytes
= NULL
;
1978 int jmp_byte_count
= 0;
1980 /* Include the jump stub section only if it is needed. A jump
1981 stub is needed if the symbol being imported <sym> is a function
1982 symbol and there is at least one undefined reference to that
1983 symbol. In other words, if all the import references to <sym> are
1984 explicitly through _declspec(dllimport) then the jump stub is not
1986 if (include_jmp_stub
)
1988 switch (pe_details
->pe_arch
)
1991 jmp_bytes
= jmp_ix86_bytes
;
1992 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1995 jmp_bytes
= jmp_sh_bytes
;
1996 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1999 jmp_bytes
= jmp_mips_bytes
;
2000 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2003 case PE_ARCH_arm_epoc
:
2004 case PE_ARCH_arm_wince
:
2005 jmp_bytes
= jmp_arm_bytes
;
2006 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2013 oname
= xmalloc (20);
2014 sprintf (oname
, "d%06d.o", tmp_seq
);
2017 abfd
= bfd_create (oname
, parent
);
2018 bfd_find_target (pe_details
->object_target
, abfd
);
2019 bfd_make_writable (abfd
);
2021 bfd_set_format (abfd
, bfd_object
);
2022 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2025 symtab
= xmalloc (11 * sizeof (asymbol
*));
2026 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
2027 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2028 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2029 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2030 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2032 if (*exp
->internal_name
== '@')
2034 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2036 if (include_jmp_stub
)
2037 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2038 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2040 /* Fastcall applies only to functions,
2041 so no need for auto-import symbol. */
2045 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2047 if (include_jmp_stub
)
2048 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2050 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2052 /* Symbol to reference ord/name of imported
2053 data symbol, used to implement auto-import. */
2055 quick_symbol (abfd
, U ("_nm_"), U (""), exp
->internal_name
, id6
,
2058 if (pe_dll_compat_implib
)
2059 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "", id5
,
2062 if (include_jmp_stub
)
2064 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
2065 td
= xmalloc (jmp_byte_count
);
2067 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2069 switch (pe_details
->pe_arch
)
2072 #ifdef pe_use_x86_64
2073 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2075 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2079 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2082 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2083 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2084 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2087 case PE_ARCH_arm_epoc
:
2088 case PE_ARCH_arm_wince
:
2089 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2097 bfd_set_section_size (abfd
, tx
, 0);
2099 bfd_set_section_size (abfd
, id7
, 4);
2103 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2106 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2107 d5
= xmalloc (PE_IDATA5_SIZE
);
2109 memset (d5
, 0, PE_IDATA5_SIZE
);
2111 if (exp
->flag_noname
)
2113 d5
[0] = exp
->ordinal
;
2114 d5
[1] = exp
->ordinal
>> 8;
2115 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2119 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2123 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2124 d4
= xmalloc (PE_IDATA4_SIZE
);
2126 memset (d4
, 0, PE_IDATA4_SIZE
);
2128 if (exp
->flag_noname
)
2130 d4
[0] = exp
->ordinal
;
2131 d4
[1] = exp
->ordinal
>> 8;
2132 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2136 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2140 if (exp
->flag_noname
)
2143 bfd_set_section_size (abfd
, id6
, 0);
2147 /* { short, asciz } */
2148 len
= 2 + strlen (exp
->name
) + 1;
2151 bfd_set_section_size (abfd
, id6
, len
);
2154 memset (d6
, 0, len
);
2155 d6
[0] = exp
->hint
& 0xff;
2156 d6
[1] = exp
->hint
>> 8;
2157 strcpy ((char *) d6
+ 2, exp
->name
);
2160 bfd_set_symtab (abfd
, symtab
, symptr
);
2162 if (include_jmp_stub
)
2163 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2164 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2165 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2166 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2167 if (!exp
->flag_noname
)
2168 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2170 bfd_make_readable (abfd
);
2175 make_singleton_name_imp (const char *import
, bfd
*parent
)
2177 /* Name thunks go to idata$4. */
2183 oname
= xmalloc (20);
2184 sprintf (oname
, "nmimp%06d.o", tmp_seq2
);
2187 abfd
= bfd_create (oname
, parent
);
2188 bfd_find_target (pe_details
->object_target
, abfd
);
2189 bfd_make_writable (abfd
);
2191 bfd_set_format (abfd
, bfd_object
);
2192 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2195 symtab
= xmalloc (3 * sizeof (asymbol
*));
2196 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2197 quick_symbol (abfd
, U ("_imp_"), import
, "", id5
, BSF_GLOBAL
, 0);
2199 /* We need space for the real thunk and for the null terminator. */
2200 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
* 2);
2201 d5
= xmalloc (PE_IDATA5_SIZE
* 2);
2203 memset (d5
, 0, PE_IDATA5_SIZE
* 2);
2204 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2207 bfd_set_symtab (abfd
, symtab
, symptr
);
2209 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA4_SIZE
* 2);
2211 bfd_make_readable (abfd
);
2216 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2218 /* Name thunks go to idata$4. */
2224 oname
= xmalloc (20);
2225 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2228 abfd
= bfd_create (oname
, parent
);
2229 bfd_find_target (pe_details
->object_target
, abfd
);
2230 bfd_make_writable (abfd
);
2232 bfd_set_format (abfd
, bfd_object
);
2233 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2236 symtab
= xmalloc (3 * sizeof (asymbol
*));
2237 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2238 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
2239 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2241 /* We need space for the real thunk and for the null terminator. */
2242 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2243 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2245 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2246 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2249 bfd_set_symtab (abfd
, symtab
, symptr
);
2251 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2253 bfd_make_readable (abfd
);
2258 make_import_fixup_mark (arelent
*rel
)
2260 /* We convert reloc to symbol, for later reference. */
2262 static char *fixup_name
= NULL
;
2263 static size_t buffer_len
= 0;
2265 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2267 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2268 struct bfd_link_hash_entry
*bh
;
2272 fixup_name
= xmalloc (384);
2276 if (strlen (sym
->name
) + 25 > buffer_len
)
2277 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2278 bigger than 20 digits long, we've got worse problems than
2279 overflowing this buffer... */
2282 /* New buffer size is length of symbol, plus 25, but
2283 then rounded up to the nearest multiple of 128. */
2284 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2285 fixup_name
= xmalloc (buffer_len
);
2288 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2291 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2292 current_sec
, /* sym->section, */
2293 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2298 /* .section .idata$2
2299 .rva __nm_thnk_SYM (singleton thunk with name of func)
2302 .rva __my_dll_iname (name of dll)
2303 .rva __fuNN_SYM (pointer to reference (address) in text) */
2306 make_import_fixup_entry (const char *name
,
2307 const char *fixup_name
,
2308 const char *dll_symname
,
2316 oname
= xmalloc (20);
2317 sprintf (oname
, "fu%06d.o", tmp_seq
);
2320 abfd
= bfd_create (oname
, parent
);
2321 bfd_find_target (pe_details
->object_target
, abfd
);
2322 bfd_make_writable (abfd
);
2324 bfd_set_format (abfd
, bfd_object
);
2325 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2328 symtab
= xmalloc (6 * sizeof (asymbol
*));
2329 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2331 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2332 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2333 /* For relocator v2 we have to use the .idata$5 element and not
2335 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2336 quick_symbol (abfd
, U ("_imp_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2338 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2340 bfd_set_section_size (abfd
, id2
, 20);
2345 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2346 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2347 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2350 bfd_set_symtab (abfd
, symtab
, symptr
);
2352 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2354 bfd_make_readable (abfd
);
2358 /* .section .rdata_runtime_pseudo_reloc
2360 .rva __fuNN_SYM (pointer to reference (address) in text) */
2363 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2364 const char *fixup_name
,
2365 bfd_vma addend ATTRIBUTE_UNUSED
,
2370 unsigned char *rt_rel_d
;
2373 oname
= xmalloc (20);
2374 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2377 abfd
= bfd_create (oname
, parent
);
2378 bfd_find_target (pe_details
->object_target
, abfd
);
2379 bfd_make_writable (abfd
);
2381 bfd_set_format (abfd
, bfd_object
);
2382 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2385 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2387 symtab
= xmalloc ((runtime_pseudp_reloc_v2_init
? 3 : 6) * sizeof (asymbol
*));
2391 symtab
= xmalloc (2 * sizeof (asymbol
*));
2393 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2394 SEC_HAS_CONTENTS
, 2);
2396 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2398 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2401 if (! runtime_pseudp_reloc_v2_init
)
2404 runtime_pseudp_reloc_v2_init
= 1;
2406 quick_symbol (abfd
, U ("_imp_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2408 bfd_set_section_size (abfd
, rt_rel
, size
);
2409 rt_rel_d
= xmalloc (size
);
2410 rt_rel
->contents
= rt_rel_d
;
2411 memset (rt_rel_d
, 0, size
);
2412 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2413 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2414 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2416 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2417 save_relocs (rt_rel
);
2419 bfd_set_symtab (abfd
, symtab
, symptr
);
2421 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2425 bfd_set_section_size (abfd
, rt_rel
, 8);
2426 rt_rel_d
= xmalloc (8);
2427 rt_rel
->contents
= rt_rel_d
;
2428 memset (rt_rel_d
, 0, 8);
2430 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2431 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2433 save_relocs (rt_rel
);
2435 bfd_set_symtab (abfd
, symtab
, symptr
);
2437 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2439 bfd_make_readable (abfd
);
2444 .rva __pei386_runtime_relocator */
2447 pe_create_runtime_relocator_reference (bfd
*parent
)
2449 asection
*extern_rt_rel
;
2450 unsigned char *extern_rt_rel_d
;
2454 oname
= xmalloc (20);
2455 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2458 abfd
= bfd_create (oname
, parent
);
2459 bfd_find_target (pe_details
->object_target
, abfd
);
2460 bfd_make_writable (abfd
);
2462 bfd_set_format (abfd
, bfd_object
);
2463 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2466 symtab
= xmalloc (2 * sizeof (asymbol
*));
2467 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2469 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2472 bfd_set_section_size (abfd
, extern_rt_rel
, PE_IDATA5_SIZE
);
2473 extern_rt_rel_d
= xmalloc (PE_IDATA5_SIZE
);
2474 extern_rt_rel
->contents
= extern_rt_rel_d
;
2476 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2477 save_relocs (extern_rt_rel
);
2479 bfd_set_symtab (abfd
, symtab
, symptr
);
2481 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2483 bfd_make_readable (abfd
);
2488 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
)
2491 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2492 struct bfd_link_hash_entry
*name_thunk_sym
;
2493 struct bfd_link_hash_entry
*name_imp_sym
;
2494 const char *name
= sym
->name
;
2495 char *fixup_name
= make_import_fixup_mark (rel
);
2497 int need_import_table
= 1;
2499 sprintf (buf
, U ("_imp_%s"), name
);
2500 name_imp_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2502 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2504 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2506 /* For version 2 pseudo relocation we don't need to add an import
2507 if the import symbol is already present. */
2508 if (link_info
.pei386_runtime_pseudo_reloc
== 2
2510 && name_imp_sym
->type
== bfd_link_hash_defined
)
2511 need_import_table
= 0;
2513 if (need_import_table
== 1
2514 && (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
))
2516 bfd
*b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2517 add_bfd_to_link (b
, b
->filename
, &link_info
);
2519 /* If we ever use autoimport, we have to cast text section writable.
2520 But not for version 2. */
2521 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2523 config
.text_read_only
= FALSE
;
2524 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2526 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2528 b
= make_singleton_name_imp (name
, link_info
.output_bfd
);
2529 add_bfd_to_link (b
, b
->filename
, &link_info
);
2533 if ((addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2534 && need_import_table
== 1)
2536 extern char * pe_data_import_dll
;
2537 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2539 b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
,
2540 link_info
.output_bfd
);
2541 add_bfd_to_link (b
, b
->filename
, &link_info
);
2544 if ((link_info
.pei386_runtime_pseudo_reloc
!= 0 && addend
!= 0)
2545 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2547 if (pe_dll_extra_pe_debug
)
2548 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2549 fixup_name
, (int) addend
);
2551 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2552 link_info
.output_bfd
);
2553 add_bfd_to_link (b
, b
->filename
, &link_info
);
2555 if (runtime_pseudo_relocs_created
== 0)
2557 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2558 add_bfd_to_link (b
, b
->filename
, &link_info
);
2560 runtime_pseudo_relocs_created
++;
2562 else if (addend
!= 0)
2564 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2565 s
->owner
, s
, rel
->address
, sym
->name
);
2572 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2581 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2582 dll_symname
= xstrdup (dll_filename
);
2583 for (i
= 0; dll_symname
[i
]; i
++)
2584 if (!ISALNUM (dll_symname
[i
]))
2585 dll_symname
[i
] = '_';
2587 unlink_if_ordinary (impfilename
);
2589 outarch
= bfd_openw (impfilename
, 0);
2593 /* xgettext:c-format */
2594 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2598 /* xgettext:c-format */
2599 info_msg (_("Creating library file: %s\n"), impfilename
);
2601 bfd_set_format (outarch
, bfd_archive
);
2602 outarch
->has_armap
= 1;
2604 /* Work out a reasonable size of things to put onto one line. */
2605 ar_head
= make_head (outarch
);
2607 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2608 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
2610 /* Iterate the exclude list. */
2611 struct exclude_list_struct
*ex
;
2613 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2615 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2617 found
= (strcmp (ex
->string
, ibfd
->filename
) == 0);
2619 /* If it matched, we must open a fresh BFD for it (the original
2620 input BFD is still needed for the DLL's final link) and add
2621 it into the archive member chain. */
2624 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2625 ? ibfd
->my_archive
->filename
: ibfd
->filename
, NULL
);
2628 einfo (_("%Xbfd_openr %s: %E\n"), ibfd
->filename
);
2631 if (ibfd
->my_archive
)
2633 /* Must now iterate through archive until we find the
2634 required member. A minor shame that we'll open the
2635 archive once per member that we require from it, and
2636 leak those archive bfds rather than reuse them. */
2637 bfd
*arbfd
= newbfd
;
2638 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2640 einfo (_("%X%s(%s): can't find member in non-archive file"),
2641 ibfd
->my_archive
->filename
, ibfd
->filename
);
2645 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2647 if (strcmp (newbfd
->filename
, ibfd
->filename
) == 0)
2652 einfo (_("%X%s(%s): can't find member in archive"),
2653 ibfd
->my_archive
->filename
, ibfd
->filename
);
2657 newbfd
->archive_next
= head
;
2662 for (i
= 0; i
< def
->num_exports
; i
++)
2664 /* The import library doesn't know about the internal name. */
2665 char *internal
= def
->exports
[i
].internal_name
;
2668 /* Don't add PRIVATE entries to import lib. */
2669 if (pe_def_file
->exports
[i
].flag_private
)
2671 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2672 n
= make_one (def
->exports
+ i
, outarch
,
2673 ! (def
->exports
+ i
)->flag_data
);
2674 n
->archive_next
= head
;
2676 def
->exports
[i
].internal_name
= internal
;
2679 ar_tail
= make_tail (outarch
);
2681 if (ar_head
== NULL
|| ar_tail
== NULL
)
2684 /* Now stick them all into the archive. */
2685 ar_head
->archive_next
= head
;
2686 ar_tail
->archive_next
= ar_head
;
2689 if (! bfd_set_archive_head (outarch
, head
))
2690 einfo ("%Xbfd_set_archive_head: %E\n");
2692 if (! bfd_close (outarch
))
2693 einfo ("%Xbfd_close %s: %E\n", impfilename
);
2695 while (head
!= NULL
)
2697 bfd
*n
= head
->archive_next
;
2704 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*link_info
)
2706 lang_input_statement_type
*fake_file
;
2708 fake_file
= lang_add_input_file (name
,
2709 lang_input_file_is_fake_enum
,
2711 fake_file
->the_bfd
= abfd
;
2712 ldlang_add_file (fake_file
);
2714 if (!bfd_link_add_symbols (abfd
, link_info
))
2715 einfo ("%Xaddsym %s: %E\n", name
);
2719 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*link_info
)
2721 def_file_module
*module
;
2723 pe_dll_id_target (bfd_get_target (output_bfd
));
2728 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2732 dll_filename
= module
->name
;
2733 dll_symname
= xstrdup (module
->name
);
2734 for (i
= 0; dll_symname
[i
]; i
++)
2735 if (!ISALNUM (dll_symname
[i
]))
2736 dll_symname
[i
] = '_';
2740 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2741 if (pe_def_file
->imports
[i
].module
== module
)
2743 def_file_export exp
;
2744 struct bfd_link_hash_entry
*blhe
;
2745 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2746 /* See if we need this import. */
2747 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2748 char *name
= xmalloc (len
+ 2 + 6);
2749 bfd_boolean include_jmp_stub
= FALSE
;
2752 sprintf (name
, "%s",
2753 pe_def_file
->imports
[i
].internal_name
);
2755 sprintf (name
, "%s%s",U (""),
2756 pe_def_file
->imports
[i
].internal_name
);
2758 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2759 FALSE
, FALSE
, FALSE
);
2761 /* Include the jump stub for <sym> only if the <sym>
2763 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2766 sprintf (name
, "%s%s", "__imp_",
2767 pe_def_file
->imports
[i
].internal_name
);
2769 sprintf (name
, "%s%s%s", "__imp_", U (""),
2770 pe_def_file
->imports
[i
].internal_name
);
2772 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2773 FALSE
, FALSE
, FALSE
);
2776 include_jmp_stub
= TRUE
;
2780 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2786 bfd
*ar_head
= make_head (output_bfd
);
2787 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2790 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2791 exp
.name
= pe_def_file
->imports
[i
].name
;
2792 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2793 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2794 exp
.flag_private
= 0;
2795 exp
.flag_constant
= 0;
2796 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2797 exp
.flag_noname
= exp
.name
? 0 : 1;
2798 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
2799 add_bfd_to_link (one
, one
->filename
, link_info
);
2804 bfd
*ar_tail
= make_tail (output_bfd
);
2805 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2812 /* We were handed a *.DLL file. Parse it and turn it into a set of
2813 IMPORTS directives in the def file. Return TRUE if the file was
2814 handled, FALSE if not. */
2817 pe_get16 (bfd
*abfd
, int where
)
2821 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2822 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2823 return b
[0] + (b
[1] << 8);
2827 pe_get32 (bfd
*abfd
, int where
)
2831 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2832 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2833 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2839 unsigned char *b
= ptr
;
2841 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2845 pe_implied_import_dll (const char *filename
)
2848 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2849 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
2850 bfd_vma exp_funcbase
;
2851 unsigned char *expdata
;
2853 bfd_vma name_rvas
, ordinals
, nexp
, ordbase
;
2854 const char *dll_name
;
2855 /* Initialization with start > end guarantees that is_data
2856 will not be set by mistake, and avoids compiler warning. */
2857 bfd_vma data_start
= 1;
2858 bfd_vma data_end
= 0;
2859 bfd_vma rdata_start
= 1;
2860 bfd_vma rdata_end
= 0;
2861 bfd_vma bss_start
= 1;
2862 bfd_vma bss_end
= 0;
2864 /* No, I can't use bfd here. kernel32.dll puts its export table in
2865 the middle of the .rdata section. */
2866 dll
= bfd_openr (filename
, pe_details
->target_name
);
2869 einfo ("%Xopen %s: %E\n", filename
);
2873 /* PEI dlls seem to be bfd_objects. */
2874 if (!bfd_check_format (dll
, bfd_object
))
2876 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2880 /* Get pe_header, optional header and numbers of export entries. */
2881 pe_header_offset
= pe_get32 (dll
, 0x3c);
2882 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2883 #ifdef pe_use_x86_64
2884 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2886 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2889 if (num_entries
< 1) /* No exports. */
2892 #ifdef pe_use_x86_64
2893 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
2894 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
2896 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2897 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2900 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2901 secptr
= (pe_header_offset
+ 4 + 20 +
2902 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2905 /* Get the rva and size of the export section. */
2906 for (i
= 0; i
< nsections
; i
++)
2909 bfd_vma secptr1
= secptr
+ 40 * i
;
2910 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2911 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
2912 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
2914 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2915 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2917 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2919 expptr
= fptr
+ (export_rva
- vaddr
);
2920 if (export_rva
+ export_size
> vaddr
+ vsize
)
2921 export_size
= vsize
- (export_rva
- vaddr
);
2926 /* Scan sections and store the base and size of the
2927 data and bss segments in data/base_start/end. */
2928 for (i
= 0; i
< nsections
; i
++)
2930 bfd_vma secptr1
= secptr
+ 40 * i
;
2931 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
2932 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2933 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
2937 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
2938 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
2940 if (strcmp(sec_name
,".data") == 0)
2943 data_end
= vaddr
+ vsize
;
2945 if (pe_dll_extra_pe_debug
)
2946 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2947 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2948 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2950 else if (strcmp(sec_name
,".rdata") == 0)
2952 rdata_start
= vaddr
;
2953 rdata_end
= vaddr
+ vsize
;
2955 if (pe_dll_extra_pe_debug
)
2956 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2957 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2958 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2960 else if (strcmp (sec_name
,".bss") == 0)
2963 bss_end
= vaddr
+ vsize
;
2965 if (pe_dll_extra_pe_debug
)
2966 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2967 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2968 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2972 expdata
= xmalloc (export_size
);
2973 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2974 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2975 erva
= (char *) expdata
- export_rva
;
2977 if (pe_def_file
== 0)
2978 pe_def_file
= def_file_empty ();
2980 nexp
= pe_as32 (expdata
+ 24);
2981 name_rvas
= pe_as32 (expdata
+ 32);
2982 ordinals
= pe_as32 (expdata
+ 36);
2983 ordbase
= pe_as32 (expdata
+ 16);
2984 exp_funcbase
= pe_as32 (expdata
+ 28);
2986 /* Use internal dll name instead of filename
2987 to enable symbolic dll linking. */
2988 dll_name
= erva
+ pe_as32 (expdata
+ 12);
2990 /* Check to see if the dll has already been added to
2991 the definition list and if so return without error.
2992 This avoids multiple symbol definitions. */
2993 if (def_get_module (pe_def_file
, dll_name
))
2995 if (pe_dll_extra_pe_debug
)
2996 printf ("%s is already loaded\n", dll_name
);
3000 /* Iterate through the list of symbols. */
3001 for (i
= 0; i
< nexp
; i
++)
3003 /* Pointer to the names vector. */
3004 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3005 def_file_import
*imp
;
3006 /* Pointer to the function address vector. */
3007 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3010 /* Skip unwanted symbols, which are
3011 exported in buggy auto-import releases. */
3012 if (! CONST_STRNEQ (erva
+ name_rva
, "_nm_"))
3014 /* is_data is true if the address is in the data, rdata or bss
3017 (func_rva
>= data_start
&& func_rva
< data_end
)
3018 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3019 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3021 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3023 /* Mark symbol type. */
3024 imp
->data
= is_data
;
3026 if (pe_dll_extra_pe_debug
)
3027 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3028 __FUNCTION__
, dll_name
, erva
+ name_rva
,
3029 (unsigned long) func_rva
, is_data
? "(data)" : "");
3036 /* These are the main functions, called from the emulation. The first
3037 is called after the bfds are read, so we can guess at how much space
3038 we need. The second is called after everything is placed, so we
3039 can put the right values in place. */
3042 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3044 pe_dll_id_target (bfd_get_target (abfd
));
3045 process_def_file (abfd
, info
);
3047 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
3050 generate_edata (abfd
, info
);
3051 build_filler_bfd (1);
3055 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3057 pe_dll_id_target (bfd_get_target (abfd
));
3058 build_filler_bfd (0);
3062 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3064 pe_dll_id_target (bfd_get_target (abfd
));
3065 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3067 generate_reloc (abfd
, info
);
3070 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3072 /* Resize the sections. */
3073 lang_reset_memory_regions ();
3074 lang_size_sections (NULL
, TRUE
);
3076 /* Redo special stuff. */
3077 ldemul_after_allocation ();
3079 /* Do the assignments again. */
3080 lang_do_assignments ();
3083 fill_edata (abfd
, info
);
3085 if (info
->shared
&& !info
->pie
)
3086 pe_data (abfd
)->dll
= 1;
3088 edata_s
->contents
= edata_d
;
3089 reloc_s
->contents
= reloc_d
;
3093 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3095 pe_dll_id_target (bfd_get_target (abfd
));
3096 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3098 generate_reloc (abfd
, info
);
3101 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3103 /* Resize the sections. */
3104 lang_reset_memory_regions ();
3105 lang_size_sections (NULL
, TRUE
);
3107 /* Redo special stuff. */
3108 ldemul_after_allocation ();
3110 /* Do the assignments again. */
3111 lang_do_assignments ();
3113 reloc_s
->contents
= reloc_d
;
3117 pe_bfd_is_dll (bfd
*abfd
)
3119 return (bfd_get_format (abfd
) == bfd_object
3121 && pe_data (abfd
)->dll
);