1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
3 Written by DJ Delorie <dj@cygnus.com>
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
25 #include "libiberty.h"
26 #include "filenames.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 through 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_exclude_all_symbols
= 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;
159 int pe_use_nul_prefixed_import_tables
= 0;
160 int pe_use_coff_long_section_names
= -1;
161 int pe_leading_underscore
= -1;
163 /* Static variables and types. */
165 static bfd_vma image_base
;
166 static bfd
*filler_bfd
;
167 static struct bfd_section
*edata_s
, *reloc_s
;
168 static unsigned char *edata_d
, *reloc_d
;
169 static size_t edata_sz
, reloc_sz
;
170 static int runtime_pseudo_relocs_created
= 0;
171 static int runtime_pseudp_reloc_v2_init
= 0;
178 autofilter_entry_type
;
182 const char *target_name
;
183 const char *object_target
;
184 unsigned int imagebase_reloc
;
187 bfd_boolean underscored
;
188 const autofilter_entry_type
* autofilter_symbollist
;
192 static const autofilter_entry_type autofilter_symbollist_generic
[] =
194 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
195 /* Entry point symbols. */
196 { STRING_COMMA_LEN ("DllMain") },
197 { STRING_COMMA_LEN ("DllMainCRTStartup") },
198 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
199 /* Runtime pseudo-reloc. */
200 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
201 { STRING_COMMA_LEN ("do_pseudo_reloc") },
205 static const autofilter_entry_type autofilter_symbollist_i386
[] =
207 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
208 /* Entry point symbols, and entry hooks. */
209 { STRING_COMMA_LEN ("cygwin_crt0") },
211 { STRING_COMMA_LEN ("DllMain") },
212 { STRING_COMMA_LEN ("DllEntryPoint") },
213 { STRING_COMMA_LEN ("DllMainCRTStartup") },
214 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
215 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
216 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
218 { STRING_COMMA_LEN ("DllMain@12") },
219 { STRING_COMMA_LEN ("DllEntryPoint@0") },
220 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
221 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
222 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
223 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
224 { STRING_COMMA_LEN ("cygwin_attach_dll") },
226 { STRING_COMMA_LEN ("cygwin_premain0") },
227 { STRING_COMMA_LEN ("cygwin_premain1") },
228 { STRING_COMMA_LEN ("cygwin_premain2") },
229 { STRING_COMMA_LEN ("cygwin_premain3") },
230 /* Runtime pseudo-reloc. */
231 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
232 { STRING_COMMA_LEN ("do_pseudo_reloc") },
233 /* Global vars that should not be exported. */
234 { STRING_COMMA_LEN ("impure_ptr") },
235 { STRING_COMMA_LEN ("_impure_ptr") },
236 { STRING_COMMA_LEN ("_fmode") },
237 { STRING_COMMA_LEN ("environ") },
238 { STRING_COMMA_LEN ("__dso_handle") },
242 #define PE_ARCH_i386 1
244 #define PE_ARCH_mips 3
245 #define PE_ARCH_arm 4
246 #define PE_ARCH_arm_epoc 5
247 #define PE_ARCH_arm_wince 6
249 /* Don't make it constant as underscore mode gets possibly overriden
250 by target or -(no-)leading-underscore option. */
251 static pe_details_type pe_detail_list
[] =
270 autofilter_symbollist_i386
275 16 /* R_SH_IMAGEBASE */,
279 autofilter_symbollist_generic
288 autofilter_symbollist_generic
297 autofilter_symbollist_generic
300 "epoc-pei-arm-little",
301 "epoc-pe-arm-little",
306 autofilter_symbollist_generic
309 "pei-arm-wince-little",
310 "pe-arm-wince-little",
311 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
315 autofilter_symbollist_generic
317 { NULL
, NULL
, 0, 0, 0, FALSE
, NULL
}
320 static const pe_details_type
*pe_details
;
322 /* Do not specify library suffix explicitly, to allow for dllized versions. */
323 static const autofilter_entry_type autofilter_liblist
[] =
325 { STRING_COMMA_LEN ("libcegcc") },
326 { STRING_COMMA_LEN ("libcygwin") },
327 { STRING_COMMA_LEN ("libgcc") },
328 { STRING_COMMA_LEN ("libgcc_s") },
329 { STRING_COMMA_LEN ("libstdc++") },
330 { STRING_COMMA_LEN ("libmingw32") },
331 { STRING_COMMA_LEN ("libmingwex") },
332 { STRING_COMMA_LEN ("libg2c") },
333 { STRING_COMMA_LEN ("libsupc++") },
334 { STRING_COMMA_LEN ("libobjc") },
335 { STRING_COMMA_LEN ("libgcj") },
339 /* Regardless of the suffix issue mentioned above, we must ensure that
340 we do not falsely match on a leading substring, such as when libtool
341 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
342 This routine ensures that the leading part of the name matches and that
343 it is followed by only an optional version suffix and a file extension,
344 returning zero if so or -1 if not. */
345 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
347 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
350 libname
+= afptr
->len
;
352 /* Be liberal in interpreting what counts as a version suffix; we
353 accept anything that has a dash to separate it from the name and
354 begins with a digit. */
355 if (libname
[0] == '-')
357 if (!ISDIGIT (*++libname
))
359 /* Ensure the filename has an extension. */
360 while (*++libname
!= '.')
364 else if (libname
[0] != '.')
370 static const autofilter_entry_type autofilter_objlist
[] =
372 { STRING_COMMA_LEN ("crt0.o") },
373 { STRING_COMMA_LEN ("crt1.o") },
374 { STRING_COMMA_LEN ("crt2.o") },
375 { STRING_COMMA_LEN ("dllcrt1.o") },
376 { STRING_COMMA_LEN ("dllcrt2.o") },
377 { STRING_COMMA_LEN ("gcrt0.o") },
378 { STRING_COMMA_LEN ("gcrt1.o") },
379 { STRING_COMMA_LEN ("gcrt2.o") },
380 { STRING_COMMA_LEN ("crtbegin.o") },
381 { STRING_COMMA_LEN ("crtend.o") },
385 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
387 /* _imp_ is treated specially, as it is always underscored. */
388 /* { STRING_COMMA_LEN ("_imp_") }, */
389 /* Don't export some c++ symbols. */
390 { STRING_COMMA_LEN ("__rtti_") },
391 { STRING_COMMA_LEN ("__builtin_") },
392 /* Don't re-export auto-imported symbols. */
393 { STRING_COMMA_LEN ("__nm_") },
394 /* Don't export symbols specifying internal DLL layout. */
395 { STRING_COMMA_LEN ("_head_") },
396 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
397 /* Don't export section labels or artificial symbols
399 { STRING_COMMA_LEN (".") },
403 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
405 { STRING_COMMA_LEN ("_iname") },
406 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
410 #define U(str) (pe_details->underscored ? "_" str : str)
413 pe_dll_id_target (const char *target
)
417 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
418 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
419 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
421 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
423 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
426 pe_detail_list
[i
].underscored
= (u
!= 0 ? TRUE
: FALSE
);
427 pe_details
= pe_detail_list
+ i
;
428 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
431 einfo (_("%P%X: Unsupported PEI architecture: %s\n"), target
);
435 /* Helper functions for qsort. Relocs must be sorted so that we can write
436 them out by pages. */
447 reloc_sort (const void *va
, const void *vb
)
449 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
450 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
452 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
456 pe_export_sort (const void *va
, const void *vb
)
458 const def_file_export
*a
= va
;
459 const def_file_export
*b
= vb
;
467 return strcmp (an
, bn
);
470 /* Read and process the .DEF file. */
472 /* These correspond to the entries in pe_def_file->exports[]. I use
473 exported_symbol_sections[i] to tag whether or not the symbol was
474 defined, since we can't export symbols we don't have. */
476 static bfd_vma
*exported_symbol_offsets
;
477 static struct bfd_section
**exported_symbol_sections
;
478 static int export_table_size
;
479 static int count_exported
;
480 static int count_exported_byname
;
481 static int count_with_ordinals
;
482 static const char *dll_name
;
483 static int min_ordinal
, max_ordinal
;
484 static int *exported_symbols
;
486 typedef struct exclude_list_struct
489 struct exclude_list_struct
*next
;
494 static struct exclude_list_struct
*excludes
= 0;
497 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
500 char *exclude_string
;
502 local_copy
= xstrdup (new_excludes
);
504 exclude_string
= strtok (local_copy
, ",:");
505 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
507 struct exclude_list_struct
*new_exclude
;
509 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
510 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
511 strcpy (new_exclude
->string
, exclude_string
);
512 new_exclude
->type
= type
;
513 new_exclude
->next
= excludes
;
514 excludes
= new_exclude
;
521 is_import (const char* n
)
523 return (CONST_STRNEQ (n
, "__imp_"));
526 /* abfd is a bfd containing n (or NULL)
527 It can be used for contextual checks. */
530 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
533 struct exclude_list_struct
*ex
;
534 const autofilter_entry_type
*afptr
;
535 const char * libname
= NULL
;
537 if (abfd
&& abfd
->my_archive
)
538 libname
= lbasename (abfd
->my_archive
->filename
);
540 key
.name
= key
.its_name
= (char *) n
;
542 /* Return false if n is in the d->exports table. */
543 if (bsearch (&key
, d
->exports
, d
->num_exports
,
544 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
547 if (pe_dll_do_default_excludes
)
552 if (pe_dll_extra_pe_debug
)
553 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
554 n
, abfd
, abfd
->my_archive
);
556 /* First of all, make context checks:
557 Don't export anything from standard libs. */
560 afptr
= autofilter_liblist
;
564 if (libnamencmp (libname
, afptr
) == 0 )
570 /* Next, exclude symbols from certain startup objects. */
572 if (abfd
&& (p
= lbasename (abfd
->filename
)))
574 afptr
= autofilter_objlist
;
577 if (strcmp (p
, afptr
->name
) == 0)
583 /* Don't try to blindly exclude all symbols
584 that begin with '__'; this was tried and
585 it is too restrictive. Instead we have
586 a target specific list to use: */
587 afptr
= pe_details
->autofilter_symbollist
;
591 if (strcmp (n
, afptr
->name
) == 0)
597 /* Next, exclude symbols starting with ... */
598 afptr
= autofilter_symbolprefixlist
;
601 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
607 /* Finally, exclude symbols ending with ... */
609 afptr
= autofilter_symbolsuffixlist
;
612 if ((len
>= afptr
->len
)
613 /* Add 1 to insure match with trailing '\0'. */
614 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
615 afptr
->len
+ 1) == 0)
622 for (ex
= excludes
; ex
; ex
= ex
->next
)
624 if (ex
->type
== EXCLUDELIBS
)
627 && ((filename_cmp (libname
, ex
->string
) == 0)
628 || (strcasecmp ("ALL", ex
->string
) == 0)))
631 else if (ex
->type
== EXCLUDEFORIMPLIB
)
633 if (filename_cmp (abfd
->filename
, ex
->string
) == 0)
636 else if (strcmp (n
, ex
->string
) == 0)
644 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
647 struct bfd_link_hash_entry
*blhe
;
649 struct bfd_section
*s
;
650 def_file_export
*e
= 0;
651 bfd_boolean resort_needed
;
654 pe_def_file
= def_file_empty ();
656 /* First, run around to all the objects looking for the .drectve
657 sections, and push those into the def file too. */
658 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
660 s
= bfd_get_section_by_name (b
, ".drectve");
664 char *buf
= xmalloc (size
);
666 bfd_get_section_contents (b
, s
, buf
, 0, size
);
667 def_file_add_directive (pe_def_file
, buf
, size
);
672 /* Process aligned common symbol information from the
673 .drectve sections now; common symbol allocation is
674 done before final link, so it will be too late to
675 process them in process_embedded_commands() called
676 from _bfd_coff_link_input_bfd(). */
677 if (pe_def_file
->aligncomms
)
679 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
682 struct coff_link_hash_entry
*sym_hash
;
683 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
684 ac
->symbol_name
, FALSE
, FALSE
, FALSE
);
685 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
686 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
688 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
694 /* If we are building an executable and there is nothing
695 to export, we do not build an export table at all. */
696 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
697 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
700 /* Now, maybe export everything else the default way. */
701 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
702 && !pe_dll_exclude_all_symbols
)
704 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
709 if (!bfd_generic_link_read_symbols (b
))
711 einfo (_("%B%F: could not read symbols: %E\n"), b
);
715 symbols
= bfd_get_outsymbols (b
);
716 nsyms
= bfd_get_symcount (b
);
718 for (j
= 0; j
< nsyms
; j
++)
720 /* We should export symbols which are either global or not
721 anything at all. (.bss data is the latter)
722 We should not export undefined symbols. */
723 bfd_boolean would_export
724 = (symbols
[j
]->section
!= bfd_und_section_ptr
725 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
726 || (symbols
[j
]->flags
== 0)));
727 if (link_info
.version_info
&& would_export
)
729 = !bfd_hide_sym_by_version (link_info
.version_info
,
733 const char *sn
= symbols
[j
]->name
;
735 /* We should not re-export imported stuff. */
741 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
742 sprintf (name
, "%s%s", "__imp_", sn
);
744 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
745 FALSE
, FALSE
, FALSE
);
748 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
752 if (pe_details
->underscored
&& *sn
== '_')
755 if (auto_export (b
, pe_def_file
, sn
))
760 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
762 /* Fill data flag properly, from dlltool.c. */
764 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
772 #define NE pe_def_file->num_exports
774 /* Don't create an empty export table. */
778 resort_needed
= FALSE
;
780 /* Canonicalize the export list. */
783 for (i
= 0; i
< NE
; i
++)
785 /* Check for fastcall/stdcall-decoration, but ignore
786 C++ mangled names. */
787 if (pe_def_file
->exports
[i
].name
[0] != '?'
788 && strchr (pe_def_file
->exports
[i
].name
, '@'))
790 /* This will preserve internal_name, which may have been
791 pointing to the same memory as name, or might not
793 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
794 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
795 char *tmp_at
= strrchr (tmp
, '@');
800 einfo (_("%P%X: Cannot export %s: invalid export name\n"),
801 pe_def_file
->exports
[i
].name
);
802 pe_def_file
->exports
[i
].name
= tmp
;
803 resort_needed
= TRUE
;
808 /* Re-sort the exports table as we have possibly changed the order
809 by removing leading @. */
811 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
814 if (pe_dll_stdcall_aliases
)
816 for (i
= 0; i
< NE
; i
++)
818 if (is_import (pe_def_file
->exports
[i
].name
))
821 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
824 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
825 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
827 *(strchr (tmp
, '@')) = 0;
828 if (auto_export (NULL
, pe_def_file
, tmp
))
829 def_file_add_export (pe_def_file
, tmp
,
830 pe_def_file
->exports
[i
].internal_name
,
838 /* Convenience, but watch out for it changing. */
839 e
= pe_def_file
->exports
;
841 for (i
= 0, j
= 0; i
< NE
; i
++)
843 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
845 /* This is a duplicate. */
846 if (e
[j
- 1].ordinal
!= -1
847 && e
[i
].ordinal
!= -1
848 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
850 if (pe_dll_warn_dup_exports
)
851 /* xgettext:c-format */
852 einfo (_("%P%X: Error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
853 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
857 if (pe_dll_warn_dup_exports
)
858 /* xgettext:c-format */
859 einfo (_("%P: Warning, duplicate EXPORT: %s\n"),
863 if (e
[i
].ordinal
!= -1)
864 e
[j
- 1].ordinal
= e
[i
].ordinal
;
865 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
866 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
867 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
868 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
871 if (e
[i
].internal_name
)
872 free (e
[i
].internal_name
);
874 free (e
[i
].its_name
);
883 pe_def_file
->num_exports
= j
; /* == NE */
885 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
886 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
888 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
892 count_exported_byname
= 0;
893 count_with_ordinals
= 0;
895 for (i
= 0; i
< NE
; i
++)
897 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
900 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
901 lang_add_gc_name (int_name
);
903 name
= xmalloc (strlen (int_name
) + 2);
904 if (pe_details
->underscored
&& int_name
[0] != '@')
907 strcpy (name
+ 1, int_name
);
909 /* PR 19803: The alias must be preserved as well. */
910 lang_add_gc_name (xstrdup (name
));
913 strcpy (name
, int_name
);
915 blhe
= bfd_link_hash_lookup (info
->hash
,
920 && (blhe
->type
== bfd_link_hash_defined
921 || (blhe
->type
== bfd_link_hash_common
)))
924 if (!pe_def_file
->exports
[i
].flag_noname
)
925 count_exported_byname
++;
927 /* Only fill in the sections. The actual offsets are computed
928 in fill_exported_offsets() after common symbols are laid
930 if (blhe
->type
== bfd_link_hash_defined
)
931 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
933 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
935 if (pe_def_file
->exports
[i
].ordinal
!= -1)
937 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
938 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
939 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
940 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
941 count_with_ordinals
++;
944 /* Check for forward exports. These are indicated in DEF files by an
945 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
946 but we must take care not to be fooled when the user wants to export
947 a symbol that actually really has a dot in it, so we only check
948 for them here, after real defined symbols have already been matched. */
949 else if (strchr (int_name
, '.'))
952 if (!pe_def_file
->exports
[i
].flag_noname
)
953 count_exported_byname
++;
955 pe_def_file
->exports
[i
].flag_forward
= 1;
957 if (pe_def_file
->exports
[i
].ordinal
!= -1)
959 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
960 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
961 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
962 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
963 count_with_ordinals
++;
966 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
968 /* xgettext:c-format */
969 einfo (_("%P%X: Cannot export %s: symbol not defined\n"),
974 /* xgettext:c-format */
975 einfo (_("%P%X: Cannot export %s: symbol wrong type (%d vs %d)\n"),
977 blhe
->type
, bfd_link_hash_defined
);
981 /* xgettext:c-format */
982 einfo (_("%P%X: Cannot export %s: symbol not found\n"),
989 /* Build the bfd that will contain .edata and .reloc sections. */
992 build_filler_bfd (int include_edata
)
994 lang_input_statement_type
*filler_file
;
995 filler_file
= lang_add_input_file ("dll stuff",
996 lang_input_file_is_fake_enum
,
998 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
999 link_info
.output_bfd
);
1000 if (filler_bfd
== NULL
1001 || !bfd_set_arch_mach (filler_bfd
,
1002 bfd_get_arch (link_info
.output_bfd
),
1003 bfd_get_mach (link_info
.output_bfd
)))
1005 einfo ("%X%P: can not create BFD: %E\n");
1011 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1013 || !bfd_set_section_flags (filler_bfd
, edata_s
,
1020 einfo ("%X%P: can not create .edata section: %E\n");
1023 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
1026 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1028 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
1035 einfo ("%X%P: can not create .reloc section: %E\n");
1039 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
1041 ldlang_add_file (filler_file
);
1044 /* Gather all the exported symbols and build the .edata section. */
1047 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1049 int i
, next_ordinal
;
1050 int name_table_size
= 0;
1053 /* First, we need to know how many exported symbols there are,
1054 and what the range of ordinals is. */
1055 if (pe_def_file
->name
)
1056 dll_name
= pe_def_file
->name
;
1059 dll_name
= abfd
->filename
;
1061 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1062 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1063 dll_name
= dlnp
+ 1;
1066 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1068 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1069 min_ordinal
= max_ordinal
- count_exported
+ 1;
1074 max_ordinal
= count_exported
;
1077 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1078 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1079 for (i
= 0; i
< export_table_size
; i
++)
1080 exported_symbols
[i
] = -1;
1082 /* Now we need to assign ordinals to those that don't have them. */
1083 for (i
= 0; i
< NE
; i
++)
1085 if (exported_symbol_sections
[i
] ||
1086 pe_def_file
->exports
[i
].flag_forward
)
1088 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1090 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1091 int pi
= exported_symbols
[ei
];
1095 /* xgettext:c-format */
1096 einfo (_("%P%X: Error: ordinal used twice: %d (%s vs %s)\n"),
1097 pe_def_file
->exports
[i
].ordinal
,
1098 pe_def_file
->exports
[i
].name
,
1099 pe_def_file
->exports
[pi
].name
);
1101 exported_symbols
[ei
] = i
;
1103 if (pe_def_file
->exports
[i
].its_name
)
1104 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1106 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1109 /* Reserve space for the forward name. */
1110 if (pe_def_file
->exports
[i
].flag_forward
)
1112 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1116 next_ordinal
= min_ordinal
;
1117 for (i
= 0; i
< NE
; i
++)
1118 if ((exported_symbol_sections
[i
] ||
1119 pe_def_file
->exports
[i
].flag_forward
) &&
1120 pe_def_file
->exports
[i
].ordinal
== -1)
1122 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1125 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1126 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1129 /* PR 12969: Check for more than 1^16 ordinals. */
1130 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1131 /* xgettext:c-format */
1132 einfo(_("%P%X: Error: export ordinal too large: %d\n"),
1133 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1135 /* OK, now we can allocate some memory. */
1136 edata_sz
= (40 /* directory */
1137 + 4 * export_table_size
/* addresses */
1138 + 4 * count_exported_byname
/* name ptrs */
1139 + 2 * count_exported_byname
/* ordinals */
1140 + name_table_size
+ strlen (dll_name
) + 1);
1143 /* Fill the exported symbol offsets. The preliminary work has already
1144 been done in process_def_file_and_drectve(). */
1147 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1150 struct bfd_link_hash_entry
*blhe
;
1152 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1156 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1157 if (pe_details
->underscored
1158 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1161 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1164 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1166 blhe
= bfd_link_hash_lookup (info
->hash
,
1168 FALSE
, FALSE
, TRUE
);
1170 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1171 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1178 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1181 unsigned char *edirectory
;
1182 unsigned char *eaddresses
;
1183 unsigned char *enameptrs
;
1184 unsigned char *eordinals
;
1187 edata_d
= xmalloc (edata_sz
);
1189 /* Note use of array pointer math here. */
1190 edirectory
= edata_d
;
1191 eaddresses
= edirectory
+ 40;
1192 enameptrs
= eaddresses
+ 4 * export_table_size
;
1193 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1194 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1196 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1197 + edata_s->output_section->vma - image_base)
1199 memset (edata_d
, 0, edata_sz
);
1201 if (pe_data (abfd
)->insert_timestamp
)
1202 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1204 if (pe_def_file
->version_major
!= -1)
1206 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1207 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1210 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1211 strcpy (enamestr
, dll_name
);
1212 enamestr
+= strlen (enamestr
) + 1;
1213 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1214 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1215 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1216 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1217 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1218 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1220 fill_exported_offsets (abfd
, info
);
1222 /* Ok, now for the filling in part.
1223 Scan alphabetically - ie the ordering in the exports[] table,
1224 rather than by ordinal - the ordering in the exported_symbol[]
1225 table. See dlltool.c and:
1226 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1227 for more information. */
1229 for (s
= 0; s
< NE
; s
++)
1231 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1232 if (pe_def_file
->exports
[s
].ordinal
!= -1 &&
1233 (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1235 int ord
= pe_def_file
->exports
[s
].ordinal
;
1237 if (pe_def_file
->exports
[s
].flag_forward
)
1239 bfd_put_32 (abfd
, ERVA (enamestr
),
1240 eaddresses
+ 4 * (ord
- min_ordinal
));
1242 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1243 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1247 bfd_vma srva
= (exported_symbol_offsets
[s
]
1248 + ssec
->output_section
->vma
1249 + ssec
->output_offset
);
1251 bfd_put_32 (abfd
, srva
- image_base
,
1252 eaddresses
+ 4 * (ord
- min_ordinal
));
1255 if (!pe_def_file
->exports
[s
].flag_noname
)
1257 char *ename
= pe_def_file
->exports
[s
].name
;
1258 if (pe_def_file
->exports
[s
].its_name
)
1259 ename
= pe_def_file
->exports
[s
].its_name
;
1261 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1263 strcpy (enamestr
, ename
);
1264 enamestr
+= strlen (enamestr
) + 1;
1265 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1267 pe_def_file
->exports
[s
].hint
= hint
++;
1274 static struct bfd_section
*current_sec
;
1277 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1279 int (*cb
) (arelent
*, asection
*, char *))
1284 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1288 if (!bfd_generic_link_read_symbols (b
))
1290 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1294 symbols
= bfd_get_outsymbols (b
);
1296 for (s
= b
->sections
; s
; s
= s
->next
)
1299 int relsize
, nrelocs
, i
;
1300 int flags
= bfd_get_section_flags (b
, s
);
1302 /* Skip discarded linkonce sections. */
1303 if (flags
& SEC_LINK_ONCE
1304 && s
->output_section
== bfd_abs_section_ptr
)
1309 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1310 relocs
= xmalloc (relsize
);
1311 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1313 for (i
= 0; i
< nrelocs
; i
++)
1315 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1317 if (!strcmp (name
, sym
->name
))
1318 cb (relocs
[i
], s
, name
);
1323 /* Warning: the allocated symbols are remembered in BFD and reused
1324 later, so don't free them! */
1325 /* free (symbols); */
1330 /* Gather all the relocations and build the .reloc section. */
1333 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1336 /* For .reloc stuff. */
1337 reloc_data_type
*reloc_data
;
1338 int total_relocs
= 0;
1340 bfd_vma sec_page
= (bfd_vma
) -1;
1341 bfd_vma page_ptr
, page_count
;
1344 struct bfd_section
*s
;
1347 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1348 for (s
= b
->sections
; s
; s
= s
->next
)
1349 total_relocs
+= s
->reloc_count
;
1351 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1355 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1358 int relsize
, nrelocs
;
1360 for (s
= b
->sections
; s
; s
= s
->next
)
1362 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1365 /* If it's not loaded, we don't need to relocate it this way. */
1366 if (!(s
->output_section
->flags
& SEC_LOAD
))
1369 /* I don't know why there would be a reloc for these, but I've
1370 seen it happen - DJ */
1371 if (s
->output_section
== bfd_abs_section_ptr
)
1374 if (s
->output_section
->vma
== 0)
1376 /* Huh? Shouldn't happen, but punt if it does. */
1377 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1378 s
->output_section
->name
, s
->output_section
->index
,
1379 s
->output_section
->flags
);
1383 if (!bfd_generic_link_read_symbols (b
))
1385 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1389 symbols
= bfd_get_outsymbols (b
);
1390 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1391 relocs
= xmalloc (relsize
);
1392 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1394 for (i
= 0; i
< nrelocs
; i
++)
1396 if (pe_dll_extra_pe_debug
)
1398 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1399 printf ("rel: %s\n", sym
->name
);
1401 if (!relocs
[i
]->howto
->pc_relative
1402 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1404 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1406 /* Don't create relocs for undefined weak symbols. */
1407 if (sym
->flags
== BSF_WEAK
)
1409 struct bfd_link_hash_entry
*blhe
1410 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1411 FALSE
, FALSE
, FALSE
);
1412 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1414 /* Check aux sym and see if it is defined or not. */
1415 struct coff_link_hash_entry
*h
, *h2
;
1416 h
= (struct coff_link_hash_entry
*)blhe
;
1417 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1419 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1420 [h
->aux
->x_sym
.x_tagndx
.l
];
1421 /* We don't want a base reloc if the aux sym is not
1422 found, undefined, or if it is the constant ABS
1423 zero default value. (We broaden that slightly by
1424 not testing the value, just the section; there's
1425 no reason we'd want a reference to any absolute
1426 address to get relocated during rebasing). */
1427 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1428 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1431 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1434 /* Nor for Dwarf FDE references to discarded sections. */
1435 else if (bfd_is_abs_section (sym
->section
->output_section
))
1437 /* We only ignore relocs from .eh_frame sections, as
1438 they are discarded by the final link rather than
1439 resolved against the kept section. */
1440 if (!strcmp (s
->name
, ".eh_frame"))
1444 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1446 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1448 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1449 relocs
[i
]->howto
->rightshift
)
1451 #ifdef pe_use_x86_64
1452 case BITS_AND_SHIFT (64, 0):
1453 reloc_data
[total_relocs
].type
= 10;
1457 case BITS_AND_SHIFT (32, 0):
1458 reloc_data
[total_relocs
].type
= 3;
1461 case BITS_AND_SHIFT (16, 0):
1462 reloc_data
[total_relocs
].type
= 2;
1465 case BITS_AND_SHIFT (16, 16):
1466 reloc_data
[total_relocs
].type
= 4;
1467 /* FIXME: we can't know the symbol's right value
1468 yet, but we probably can safely assume that
1469 CE will relocate us in 64k blocks, so leaving
1471 reloc_data
[total_relocs
].extra
= 0;
1474 case BITS_AND_SHIFT (26, 2):
1475 reloc_data
[total_relocs
].type
= 5;
1478 case BITS_AND_SHIFT (24, 2):
1479 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1480 Those ARM_xxx definitions should go in proper
1482 if (relocs
[i
]->howto
->type
== 0
1483 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1484 || relocs
[i
]->howto
->type
== 5)
1485 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1486 that has already been fully processed during a
1487 previous link stage, so ignore it here. */
1491 /* xgettext:c-format */
1492 einfo (_("%P%X: Error: %d-bit reloc in dll\n"),
1493 relocs
[i
]->howto
->bitsize
);
1499 /* Warning: the allocated symbols are remembered in BFD and
1500 reused later, so don't free them! */
1504 /* At this point, we have total_relocs relocation addresses in
1505 reloc_addresses, which are all suitable for the .reloc section.
1506 We must now create the new sections. */
1507 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1509 for (i
= 0; i
< total_relocs
; i
++)
1511 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1513 if (this_page
!= sec_page
)
1515 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1517 sec_page
= this_page
;
1522 if (reloc_data
[i
].type
== 4)
1526 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1527 reloc_d
= xmalloc (reloc_sz
);
1528 sec_page
= (bfd_vma
) -1;
1530 page_ptr
= (bfd_vma
) -1;
1533 for (i
= 0; i
< total_relocs
; i
++)
1535 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1536 bfd_vma this_page
= (rva
& ~0xfff);
1538 if (this_page
!= sec_page
)
1540 while (reloc_sz
& 3)
1541 reloc_d
[reloc_sz
++] = 0;
1543 if (page_ptr
!= (bfd_vma
) -1)
1544 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1546 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1547 page_ptr
= reloc_sz
;
1549 sec_page
= this_page
;
1553 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1554 reloc_d
+ reloc_sz
);
1557 if (reloc_data
[i
].type
== 4)
1559 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1566 while (reloc_sz
& 3)
1567 reloc_d
[reloc_sz
++] = 0;
1569 if (page_ptr
!= (bfd_vma
) -1)
1570 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1572 while (reloc_sz
< reloc_s
->size
)
1573 reloc_d
[reloc_sz
++] = 0;
1576 /* Given the exiting def_file structure, print out a .DEF file that
1577 corresponds to it. */
1580 quoteput (char *s
, FILE *f
, int needs_quotes
)
1584 for (cp
= s
; *cp
; cp
++)
1599 if (*s
== '"' || *s
== '\\')
1613 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1616 FILE *out
= fopen (pe_out_def_filename
, "w");
1619 /* xgettext:c-format */
1620 einfo (_("%P: Can't open output def file %s\n"),
1621 pe_out_def_filename
);
1625 if (pe_def_file
->name
)
1627 if (pe_def_file
->is_dll
)
1628 fprintf (out
, "LIBRARY ");
1630 fprintf (out
, "NAME ");
1632 quoteput (pe_def_file
->name
, out
, 1);
1634 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1636 fprintf (out
, " BASE=0x");
1637 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1639 fprintf (out
, "\n");
1642 if (pe_def_file
->description
)
1644 fprintf (out
, "DESCRIPTION ");
1645 quoteput (pe_def_file
->description
, out
, 1);
1646 fprintf (out
, "\n");
1649 if (pe_def_file
->version_minor
!= -1)
1650 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1651 pe_def_file
->version_minor
);
1652 else if (pe_def_file
->version_major
!= -1)
1653 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1655 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1656 fprintf (out
, "\n");
1658 if (pe_def_file
->stack_commit
!= -1)
1659 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1660 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1661 else if (pe_def_file
->stack_reserve
!= -1)
1662 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1664 if (pe_def_file
->heap_commit
!= -1)
1665 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1666 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1667 else if (pe_def_file
->heap_reserve
!= -1)
1668 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1670 if (pe_def_file
->num_section_defs
> 0)
1672 fprintf (out
, "\nSECTIONS\n\n");
1674 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1677 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1679 if (pe_def_file
->section_defs
[i
].class)
1681 fprintf (out
, " CLASS ");
1682 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1685 if (pe_def_file
->section_defs
[i
].flag_read
)
1686 fprintf (out
, " READ");
1688 if (pe_def_file
->section_defs
[i
].flag_write
)
1689 fprintf (out
, " WRITE");
1691 if (pe_def_file
->section_defs
[i
].flag_execute
)
1692 fprintf (out
, " EXECUTE");
1694 if (pe_def_file
->section_defs
[i
].flag_shared
)
1695 fprintf (out
, " SHARED");
1697 fprintf (out
, "\n");
1701 if (pe_def_file
->num_exports
> 0)
1703 fprintf (out
, "EXPORTS\n");
1705 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1707 def_file_export
*e
= pe_def_file
->exports
+ i
;
1709 quoteput (e
->name
, out
, 0);
1711 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1713 fprintf (out
, " = ");
1714 quoteput (e
->internal_name
, out
, 0);
1717 if (e
->ordinal
!= -1)
1718 fprintf (out
, " @%d", e
->ordinal
);
1720 if (e
->flag_private
)
1721 fprintf (out
, " PRIVATE");
1723 if (e
->flag_constant
)
1724 fprintf (out
, " CONSTANT");
1727 fprintf (out
, " NONAME");
1730 fprintf (out
, " DATA");
1732 fprintf (out
, "\n");
1736 if (pe_def_file
->num_imports
> 0)
1738 fprintf (out
, "\nIMPORTS\n\n");
1740 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1742 def_file_import
*im
= pe_def_file
->imports
+ i
;
1745 if (im
->internal_name
1746 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1748 quoteput (im
->internal_name
, out
, 0);
1749 fprintf (out
, " = ");
1752 quoteput (im
->module
->name
, out
, 0);
1756 quoteput (im
->name
, out
, 0);
1758 fprintf (out
, "%d", im
->ordinal
);
1762 fprintf (out
, " == ");
1763 quoteput (im
->its_name
, out
, 0);
1766 fprintf (out
, "\n");
1771 fprintf (out
, _("; no contents available\n"));
1773 if (fclose (out
) == EOF
)
1774 /* xgettext:c-format */
1775 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1778 /* Generate the import library. */
1780 static asymbol
**symtab
;
1783 static int tmp_seq2
;
1784 static const char *dll_filename
;
1785 static char *dll_symname
;
1787 #define UNDSEC bfd_und_section_ptr
1790 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1795 sec
= bfd_make_section_old_way (abfd
, name
);
1796 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1797 bfd_set_section_alignment (abfd
, sec
, align
);
1798 /* Remember to undo this before trying to link internally! */
1799 sec
->output_section
= sec
;
1801 sym
= bfd_make_empty_symbol (abfd
);
1802 symtab
[symptr
++] = sym
;
1803 sym
->name
= sec
->name
;
1805 sym
->flags
= BSF_LOCAL
;
1812 quick_symbol (bfd
*abfd
,
1821 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1826 sym
= bfd_make_empty_symbol (abfd
);
1831 symtab
[symptr
++] = sym
;
1834 static arelent
*reltab
= 0;
1835 static int relcount
= 0, relsize
= 0;
1838 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1840 if (relcount
>= relsize
- 1)
1844 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1846 reltab
= xmalloc (relsize
* sizeof (arelent
));
1848 reltab
[relcount
].address
= address
;
1849 reltab
[relcount
].addend
= 0;
1850 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1851 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1856 save_relocs (asection
*sec
)
1860 sec
->relocation
= reltab
;
1861 sec
->reloc_count
= relcount
;
1862 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1863 for (i
= 0; i
< relcount
; i
++)
1864 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1865 sec
->orelocation
[relcount
] = 0;
1866 sec
->flags
|= SEC_RELOC
;
1868 relcount
= relsize
= 0;
1871 /* .section .idata$2
1872 .global __head_my_dll
1889 make_head (bfd
*parent
)
1891 asection
*id2
, *id5
, *id4
;
1892 unsigned char *d2
, *d5
, *d4
;
1896 oname
= xmalloc (20);
1897 sprintf (oname
, "d%06d.o", tmp_seq
);
1900 abfd
= bfd_create (oname
, parent
);
1901 bfd_find_target (pe_details
->object_target
, abfd
);
1902 bfd_make_writable (abfd
);
1904 bfd_set_format (abfd
, bfd_object
);
1905 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1908 symtab
= xmalloc (6 * sizeof (asymbol
*));
1909 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1910 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1911 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1912 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1913 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1915 /* OK, pay attention here. I got confused myself looking back at
1916 it. We create a four-byte section to mark the beginning of the
1917 list, and we include an offset of 4 in the section, so that the
1918 pointer to the list points to the *end* of this section, which is
1919 the start of the list of sections from other objects. */
1921 bfd_set_section_size (abfd
, id2
, 20);
1925 if (pe_use_nul_prefixed_import_tables
)
1926 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
1927 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1928 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1929 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1932 if (pe_use_nul_prefixed_import_tables
)
1933 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1935 bfd_set_section_size (abfd
, id5
, 0);
1936 d5
= xmalloc (PE_IDATA5_SIZE
);
1938 memset (d5
, 0, PE_IDATA5_SIZE
);
1939 if (pe_use_nul_prefixed_import_tables
)
1940 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1942 bfd_set_section_size (abfd
, id4
, 0);
1943 d4
= xmalloc (PE_IDATA4_SIZE
);
1945 memset (d4
, 0, PE_IDATA4_SIZE
);
1947 bfd_set_symtab (abfd
, symtab
, symptr
);
1949 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1950 if (pe_use_nul_prefixed_import_tables
)
1952 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1953 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1957 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
1958 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
1961 bfd_make_readable (abfd
);
1965 /* .section .idata$4
1972 .global __my_dll_iname
1977 make_tail (bfd
*parent
)
1979 asection
*id4
, *id5
, *id7
;
1980 unsigned char *d4
, *d5
, *d7
;
1985 oname
= xmalloc (20);
1986 sprintf (oname
, "d%06d.o", tmp_seq
);
1989 abfd
= bfd_create (oname
, parent
);
1990 bfd_find_target (pe_details
->object_target
, abfd
);
1991 bfd_make_writable (abfd
);
1993 bfd_set_format (abfd
, bfd_object
);
1994 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1997 symtab
= xmalloc (5 * sizeof (asymbol
*));
1998 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1999 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2000 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2001 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2003 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2004 d4
= xmalloc (PE_IDATA4_SIZE
);
2006 memset (d4
, 0, PE_IDATA4_SIZE
);
2008 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2009 d5
= xmalloc (PE_IDATA5_SIZE
);
2011 memset (d5
, 0, PE_IDATA5_SIZE
);
2013 len
= strlen (dll_filename
) + 1;
2016 bfd_set_section_size (abfd
, id7
, len
);
2019 strcpy ((char *) d7
, dll_filename
);
2020 /* If len was odd, the above
2021 strcpy leaves behind an undefined byte. That is harmless,
2022 but we set it to 0 just so the binary dumps are pretty. */
2025 bfd_set_symtab (abfd
, symtab
, symptr
);
2027 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2028 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2029 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2031 bfd_make_readable (abfd
);
2037 .global ___imp_function
2038 .global __imp__function
2040 jmp *__imp__function:
2054 .asciz "function" xlate? (add underscore, kill at) */
2056 static const unsigned char jmp_ix86_bytes
[] =
2058 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2066 .dw __imp_function */
2068 static const unsigned char jmp_sh_bytes
[] =
2070 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2074 lui $t0,<high:__imp_function>
2075 lw $t0,<low:__imp_function>
2079 static const unsigned char jmp_mips_bytes
[] =
2081 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2082 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2085 static const unsigned char jmp_arm_bytes
[] =
2087 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2088 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2094 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2096 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2097 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2101 const unsigned char *jmp_bytes
= NULL
;
2102 int jmp_byte_count
= 0;
2104 /* Include the jump stub section only if it is needed. A jump
2105 stub is needed if the symbol being imported <sym> is a function
2106 symbol and there is at least one undefined reference to that
2107 symbol. In other words, if all the import references to <sym> are
2108 explicitly through _declspec(dllimport) then the jump stub is not
2110 if (include_jmp_stub
)
2112 switch (pe_details
->pe_arch
)
2115 jmp_bytes
= jmp_ix86_bytes
;
2116 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2119 jmp_bytes
= jmp_sh_bytes
;
2120 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2123 jmp_bytes
= jmp_mips_bytes
;
2124 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2127 case PE_ARCH_arm_epoc
:
2128 case PE_ARCH_arm_wince
:
2129 jmp_bytes
= jmp_arm_bytes
;
2130 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2137 oname
= xmalloc (20);
2138 sprintf (oname
, "d%06d.o", tmp_seq
);
2141 abfd
= bfd_create (oname
, parent
);
2142 bfd_find_target (pe_details
->object_target
, abfd
);
2143 bfd_make_writable (abfd
);
2145 bfd_set_format (abfd
, bfd_object
);
2146 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2149 symtab
= xmalloc (12 * sizeof (asymbol
*));
2151 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2152 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2153 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2154 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2155 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2157 if (*exp
->internal_name
== '@')
2159 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2161 if (include_jmp_stub
)
2162 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2163 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2165 /* Fastcall applies only to functions,
2166 so no need for auto-import symbol. */
2170 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2172 if (include_jmp_stub
)
2173 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2175 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2177 /* Symbol to reference ord/name of imported
2178 data symbol, used to implement auto-import. */
2180 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2183 if (pe_dll_compat_implib
)
2184 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2187 if (include_jmp_stub
)
2189 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
2190 td
= xmalloc (jmp_byte_count
);
2192 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2194 switch (pe_details
->pe_arch
)
2197 #ifdef pe_use_x86_64
2198 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2200 /* Mark this object as SAFESEH compatible. */
2201 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2203 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2207 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2210 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2211 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2212 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2215 case PE_ARCH_arm_epoc
:
2216 case PE_ARCH_arm_wince
:
2217 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2225 bfd_set_section_size (abfd
, tx
, 0);
2227 bfd_set_section_size (abfd
, id7
, 4);
2231 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2234 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2235 d5
= xmalloc (PE_IDATA5_SIZE
);
2237 memset (d5
, 0, PE_IDATA5_SIZE
);
2239 if (exp
->flag_noname
)
2241 d5
[0] = exp
->ordinal
;
2242 d5
[1] = exp
->ordinal
>> 8;
2243 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2247 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2251 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2252 d4
= xmalloc (PE_IDATA4_SIZE
);
2254 memset (d4
, 0, PE_IDATA4_SIZE
);
2256 if (exp
->flag_noname
)
2258 d4
[0] = exp
->ordinal
;
2259 d4
[1] = exp
->ordinal
>> 8;
2260 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2264 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2268 if (exp
->flag_noname
)
2271 bfd_set_section_size (abfd
, id6
, 0);
2277 /* { short, asciz } */
2279 len
= 2 + strlen (exp
->its_name
) + 1;
2281 len
= 2 + strlen (exp
->name
) + 1;
2284 bfd_set_section_size (abfd
, id6
, len
);
2287 memset (d6
, 0, len
);
2289 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2290 contains an invalid value (-1). */
2291 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2296 strcpy ((char*) d6
+ 2, exp
->its_name
);
2298 strcpy ((char *) d6
+ 2, exp
->name
);
2301 bfd_set_symtab (abfd
, symtab
, symptr
);
2303 if (include_jmp_stub
)
2304 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2305 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2306 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2307 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2308 if (!exp
->flag_noname
)
2309 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2311 bfd_make_readable (abfd
);
2316 make_singleton_name_imp (const char *import
, bfd
*parent
)
2318 /* Name thunks go to idata$4. */
2324 oname
= xmalloc (20);
2325 sprintf (oname
, "nmimp%06d.o", tmp_seq2
);
2328 abfd
= bfd_create (oname
, parent
);
2329 bfd_find_target (pe_details
->object_target
, abfd
);
2330 bfd_make_writable (abfd
);
2332 bfd_set_format (abfd
, bfd_object
);
2333 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2336 symtab
= xmalloc (3 * sizeof (asymbol
*));
2337 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2338 quick_symbol (abfd
, "__imp_", import
, "", id5
, BSF_GLOBAL
, 0);
2340 /* We need space for the real thunk and for the null terminator. */
2341 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
* 2);
2342 d5
= xmalloc (PE_IDATA5_SIZE
* 2);
2344 memset (d5
, 0, PE_IDATA5_SIZE
* 2);
2345 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2348 bfd_set_symtab (abfd
, symtab
, symptr
);
2350 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA4_SIZE
* 2);
2352 bfd_make_readable (abfd
);
2357 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2359 /* Name thunks go to idata$4. */
2365 oname
= xmalloc (20);
2366 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2369 abfd
= bfd_create (oname
, parent
);
2370 bfd_find_target (pe_details
->object_target
, abfd
);
2371 bfd_make_writable (abfd
);
2373 bfd_set_format (abfd
, bfd_object
);
2374 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2377 symtab
= xmalloc (3 * sizeof (asymbol
*));
2378 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2379 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2380 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2382 /* We need space for the real thunk and for the null terminator. */
2383 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2384 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2386 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2387 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2390 bfd_set_symtab (abfd
, symtab
, symptr
);
2392 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2394 bfd_make_readable (abfd
);
2399 make_import_fixup_mark (arelent
*rel
, char *name
)
2401 /* We convert reloc to symbol, for later reference. */
2402 static unsigned int counter
;
2403 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2404 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2405 struct bfd_link_hash_entry
*bh
;
2406 char *fixup_name
, buf
[26];
2409 /* "name" buffer has space before the symbol name for prefixes. */
2410 sprintf (buf
, "__fu%d_", counter
++);
2411 prefix_len
= strlen (buf
);
2412 fixup_name
= name
- prefix_len
;
2413 memcpy (fixup_name
, buf
, prefix_len
);
2416 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2417 current_sec
, /* sym->section, */
2418 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2423 /* .section .idata$2
2424 .rva __nm_thnk_SYM (singleton thunk with name of func)
2427 .rva __my_dll_iname (name of dll)
2428 .rva __fuNN_SYM (pointer to reference (address) in text) */
2431 make_import_fixup_entry (const char *name
,
2432 const char *fixup_name
,
2433 const char *symname
,
2441 oname
= xmalloc (20);
2442 sprintf (oname
, "fu%06d.o", tmp_seq
);
2445 abfd
= bfd_create (oname
, parent
);
2446 bfd_find_target (pe_details
->object_target
, abfd
);
2447 bfd_make_writable (abfd
);
2449 bfd_set_format (abfd
, bfd_object
);
2450 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2453 symtab
= xmalloc (6 * sizeof (asymbol
*));
2454 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2456 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2457 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2458 /* For relocator v2 we have to use the .idata$5 element and not
2460 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2461 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2463 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2465 bfd_set_section_size (abfd
, id2
, 20);
2470 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2471 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2472 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2475 bfd_set_symtab (abfd
, symtab
, symptr
);
2477 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2479 bfd_make_readable (abfd
);
2483 /* .section .rdata_runtime_pseudo_reloc
2485 .rva __fuNN_SYM (pointer to reference (address) in text) */
2488 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2489 const char *fixup_name
,
2490 bfd_vma addend ATTRIBUTE_UNUSED
,
2495 unsigned char *rt_rel_d
;
2498 oname
= xmalloc (20);
2499 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2502 abfd
= bfd_create (oname
, parent
);
2503 bfd_find_target (pe_details
->object_target
, abfd
);
2504 bfd_make_writable (abfd
);
2506 bfd_set_format (abfd
, bfd_object
);
2507 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2510 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2512 symtab
= xmalloc ((runtime_pseudp_reloc_v2_init
? 3 : 6) * sizeof (asymbol
*));
2516 symtab
= xmalloc (2 * sizeof (asymbol
*));
2518 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2519 SEC_HAS_CONTENTS
, 2);
2521 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2523 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2526 if (! runtime_pseudp_reloc_v2_init
)
2529 runtime_pseudp_reloc_v2_init
= 1;
2531 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2533 bfd_set_section_size (abfd
, rt_rel
, size
);
2534 rt_rel_d
= xmalloc (size
);
2535 rt_rel
->contents
= rt_rel_d
;
2536 memset (rt_rel_d
, 0, size
);
2537 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2538 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2539 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2541 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2542 save_relocs (rt_rel
);
2544 bfd_set_symtab (abfd
, symtab
, symptr
);
2546 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2550 bfd_set_section_size (abfd
, rt_rel
, 8);
2551 rt_rel_d
= xmalloc (8);
2552 rt_rel
->contents
= rt_rel_d
;
2553 memset (rt_rel_d
, 0, 8);
2555 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2556 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2558 save_relocs (rt_rel
);
2560 bfd_set_symtab (abfd
, symtab
, symptr
);
2562 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2564 bfd_make_readable (abfd
);
2569 .rva __pei386_runtime_relocator */
2572 pe_create_runtime_relocator_reference (bfd
*parent
)
2574 asection
*extern_rt_rel
;
2575 unsigned char *extern_rt_rel_d
;
2579 oname
= xmalloc (20);
2580 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2583 abfd
= bfd_create (oname
, parent
);
2584 bfd_find_target (pe_details
->object_target
, abfd
);
2585 bfd_make_writable (abfd
);
2587 bfd_set_format (abfd
, bfd_object
);
2588 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2591 symtab
= xmalloc (2 * sizeof (asymbol
*));
2592 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2594 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2597 bfd_set_section_size (abfd
, extern_rt_rel
, PE_IDATA5_SIZE
);
2598 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2599 extern_rt_rel
->contents
= extern_rt_rel_d
;
2601 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2602 save_relocs (extern_rt_rel
);
2604 bfd_set_symtab (abfd
, symtab
, symptr
);
2606 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2608 bfd_make_readable (abfd
);
2613 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
)
2615 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2616 struct bfd_link_hash_entry
*name_thunk_sym
;
2617 struct bfd_link_hash_entry
*name_imp_sym
;
2618 char *fixup_name
, *impname
;
2620 int need_import_table
= 1;
2622 /* name buffer is allocated with space at beginning for prefixes. */
2623 impname
= name
- (sizeof "__imp_" - 1);
2624 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
2625 name_imp_sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
2627 impname
= name
- (sizeof "__nm_thnk_" - 1);
2628 memcpy (impname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2629 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
2631 fixup_name
= make_import_fixup_mark (rel
, name
);
2633 /* For version 2 pseudo relocation we don't need to add an import
2634 if the import symbol is already present. */
2635 if (link_info
.pei386_runtime_pseudo_reloc
== 2
2637 && name_imp_sym
->type
== bfd_link_hash_defined
)
2638 need_import_table
= 0;
2640 if (need_import_table
== 1
2641 && (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
))
2643 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2644 add_bfd_to_link (b
, b
->filename
, &link_info
);
2646 /* If we ever use autoimport, we have to cast text section writable.
2647 But not for version 2. */
2648 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2650 config
.text_read_only
= FALSE
;
2651 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2653 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2655 b
= make_singleton_name_imp (name
, link_info
.output_bfd
);
2656 add_bfd_to_link (b
, b
->filename
, &link_info
);
2660 if ((addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2661 && need_import_table
== 1)
2663 extern char * pe_data_import_dll
;
2664 char * symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2666 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2667 link_info
.output_bfd
);
2668 add_bfd_to_link (b
, b
->filename
, &link_info
);
2671 if ((link_info
.pei386_runtime_pseudo_reloc
!= 0 && addend
!= 0)
2672 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2674 if (pe_dll_extra_pe_debug
)
2675 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2676 fixup_name
, (int) addend
);
2678 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2679 link_info
.output_bfd
);
2680 add_bfd_to_link (b
, b
->filename
, &link_info
);
2682 if (runtime_pseudo_relocs_created
== 0)
2684 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2685 add_bfd_to_link (b
, b
->filename
, &link_info
);
2687 runtime_pseudo_relocs_created
++;
2689 else if (addend
!= 0)
2690 einfo (_("%P%X%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2691 s
->owner
, s
, rel
->address
, sym
->name
);
2696 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2705 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2706 dll_symname
= xstrdup (dll_filename
);
2707 for (i
= 0; dll_symname
[i
]; i
++)
2708 if (!ISALNUM (dll_symname
[i
]))
2709 dll_symname
[i
] = '_';
2711 unlink_if_ordinary (impfilename
);
2713 outarch
= bfd_openw (impfilename
, 0);
2717 /* xgettext:c-format */
2718 einfo (_("%P%X: Can't open .lib file: %s\n"), impfilename
);
2723 /* xgettext:c-format */
2724 info_msg (_("Creating library file: %s\n"), impfilename
);
2726 bfd_set_format (outarch
, bfd_archive
);
2727 outarch
->has_armap
= 1;
2729 /* Work out a reasonable size of things to put onto one line. */
2730 ar_head
= make_head (outarch
);
2732 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2733 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2735 /* Iterate the exclude list. */
2736 struct exclude_list_struct
*ex
;
2738 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2740 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2742 found
= (filename_cmp (ex
->string
, ibfd
->filename
) == 0);
2744 /* If it matched, we must open a fresh BFD for it (the original
2745 input BFD is still needed for the DLL's final link) and add
2746 it into the archive member chain. */
2749 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2750 ? ibfd
->my_archive
->filename
: ibfd
->filename
, NULL
);
2753 einfo (_("%P%X: bfd_openr %s: %E\n"), ibfd
->filename
);
2756 if (ibfd
->my_archive
)
2758 /* Must now iterate through archive until we find the
2759 required member. A minor shame that we'll open the
2760 archive once per member that we require from it, and
2761 leak those archive bfds rather than reuse them. */
2762 bfd
*arbfd
= newbfd
;
2763 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2765 einfo (_("%P%X: %s(%s): can't find member in non-archive file"),
2766 ibfd
->my_archive
->filename
, ibfd
->filename
);
2770 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2772 if (filename_cmp (newbfd
->filename
, ibfd
->filename
) == 0)
2777 einfo (_("%P%X: %s(%s): can't find member in archive"),
2778 ibfd
->my_archive
->filename
, ibfd
->filename
);
2782 newbfd
->archive_next
= head
;
2787 for (i
= 0; i
< def
->num_exports
; i
++)
2789 /* The import library doesn't know about the internal name. */
2790 char *internal
= def
->exports
[i
].internal_name
;
2793 /* Don't add PRIVATE entries to import lib. */
2794 if (pe_def_file
->exports
[i
].flag_private
)
2797 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2799 /* PR 19803: If a symbol has been discard due to garbage
2800 collection then do not create any exports for it. */
2802 struct coff_link_hash_entry
*h
;
2804 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2805 FALSE
, FALSE
, FALSE
);
2807 /* If the symbol is hidden and undefined then it
2808 has been swept up by garbage collection. */
2809 && h
->symbol_class
== C_HIDDEN
2810 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2813 /* If necessary, check with an underscore prefix as well. */
2814 if (pe_details
->underscored
&& internal
[0] != '@')
2818 name
= xmalloc (strlen (internal
) + 2);
2819 sprintf (name
, "_%s", internal
);
2821 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2822 FALSE
, FALSE
, FALSE
);
2826 /* If the symbol is hidden and undefined then it
2827 has been swept up by garbage collection. */
2828 && h
->symbol_class
== C_HIDDEN
2829 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2834 n
= make_one (def
->exports
+ i
, outarch
,
2835 ! (def
->exports
+ i
)->flag_data
);
2836 n
->archive_next
= head
;
2838 def
->exports
[i
].internal_name
= internal
;
2841 ar_tail
= make_tail (outarch
);
2843 if (ar_head
== NULL
|| ar_tail
== NULL
)
2846 /* Now stick them all into the archive. */
2847 ar_head
->archive_next
= head
;
2848 ar_tail
->archive_next
= ar_head
;
2851 if (! bfd_set_archive_head (outarch
, head
))
2852 einfo ("%P%X: bfd_set_archive_head: %E\n");
2854 if (! bfd_close (outarch
))
2855 einfo ("%P%X: bfd_close %s: %E\n", impfilename
);
2857 while (head
!= NULL
)
2859 bfd
*n
= head
->archive_next
;
2865 static int undef_count
= 0;
2873 static struct key_value
*udef_table
;
2875 static int undef_sort_cmp (const void *l1
, const void *r1
)
2877 const struct key_value
*l
= l1
;
2878 const struct key_value
*r
= r1
;
2880 return strcmp (l
->key
, r
->key
);
2883 static struct bfd_link_hash_entry
*
2884 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
2886 struct bfd_link_hash_entry
*h
= NULL
;
2887 struct key_value
*kv
;
2888 struct key_value key
;
2889 char *at
, *lname
= xmalloc (strlen (name
) + 3);
2891 strcpy (lname
, name
);
2893 at
= strchr (lname
+ (lname
[0] == '@'), '@');
2898 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
2903 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
2904 if (h
->type
== bfd_link_hash_undefined
)
2908 if (lname
[0] == '?')
2911 if (at
|| lname
[0] == '@')
2913 if (lname
[0] == '@')
2915 if (pe_details
->underscored
)
2918 strcpy (lname
, lname
+ 1);
2920 kv
= bsearch (&key
, udef_table
, undef_count
,
2921 sizeof (struct key_value
), undef_sort_cmp
);
2924 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
2925 if (h
->type
== bfd_link_hash_undefined
)
2930 *strchr (lname
, '@') = 0;
2932 kv
= bsearch (&key
, udef_table
, undef_count
,
2933 sizeof (struct key_value
), undef_sort_cmp
);
2936 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
2937 if (h
->type
== bfd_link_hash_undefined
)
2943 strcat (lname
, "@");
2945 kv
= bsearch (&key
, udef_table
, undef_count
,
2946 sizeof (struct key_value
), undef_sort_cmp
);
2950 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
2951 if (h
->type
== bfd_link_hash_undefined
)
2955 if (lname
[0] == '_' && pe_details
->underscored
)
2959 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
2964 kv
= bsearch (&key
, udef_table
, undef_count
,
2965 sizeof (struct key_value
), undef_sort_cmp
);
2969 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
2970 if (h
->type
== bfd_link_hash_undefined
)
2982 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2983 void *inf ATTRIBUTE_UNUSED
)
2985 if (h
->type
== bfd_link_hash_undefined
)
2991 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
2993 if (h
->type
== bfd_link_hash_undefined
)
2997 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
2998 at
= strchr (udef_table
[undef_count
].key
2999 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3002 udef_table
[undef_count
].oname
= h
->root
.string
;
3009 pe_create_undef_table (void)
3013 /* count undefined symbols */
3015 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3017 /* create and fill the corresponding table */
3018 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3021 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3024 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3028 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3030 lang_input_statement_type
*fake_file
;
3032 fake_file
= lang_add_input_file (name
,
3033 lang_input_file_is_fake_enum
,
3035 fake_file
->the_bfd
= abfd
;
3036 ldlang_add_file (fake_file
);
3038 if (!bfd_link_add_symbols (abfd
, linfo
))
3039 einfo ("%P%X: addsym %s: %E\n", name
);
3043 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3046 def_file_module
*module
;
3047 def_file_import
*imp
;
3049 pe_dll_id_target (bfd_get_target (output_bfd
));
3054 imp
= pe_def_file
->imports
;
3056 pe_create_undef_table ();
3058 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3060 int do_this_dll
= 0;
3062 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3064 if (i
>= pe_def_file
->num_imports
)
3067 dll_filename
= module
->name
;
3068 dll_symname
= xstrdup (module
->name
);
3069 for (j
= 0; dll_symname
[j
]; j
++)
3070 if (!ISALNUM (dll_symname
[j
]))
3071 dll_symname
[j
] = '_';
3073 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3075 def_file_export exp
;
3076 struct bfd_link_hash_entry
*blhe
;
3077 int lead_at
= (*imp
[i
].internal_name
== '@');
3078 /* See if we need this import. */
3079 size_t len
= strlen (imp
[i
].internal_name
);
3080 char *name
= xmalloc (len
+ 2 + 6);
3081 bfd_boolean include_jmp_stub
= FALSE
;
3082 bfd_boolean is_cdecl
= FALSE
;
3083 bfd_boolean is_undef
= FALSE
;
3085 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3089 sprintf (name
, "%s", imp
[i
].internal_name
);
3091 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3093 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3094 FALSE
, FALSE
, FALSE
);
3096 /* Include the jump stub for <sym> only if the <sym>
3098 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3101 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3103 sprintf (name
, "%s%s%s", "__imp_", U (""),
3104 imp
[i
].internal_name
);
3106 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3107 FALSE
, FALSE
, FALSE
);
3109 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3113 include_jmp_stub
= TRUE
;
3114 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3117 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3119 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3120 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3121 include_jmp_stub
= TRUE
;
3123 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3134 bfd
*ar_head
= make_head (output_bfd
);
3135 add_bfd_to_link (ar_head
, ar_head
->filename
, linfo
);
3138 exp
.internal_name
= imp
[i
].internal_name
;
3139 exp
.name
= imp
[i
].name
;
3140 exp
.its_name
= imp
[i
].its_name
;
3141 exp
.ordinal
= imp
[i
].ordinal
;
3142 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3143 exp
.flag_private
= 0;
3144 exp
.flag_constant
= 0;
3145 exp
.flag_data
= imp
[i
].data
;
3146 exp
.flag_noname
= exp
.name
? 0 : 1;
3147 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3148 add_bfd_to_link (one
, one
->filename
, linfo
);
3153 bfd
*ar_tail
= make_tail (output_bfd
);
3154 add_bfd_to_link (ar_tail
, ar_tail
->filename
, linfo
);
3163 free (udef_table
[undef_count
].key
);
3168 /* We were handed a *.DLL file. Parse it and turn it into a set of
3169 IMPORTS directives in the def file. Return TRUE if the file was
3170 handled, FALSE if not. */
3173 pe_get16 (bfd
*abfd
, int where
)
3177 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3178 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3179 return b
[0] + (b
[1] << 8);
3183 pe_get32 (bfd
*abfd
, int where
)
3187 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3188 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3189 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
3195 unsigned char *b
= ptr
;
3197 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
3201 pe_implied_import_dll (const char *filename
)
3204 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3205 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3206 bfd_vma exp_funcbase
;
3207 unsigned char *expdata
;
3209 bfd_vma name_rvas
, nexp
;
3210 const char *dllname
;
3211 /* Initialization with start > end guarantees that is_data
3212 will not be set by mistake, and avoids compiler warning. */
3213 bfd_vma data_start
= 1;
3214 bfd_vma data_end
= 0;
3215 bfd_vma rdata_start
= 1;
3216 bfd_vma rdata_end
= 0;
3217 bfd_vma bss_start
= 1;
3218 bfd_vma bss_end
= 0;
3220 /* No, I can't use bfd here. kernel32.dll puts its export table in
3221 the middle of the .rdata section. */
3222 dll
= bfd_openr (filename
, pe_details
->target_name
);
3225 einfo ("%P%X: open %s: %E\n", filename
);
3229 /* PEI dlls seem to be bfd_objects. */
3230 if (!bfd_check_format (dll
, bfd_object
))
3232 einfo ("%P%X: %s: this doesn't appear to be a DLL\n", filename
);
3236 /* Get pe_header, optional header and numbers of directory entries. */
3237 pe_header_offset
= pe_get32 (dll
, 0x3c);
3238 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3239 #ifdef pe_use_x86_64
3240 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3242 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3245 /* No import or export directory entry. */
3246 if (num_entries
< 1)
3249 #ifdef pe_use_x86_64
3250 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3251 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3253 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3254 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3257 /* No export table - nothing to export. */
3258 if (export_size
== 0)
3261 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3262 secptr
= (pe_header_offset
+ 4 + 20 +
3263 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3266 /* Get the rva and size of the export section. */
3267 for (i
= 0; i
< nsections
; i
++)
3270 bfd_vma secptr1
= secptr
+ 40 * i
;
3271 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3272 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3273 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3275 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3276 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3278 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3280 expptr
= fptr
+ (export_rva
- vaddr
);
3281 if (export_rva
+ export_size
> vaddr
+ vsize
)
3282 export_size
= vsize
- (export_rva
- vaddr
);
3287 /* Scan sections and store the base and size of the
3288 data and bss segments in data/base_start/end. */
3289 for (i
= 0; i
< nsections
; i
++)
3291 bfd_vma secptr1
= secptr
+ 40 * i
;
3292 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3293 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3294 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3298 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3299 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3301 if (strcmp(sec_name
,".data") == 0)
3304 data_end
= vaddr
+ vsize
;
3306 if (pe_dll_extra_pe_debug
)
3307 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3308 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3309 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3311 else if (strcmp(sec_name
,".rdata") == 0)
3313 rdata_start
= vaddr
;
3314 rdata_end
= vaddr
+ vsize
;
3316 if (pe_dll_extra_pe_debug
)
3317 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3318 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3319 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3321 else if (strcmp (sec_name
,".bss") == 0)
3324 bss_end
= vaddr
+ vsize
;
3326 if (pe_dll_extra_pe_debug
)
3327 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3328 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3329 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3333 expdata
= xmalloc (export_size
);
3334 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3335 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3336 erva
= (char *) expdata
- export_rva
;
3338 if (pe_def_file
== 0)
3339 pe_def_file
= def_file_empty ();
3341 nexp
= pe_as32 (expdata
+ 24);
3342 name_rvas
= pe_as32 (expdata
+ 32);
3343 exp_funcbase
= pe_as32 (expdata
+ 28);
3345 /* Use internal dll name instead of filename
3346 to enable symbolic dll linking. */
3347 dllname
= erva
+ pe_as32 (expdata
+ 12);
3349 /* Check to see if the dll has already been added to
3350 the definition list and if so return without error.
3351 This avoids multiple symbol definitions. */
3352 if (def_get_module (pe_def_file
, dllname
))
3354 if (pe_dll_extra_pe_debug
)
3355 printf ("%s is already loaded\n", dllname
);
3359 /* Iterate through the list of symbols. */
3360 for (i
= 0; i
< nexp
; i
++)
3362 /* Pointer to the names vector. */
3363 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3364 def_file_import
*imp
;
3365 /* Pointer to the function address vector. */
3366 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3369 /* Skip unwanted symbols, which are
3370 exported in buggy auto-import releases. */
3371 if (! CONST_STRNEQ (erva
+ name_rva
, "__nm_"))
3374 /* is_data is true if the address is in the data, rdata or bss
3377 (func_rva
>= data_start
&& func_rva
< data_end
)
3378 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3379 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3381 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3382 dllname
, i
, NULL
, NULL
, &is_dup
);
3383 /* Mark symbol type. */
3385 imp
->data
= is_data
;
3387 if (pe_dll_extra_pe_debug
)
3388 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3389 __FUNCTION__
, dllname
, erva
+ name_rva
,
3390 (unsigned long) func_rva
, is_data
? "(data)" : "");
3398 pe_output_file_set_long_section_names (bfd
*abfd
)
3400 if (pe_use_coff_long_section_names
< 0)
3402 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3403 einfo (_("%P%X: Error: can't use long section names on this arch\n"));
3406 /* These are the main functions, called from the emulation. The first
3407 is called after the bfds are read, so we can guess at how much space
3408 we need. The second is called after everything is placed, so we
3409 can put the right values in place. */
3412 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3414 pe_dll_id_target (bfd_get_target (abfd
));
3415 pe_output_file_set_long_section_names (abfd
);
3416 process_def_file_and_drectve (abfd
, info
);
3418 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3421 generate_edata (abfd
, info
);
3422 build_filler_bfd (1);
3423 pe_output_file_set_long_section_names (filler_bfd
);
3427 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3429 pe_dll_id_target (bfd_get_target (abfd
));
3430 pe_output_file_set_long_section_names (abfd
);
3431 build_filler_bfd (0);
3432 pe_output_file_set_long_section_names (filler_bfd
);
3436 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3438 pe_dll_id_target (bfd_get_target (abfd
));
3439 pe_output_file_set_long_section_names (abfd
);
3440 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3442 generate_reloc (abfd
, info
);
3445 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3447 /* Resize the sections. */
3448 lang_reset_memory_regions ();
3449 lang_size_sections (NULL
, TRUE
);
3451 /* Redo special stuff. */
3452 ldemul_after_allocation ();
3454 /* Do the assignments again. */
3455 lang_do_assignments (lang_final_phase_enum
);
3458 fill_edata (abfd
, info
);
3460 if (bfd_link_dll (info
))
3461 pe_data (abfd
)->dll
= 1;
3463 edata_s
->contents
= edata_d
;
3464 reloc_s
->contents
= reloc_d
;
3468 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3470 pe_dll_id_target (bfd_get_target (abfd
));
3471 pe_output_file_set_long_section_names (abfd
);
3472 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3474 generate_reloc (abfd
, info
);
3477 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3479 /* Resize the sections. */
3480 lang_reset_memory_regions ();
3481 lang_size_sections (NULL
, TRUE
);
3483 /* Redo special stuff. */
3484 ldemul_after_allocation ();
3486 /* Do the assignments again. */
3487 lang_do_assignments (lang_final_phase_enum
);
3489 reloc_s
->contents
= reloc_d
;
3493 pe_bfd_is_dll (bfd
*abfd
)
3495 return (bfd_get_format (abfd
) == bfd_object
3497 && pe_data (abfd
)->dll
);