1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2023 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"
41 #include "coff/internal.h"
42 #include "../bfd/libcoff.h"
47 #define PE_IDATA4_SIZE 8
48 #define PE_IDATA5_SIZE 8
51 #define AOUTSZ PEPAOUTSZ
52 #define PEAOUTHDR PEPAOUTHDR
60 #ifndef PE_IDATA4_SIZE
61 #define PE_IDATA4_SIZE 4
64 #ifndef PE_IDATA5_SIZE
65 #define PE_IDATA5_SIZE 4
68 /* This file turns a regular Windows PE image into a DLL. Because of
69 the complexity of this operation, it has been broken down into a
70 number of separate modules which are all called by the main function
71 at the end of this file. This function is not re-entrant and is
72 normally only called once, so static variables are used to reduce
73 the number of parameters and return values required.
75 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
77 /* Auto-import feature by Paul Sokolovsky
81 1. With this feature on, DLL clients can import variables from DLL
82 without any concern from their side (for example, without any source
85 2. This is done completely in bounds of the PE specification (to be fair,
86 there's a place where it pokes nose out of, but in practice it works).
87 So, resulting module can be used with any other PE compiler/linker.
89 3. Auto-import is fully compatible with standard import method and they
90 can be mixed together.
92 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
93 reference to it; load time: negligible; virtual/physical memory: should be
94 less than effect of DLL relocation, and I sincerely hope it doesn't affect
95 DLL sharability (too much).
99 The obvious and only way to get rid of dllimport insanity is to make client
100 access variable directly in the DLL, bypassing extra dereference. I.e.,
101 whenever client contains something like
105 address of dll_var in the command should be relocated to point into loaded
106 DLL. The aim is to make OS loader do so, and than make ld help with that.
107 Import section of PE made following way: there's a vector of structures
108 each describing imports from particular DLL. Each such structure points
109 to two other parallel vectors: one holding imported names, and one which
110 will hold address of corresponding imported name. So, the solution is
111 de-vectorize these structures, making import locations be sparse and
112 pointing directly into code. Before continuing, it is worth a note that,
113 while authors strives to make PE act ELF-like, there're some other people
114 make ELF act PE-like: elfvector, ;-) .
118 For each reference of data symbol to be imported from DLL (to set of which
119 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
120 import fixup entry is generated. That entry is of type
121 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
122 fixup entry contains pointer to symbol's address within .text section
123 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
124 (so, DLL name is referenced by multiple entries), and pointer to symbol
125 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
126 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
127 containing imported name. Here comes that "on the edge" problem mentioned
128 above: PE specification rambles that name vector (OriginalFirstThunk)
129 should run in parallel with addresses vector (FirstThunk), i.e. that they
130 should have same number of elements and terminated with zero. We violate
131 this, since FirstThunk points directly into machine code. But in practice,
132 OS loader implemented the sane way: it goes through OriginalFirstThunk and
133 puts addresses to FirstThunk, not something else. It once again should be
134 noted that dll and symbol name structures are reused across fixup entries
135 and should be there anyway to support standard import stuff, so sustained
136 overhead is 20 bytes per reference. Other question is whether having several
137 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
138 done even by native compiler/linker (libth32's functions are in fact reside
139 in windows9x kernel32.dll, so if you use it, you have two
140 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
141 referencing the same PE structures several times is valid. The answer is why
142 not, prohibiting that (detecting violation) would require more work on
143 behalf of loader than not doing it.
145 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
147 static void add_bfd_to_link (bfd
*, const char *, struct bfd_link_info
*);
149 /* For emultempl/pe.em. */
151 def_file
* pe_def_file
= 0;
152 int pe_dll_export_everything
= 0;
153 int pe_dll_exclude_all_symbols
= 0;
154 int pe_dll_do_default_excludes
= 1;
155 int pe_dll_kill_ats
= 0;
156 int pe_dll_stdcall_aliases
= 0;
157 int pe_dll_warn_dup_exports
= 0;
158 int pe_dll_compat_implib
= 0;
159 int pe_dll_extra_pe_debug
= 0;
160 int pe_use_nul_prefixed_import_tables
= 0;
161 int pe_use_coff_long_section_names
= -1;
162 int pe_leading_underscore
= -1;
163 int pe_dll_enable_reloc_section
= 1;
165 /* Static variables and types. */
167 static bfd_vma image_base
;
168 static bfd
*filler_bfd
;
169 static struct bfd_section
*edata_s
, *reloc_s
;
170 static unsigned char *edata_d
, *reloc_d
;
171 static size_t edata_sz
, reloc_sz
;
172 static int runtime_pseudo_relocs_created
= 0;
173 static bool runtime_pseudp_reloc_v2_init
= false;
180 autofilter_entry_type
;
184 const char *target_name
;
185 const char *object_target
;
186 unsigned int imagebase_reloc
;
190 const autofilter_entry_type
* autofilter_symbollist
;
194 static const autofilter_entry_type autofilter_symbollist_generic
[] =
196 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
197 /* Entry point symbols. */
198 { STRING_COMMA_LEN ("DllMain") },
199 { STRING_COMMA_LEN ("DllMainCRTStartup") },
200 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
201 /* Runtime pseudo-reloc. */
202 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
203 { STRING_COMMA_LEN ("do_pseudo_reloc") },
207 static const autofilter_entry_type autofilter_symbollist_i386
[] =
209 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
210 /* Entry point symbols, and entry hooks. */
211 { STRING_COMMA_LEN ("cygwin_crt0") },
213 { STRING_COMMA_LEN ("DllMain") },
214 { STRING_COMMA_LEN ("DllEntryPoint") },
215 { STRING_COMMA_LEN ("DllMainCRTStartup") },
216 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
217 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
218 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
220 { STRING_COMMA_LEN ("DllMain@12") },
221 { STRING_COMMA_LEN ("DllEntryPoint@0") },
222 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
223 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
224 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
225 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
226 { STRING_COMMA_LEN ("cygwin_attach_dll") },
228 { STRING_COMMA_LEN ("cygwin_premain0") },
229 { STRING_COMMA_LEN ("cygwin_premain1") },
230 { STRING_COMMA_LEN ("cygwin_premain2") },
231 { STRING_COMMA_LEN ("cygwin_premain3") },
232 /* Runtime pseudo-reloc. */
233 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
234 { STRING_COMMA_LEN ("do_pseudo_reloc") },
235 /* Global vars that should not be exported. */
236 { STRING_COMMA_LEN ("impure_ptr") },
237 { STRING_COMMA_LEN ("_impure_ptr") },
238 { STRING_COMMA_LEN ("_fmode") },
239 { STRING_COMMA_LEN ("environ") },
240 { STRING_COMMA_LEN ("__dso_handle") },
244 #define PE_ARCH_i386 1
246 #define PE_ARCH_mips 3
247 #define PE_ARCH_arm 4
248 #define PE_ARCH_arm_wince 5
249 #define PE_ARCH_aarch64 6
251 /* Don't make it constant as underscore mode gets possibly overriden
252 by target or -(no-)leading-underscore option. */
253 static pe_details_type pe_detail_list
[] =
272 autofilter_symbollist_i386
282 autofilter_symbollist_i386
292 autofilter_symbollist_i386
298 16 /* R_SH_IMAGEBASE */,
302 autofilter_symbollist_generic
311 autofilter_symbollist_generic
320 autofilter_symbollist_generic
323 "pei-arm-wince-little",
324 "pe-arm-wince-little",
325 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
329 autofilter_symbollist_generic
332 "pei-aarch64-little",
338 autofilter_symbollist_generic
340 { NULL
, NULL
, 0, 0, 0, false, NULL
}
343 static const pe_details_type
*pe_details
;
345 /* Do not specify library suffix explicitly, to allow for dllized versions. */
346 static const autofilter_entry_type autofilter_liblist
[] =
348 { STRING_COMMA_LEN ("libcegcc") },
349 { STRING_COMMA_LEN ("libcygwin") },
350 { STRING_COMMA_LEN ("libgcc") },
351 { STRING_COMMA_LEN ("libgcc_s") },
352 { STRING_COMMA_LEN ("libstdc++") },
353 { STRING_COMMA_LEN ("libmingw32") },
354 { STRING_COMMA_LEN ("libmingwex") },
355 { STRING_COMMA_LEN ("libg2c") },
356 { STRING_COMMA_LEN ("libsupc++") },
357 { STRING_COMMA_LEN ("libobjc") },
358 { STRING_COMMA_LEN ("libgcj") },
359 { STRING_COMMA_LEN ("libmsvcrt") },
360 { STRING_COMMA_LEN ("libmsvcrt-os") },
361 { STRING_COMMA_LEN ("libucrt") },
362 { STRING_COMMA_LEN ("libucrtbase") },
366 /* Regardless of the suffix issue mentioned above, we must ensure that
367 we do not falsely match on a leading substring, such as when libtool
368 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
369 This routine ensures that the leading part of the name matches and that
370 it is followed by only an optional version suffix and a file extension,
371 returning zero if so or -1 if not. */
372 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
374 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
377 libname
+= afptr
->len
;
379 /* Be liberal in interpreting what counts as a version suffix; we
380 accept anything that has a dash to separate it from the name and
381 begins with a digit. */
382 if (libname
[0] == '-')
384 if (!ISDIGIT (*++libname
))
386 /* Ensure the filename has an extension. */
387 while (*++libname
!= '.')
391 else if (libname
[0] != '.')
397 static const autofilter_entry_type autofilter_objlist
[] =
399 { STRING_COMMA_LEN ("crt0.o") },
400 { STRING_COMMA_LEN ("crt1.o") },
401 { STRING_COMMA_LEN ("crt2.o") },
402 { STRING_COMMA_LEN ("dllcrt1.o") },
403 { STRING_COMMA_LEN ("dllcrt2.o") },
404 { STRING_COMMA_LEN ("gcrt0.o") },
405 { STRING_COMMA_LEN ("gcrt1.o") },
406 { STRING_COMMA_LEN ("gcrt2.o") },
407 { STRING_COMMA_LEN ("crtbegin.o") },
408 { STRING_COMMA_LEN ("crtend.o") },
412 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
414 /* _imp_ is treated specially, as it is always underscored. */
415 /* { STRING_COMMA_LEN ("_imp_") }, */
416 /* Don't export some c++ symbols. */
417 { STRING_COMMA_LEN ("__rtti_") },
418 { STRING_COMMA_LEN ("__builtin_") },
419 /* Don't re-export auto-imported symbols. */
420 { STRING_COMMA_LEN ("__nm_") },
421 /* Don't export symbols specifying internal DLL layout. */
422 { STRING_COMMA_LEN ("_head_") },
423 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
424 /* Don't export section labels or artificial symbols
426 { STRING_COMMA_LEN (".") },
430 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
432 { STRING_COMMA_LEN ("_iname") },
433 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
437 #define U(str) (pe_details->underscored ? "_" str : str)
440 pe_dll_id_target (const char *target
)
444 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
445 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
446 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
448 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
450 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
453 pe_detail_list
[i
].underscored
= u
!= 0;
454 pe_details
= pe_detail_list
+ i
;
455 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
458 einfo (_("%X%P: unsupported PEI architecture: %s\n"), target
);
462 /* Helper functions for qsort. Relocs must be sorted so that we can write
463 them out by pages. */
475 reloc_sort (const void *va
, const void *vb
)
477 const reloc_data_type
*a
= (const reloc_data_type
*) va
;
478 const reloc_data_type
*b
= (const reloc_data_type
*) vb
;
492 pe_export_sort (const void *va
, const void *vb
)
494 const def_file_export
*a
= va
;
495 const def_file_export
*b
= vb
;
503 return strcmp (an
, bn
);
506 /* Read and process the .DEF file. */
508 /* These correspond to the entries in pe_def_file->exports[]. I use
509 exported_symbol_sections[i] to tag whether or not the symbol was
510 defined, since we can't export symbols we don't have. */
512 static bfd_vma
*exported_symbol_offsets
;
513 static struct bfd_section
**exported_symbol_sections
;
514 static int export_table_size
;
515 static int count_exported
;
516 static int count_exported_byname
;
517 static int count_with_ordinals
;
518 static const char *dll_filename
;
519 static int min_ordinal
, max_ordinal
;
520 static int *exported_symbols
;
522 typedef struct exclude_list_struct
525 struct exclude_list_struct
*next
;
530 static struct exclude_list_struct
*excludes
= 0;
533 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
536 char *exclude_string
;
538 local_copy
= xstrdup (new_excludes
);
540 exclude_string
= strtok (local_copy
, ",:");
541 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
543 struct exclude_list_struct
*new_exclude
;
545 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
546 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
547 strcpy (new_exclude
->string
, exclude_string
);
548 new_exclude
->type
= type
;
549 new_exclude
->next
= excludes
;
550 excludes
= new_exclude
;
557 is_import (const char* n
)
559 return (startswith (n
, "__imp_"));
562 /* abfd is a bfd containing n (or NULL)
563 It can be used for contextual checks. */
566 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
569 struct exclude_list_struct
*ex
;
570 const autofilter_entry_type
*afptr
;
571 const char * libname
= NULL
;
573 if (abfd
&& abfd
->my_archive
)
574 libname
= lbasename (bfd_get_filename (abfd
->my_archive
));
576 key
.name
= key
.its_name
= (char *) n
;
578 /* Return false if n is in the d->exports table. */
579 if (d
->num_exports
!= 0
580 && bsearch (&key
, d
->exports
, d
->num_exports
,
581 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
584 if (pe_dll_do_default_excludes
)
589 if (pe_dll_extra_pe_debug
)
590 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
591 n
, abfd
, abfd
->my_archive
);
593 /* First of all, make context checks:
594 Don't export anything from standard libs. */
597 afptr
= autofilter_liblist
;
601 if (libnamencmp (libname
, afptr
) == 0 )
607 /* Next, exclude symbols from certain startup objects. */
609 if (abfd
&& (p
= lbasename (bfd_get_filename (abfd
))))
611 afptr
= autofilter_objlist
;
614 if (strcmp (p
, afptr
->name
) == 0)
620 /* Don't try to blindly exclude all symbols
621 that begin with '__'; this was tried and
622 it is too restrictive. Instead we have
623 a target specific list to use: */
624 afptr
= pe_details
->autofilter_symbollist
;
628 if (strcmp (n
, afptr
->name
) == 0)
634 /* Next, exclude symbols starting with ... */
635 afptr
= autofilter_symbolprefixlist
;
638 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
644 /* Finally, exclude symbols ending with ... */
646 afptr
= autofilter_symbolsuffixlist
;
649 if ((len
>= afptr
->len
)
650 /* Add 1 to insure match with trailing '\0'. */
651 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
652 afptr
->len
+ 1) == 0)
659 for (ex
= excludes
; ex
; ex
= ex
->next
)
661 if (ex
->type
== EXCLUDELIBS
)
664 && ((filename_cmp (libname
, ex
->string
) == 0)
665 || (strcasecmp ("ALL", ex
->string
) == 0)))
668 else if (ex
->type
== EXCLUDEFORIMPLIB
)
670 if (filename_cmp (bfd_get_filename (abfd
), ex
->string
) == 0)
673 else if (strcmp (n
, ex
->string
) == 0)
681 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
685 struct bfd_link_hash_entry
*blhe
;
687 struct bfd_section
*s
;
688 def_file_export
*e
= 0;
692 pe_def_file
= def_file_empty ();
694 /* First, run around to all the objects looking for the .drectve
695 sections, and push those into the def file too. */
696 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
698 s
= bfd_get_section_by_name (b
, ".drectve");
702 char *buf
= xmalloc (size
);
704 bfd_get_section_contents (b
, s
, buf
, 0, size
);
705 def_file_add_directive (pe_def_file
, buf
, size
);
710 /* Process aligned common symbol information from the
711 .drectve sections now; common symbol allocation is
712 done before final link, so it will be too late to
713 process them in process_embedded_commands() called
714 from _bfd_coff_link_input_bfd(). */
715 if (pe_def_file
->aligncomms
)
717 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
720 struct coff_link_hash_entry
*sym_hash
;
721 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
722 ac
->symbol_name
, false, false, false);
723 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
724 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
726 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
732 if (pe_def_file
->exclude_symbols
)
734 for (ui
= 0; ui
< pe_def_file
->num_exclude_symbols
; ui
++)
736 pe_dll_add_excludes (pe_def_file
->exclude_symbols
[ui
].symbol_name
,
741 /* If we are building an executable and there is nothing
742 to export, we do not build an export table at all. */
743 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
744 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
747 /* Now, maybe export everything else the default way. */
748 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
749 && !pe_dll_exclude_all_symbols
)
751 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
756 if (!bfd_generic_link_read_symbols (b
))
758 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
762 symbols
= bfd_get_outsymbols (b
);
763 nsyms
= bfd_get_symcount (b
);
765 for (j
= 0; j
< nsyms
; j
++)
767 /* We should export symbols which are either global or not
768 anything at all. (.bss data is the latter)
769 We should not export undefined symbols. */
771 = (symbols
[j
]->section
!= bfd_und_section_ptr
772 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
773 || (symbols
[j
]->flags
== 0)));
774 if (link_info
.version_info
&& would_export
)
776 = !bfd_hide_sym_by_version (link_info
.version_info
,
780 const char *sn
= symbols
[j
]->name
;
782 /* We should not re-export imported stuff. */
788 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
789 sprintf (name
, "%s%s", "__imp_", sn
);
791 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
792 false, false, false);
795 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
799 if (pe_details
->underscored
&& *sn
== '_')
802 if (auto_export (b
, pe_def_file
, sn
))
807 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
809 /* Fill data flag properly, from dlltool.c. */
811 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
819 #define NE pe_def_file->num_exports
821 /* Don't create an empty export table. */
825 resort_needed
= false;
827 /* Canonicalize the export list. */
830 for (i
= 0; i
< NE
; i
++)
832 /* Check for fastcall/stdcall-decoration, but ignore
833 C++ mangled names. */
834 if (pe_def_file
->exports
[i
].name
[0] != '?'
835 && strchr (pe_def_file
->exports
[i
].name
, '@'))
837 /* This will preserve internal_name, which may have been
838 pointing to the same memory as name, or might not
840 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
841 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
842 char *tmp_at
= strrchr (tmp
, '@');
847 einfo (_("%X%P: cannot export %s: invalid export name\n"),
848 pe_def_file
->exports
[i
].name
);
849 pe_def_file
->exports
[i
].name
= tmp
;
850 resort_needed
= true;
855 /* Re-sort the exports table as we have possibly changed the order
856 by removing leading @. */
858 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
861 if (pe_dll_stdcall_aliases
)
863 for (i
= 0; i
< NE
; i
++)
865 if (is_import (pe_def_file
->exports
[i
].name
))
868 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
871 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
872 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
874 *(strchr (tmp
, '@')) = 0;
875 if (auto_export (NULL
, pe_def_file
, tmp
))
876 def_file_add_export (pe_def_file
, tmp
,
877 pe_def_file
->exports
[i
].internal_name
,
885 /* Convenience, but watch out for it changing. */
886 e
= pe_def_file
->exports
;
888 for (i
= 0, j
= 0; i
< NE
; i
++)
890 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
892 /* This is a duplicate. */
893 if (e
[j
- 1].ordinal
!= -1
894 && e
[i
].ordinal
!= -1
895 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
897 if (pe_dll_warn_dup_exports
)
898 /* xgettext:c-format */
899 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
900 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
904 if (pe_dll_warn_dup_exports
)
905 /* xgettext:c-format */
906 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
910 if (e
[i
].ordinal
!= -1)
911 e
[j
- 1].ordinal
= e
[i
].ordinal
;
912 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
913 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
914 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
915 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
917 free (e
[i
].internal_name
);
918 free (e
[i
].its_name
);
927 pe_def_file
->num_exports
= j
; /* == NE */
929 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
930 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
932 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
936 count_exported_byname
= 0;
937 count_with_ordinals
= 0;
939 for (i
= 0; i
< NE
; i
++)
941 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
944 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
945 lang_add_gc_name (int_name
);
947 name
= xmalloc (strlen (int_name
) + 2);
948 if (pe_details
->underscored
&& int_name
[0] != '@')
951 strcpy (name
+ 1, int_name
);
953 /* PR 19803: The alias must be preserved as well. */
954 lang_add_gc_name (xstrdup (name
));
957 strcpy (name
, int_name
);
959 blhe
= bfd_link_hash_lookup (info
->hash
,
964 && (blhe
->type
== bfd_link_hash_defined
965 || (blhe
->type
== bfd_link_hash_common
)))
968 if (!pe_def_file
->exports
[i
].flag_noname
)
969 count_exported_byname
++;
971 /* Only fill in the sections. The actual offsets are computed
972 in fill_exported_offsets() after common symbols are laid
974 if (blhe
->type
== bfd_link_hash_defined
)
975 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
977 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
979 if (pe_def_file
->exports
[i
].ordinal
!= -1)
981 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
982 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
983 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
984 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
985 count_with_ordinals
++;
988 /* Check for forward exports. These are indicated in DEF files by an
989 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
990 but we must take care not to be fooled when the user wants to export
991 a symbol that actually really has a dot in it, so we only check
992 for them here, after real defined symbols have already been matched. */
993 else if (strchr (int_name
, '.'))
996 if (!pe_def_file
->exports
[i
].flag_noname
)
997 count_exported_byname
++;
999 pe_def_file
->exports
[i
].flag_forward
= 1;
1001 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1003 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
1004 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
1005 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
1006 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
1007 count_with_ordinals
++;
1010 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
1012 /* xgettext:c-format */
1013 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
1018 /* xgettext:c-format */
1019 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
1021 blhe
->type
, bfd_link_hash_defined
);
1025 /* xgettext:c-format */
1026 einfo (_("%X%P: cannot export %s: symbol not found\n"),
1033 /* Build the bfd that will contain .edata and .reloc sections. */
1036 build_filler_bfd (int include_edata
)
1038 lang_input_statement_type
*filler_file
;
1039 filler_file
= lang_add_input_file ("dll stuff",
1040 lang_input_file_is_fake_enum
,
1042 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1043 link_info
.output_bfd
);
1044 if (filler_bfd
== NULL
1045 || !bfd_set_arch_mach (filler_bfd
,
1046 bfd_get_arch (link_info
.output_bfd
),
1047 bfd_get_mach (link_info
.output_bfd
)))
1049 einfo (_("%F%P: can not create BFD: %E\n"));
1055 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1057 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1063 einfo (_("%X%P: can not create .edata section: %E\n"));
1066 bfd_set_section_size (edata_s
, edata_sz
);
1069 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1071 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1077 einfo (_("%X%P: can not create .reloc section: %E\n"));
1081 bfd_set_section_size (reloc_s
, 0);
1083 ldlang_add_file (filler_file
);
1086 /* Gather all the exported symbols and build the .edata section. */
1089 generate_edata (void)
1091 int i
, next_ordinal
;
1092 int name_table_size
= 0;
1094 /* First, we need to know how many exported symbols there are,
1095 and what the range of ordinals is. */
1096 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1098 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1099 min_ordinal
= max_ordinal
- count_exported
+ 1;
1104 max_ordinal
= count_exported
;
1107 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1108 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1109 for (i
= 0; i
< export_table_size
; i
++)
1110 exported_symbols
[i
] = -1;
1112 /* Now we need to assign ordinals to those that don't have them. */
1113 for (i
= 0; i
< NE
; i
++)
1115 if (exported_symbol_sections
[i
]
1116 || pe_def_file
->exports
[i
].flag_forward
)
1118 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1120 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1121 int pi
= exported_symbols
[ei
];
1125 /* xgettext:c-format */
1126 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1127 pe_def_file
->exports
[i
].ordinal
,
1128 pe_def_file
->exports
[i
].name
,
1129 pe_def_file
->exports
[pi
].name
);
1131 exported_symbols
[ei
] = i
;
1133 if (pe_def_file
->exports
[i
].its_name
)
1134 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1136 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1139 /* Reserve space for the forward name. */
1140 if (pe_def_file
->exports
[i
].flag_forward
)
1142 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1146 next_ordinal
= min_ordinal
;
1147 for (i
= 0; i
< NE
; i
++)
1148 if ((exported_symbol_sections
[i
]
1149 || pe_def_file
->exports
[i
].flag_forward
)
1150 && pe_def_file
->exports
[i
].ordinal
== -1)
1152 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1155 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1156 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1159 /* PR 12969: Check for more than 1^16 ordinals. */
1160 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1161 /* xgettext:c-format */
1162 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1163 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1165 /* OK, now we can allocate some memory. */
1166 edata_sz
= (40 /* directory */
1167 + 4 * export_table_size
/* addresses */
1168 + 4 * count_exported_byname
/* name ptrs */
1169 + 2 * count_exported_byname
/* ordinals */
1170 + name_table_size
+ strlen (dll_filename
) + 1);
1173 /* Fill the exported symbol offsets. The preliminary work has already
1174 been done in process_def_file_and_drectve(). */
1177 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1180 struct bfd_link_hash_entry
*blhe
;
1182 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1186 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1187 if (pe_details
->underscored
1188 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1191 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1194 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1196 blhe
= bfd_link_hash_lookup (info
->hash
,
1198 false, false, true);
1200 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1201 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1208 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1211 unsigned char *edirectory
;
1212 unsigned char *eaddresses
;
1213 unsigned char *enameptrs
;
1214 unsigned char *eordinals
;
1217 edata_d
= xmalloc (edata_sz
);
1219 /* Note use of array pointer math here. */
1220 edirectory
= edata_d
;
1221 eaddresses
= edirectory
+ 40;
1222 enameptrs
= eaddresses
+ 4 * export_table_size
;
1223 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1224 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1226 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1227 + edata_s->output_section->vma - image_base)
1229 memset (edata_d
, 0, edata_sz
);
1231 if (pe_data (abfd
)->timestamp
== -1)
1232 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1234 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, edata_d
+ 4);
1236 if (pe_def_file
->version_major
!= -1)
1238 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1239 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1242 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1243 strcpy (enamestr
, dll_filename
);
1244 enamestr
+= strlen (enamestr
) + 1;
1245 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1246 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1247 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1248 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1249 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1250 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1252 fill_exported_offsets (abfd
, info
);
1254 /* Ok, now for the filling in part.
1255 Scan alphabetically - ie the ordering in the exports[] table,
1256 rather than by ordinal - the ordering in the exported_symbol[]
1257 table. See dlltool.c and:
1258 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1259 for more information. */
1261 for (s
= 0; s
< NE
; s
++)
1263 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1264 if (pe_def_file
->exports
[s
].ordinal
!= -1
1265 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1267 int ord
= pe_def_file
->exports
[s
].ordinal
;
1269 if (pe_def_file
->exports
[s
].flag_forward
)
1271 bfd_put_32 (abfd
, ERVA (enamestr
),
1272 eaddresses
+ 4 * (ord
- min_ordinal
));
1274 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1275 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1279 bfd_vma srva
= (exported_symbol_offsets
[s
]
1280 + ssec
->output_section
->vma
1281 + ssec
->output_offset
);
1283 bfd_put_32 (abfd
, srva
- image_base
,
1284 eaddresses
+ 4 * (ord
- min_ordinal
));
1287 if (!pe_def_file
->exports
[s
].flag_noname
)
1289 char *ename
= pe_def_file
->exports
[s
].name
;
1290 if (pe_def_file
->exports
[s
].its_name
)
1291 ename
= pe_def_file
->exports
[s
].its_name
;
1293 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1295 strcpy (enamestr
, ename
);
1296 enamestr
+= strlen (enamestr
) + 1;
1297 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1299 pe_def_file
->exports
[s
].hint
= hint
++;
1306 static struct bfd_section
*current_sec
;
1309 pe_walk_relocs (struct bfd_link_info
*info
,
1311 const char *symname
,
1312 struct bfd_hash_table
*import_hash
,
1313 void (*cb
) (arelent
*, asection
*, char *, const char *))
1318 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1322 if (!bfd_generic_link_read_symbols (b
))
1324 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1328 symbols
= bfd_get_outsymbols (b
);
1330 for (s
= b
->sections
; s
; s
= s
->next
)
1333 int relsize
, nrelocs
, i
;
1334 int flags
= bfd_section_flags (s
);
1336 /* Skip discarded linkonce sections. */
1337 if (flags
& SEC_LINK_ONCE
1338 && s
->output_section
== bfd_abs_section_ptr
)
1343 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1344 relocs
= xmalloc (relsize
);
1345 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1347 for (i
= 0; i
< nrelocs
; i
++)
1349 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1351 /* Warning: the callback needs to be passed NAME directly. */
1354 if (bfd_hash_lookup (import_hash
, sym
->name
, false, false))
1356 strcpy (name
, sym
->name
);
1357 cb (relocs
[i
], s
, name
, symname
);
1362 if (strcmp (name
, sym
->name
) == 0)
1363 cb (relocs
[i
], s
, name
, symname
);
1369 /* Warning: the allocated symbols are remembered in BFD and reused
1370 later, so don't free them! */
1371 /* free (symbols); */
1377 pe_find_data_imports (const char *symhead
,
1378 void (*cb
) (arelent
*, asection
*, char *, const char *))
1380 struct bfd_link_hash_entry
*undef
;
1381 const size_t headlen
= strlen (symhead
);
1384 struct bfd_hash_table
*import_hash
;
1386 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1387 if (undef
->type
== bfd_link_hash_undefined
)
1389 size_t len
= strlen (undef
->root
.string
);
1396 /* For the pseudo-relocation support version 2, we can collect the symbols
1397 that are subject to auto-import and adjust the relocations en masse. */
1398 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1401 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1402 if (!bfd_hash_table_init (import_hash
,
1404 sizeof (struct bfd_hash_entry
)))
1405 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1410 /* We are being a bit cunning here. The buffer will have space for
1411 prefixes at the beginning. The prefix is modified here and in a
1412 number of functions called from this function. */
1413 #define PREFIX_LEN 32
1414 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1415 name
= buf
+ PREFIX_LEN
;
1417 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1418 if (undef
->type
== bfd_link_hash_undefined
)
1420 struct bfd_link_hash_entry
*sym
;
1423 if (pe_dll_extra_pe_debug
)
1424 printf ("%s:%s\n", __FUNCTION__
, undef
->root
.string
);
1426 strcpy (name
, undef
->root
.string
);
1427 impname
= name
- (sizeof "__imp_" - 1);
1428 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1430 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1432 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1435 bfd_hash_lookup (import_hash
, undef
->root
.string
, true, false);
1438 bfd
*b
= sym
->u
.def
.section
->owner
;
1439 const char *symname
= NULL
;
1443 if (!bfd_generic_link_read_symbols (b
))
1445 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1449 symbols
= bfd_get_outsymbols (b
);
1450 nsyms
= bfd_get_symcount (b
);
1452 for (i
= 0; i
< nsyms
; i
++)
1453 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1455 if (pe_dll_extra_pe_debug
)
1456 printf ("->%s\n", symbols
[i
]->name
);
1458 symname
= symbols
[i
]->name
+ headlen
;
1462 /* If the symobl isn't part of an import table, there is no
1463 point in building a fixup, this would give rise to link
1464 errors for mangled symbols instead of the original one. */
1466 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1471 /* Let's differentiate it somehow from defined. */
1472 undef
->type
= bfd_link_hash_defweak
;
1473 undef
->u
.def
.value
= sym
->u
.def
.value
;
1474 undef
->u
.def
.section
= sym
->u
.def
.section
;
1476 /* We replace the original name with the __imp_ prefixed one, this
1477 1) may trash memory 2) leads to duplicate symbols. But this is
1478 better than having a misleading name that can confuse GDB. */
1479 undef
->root
.string
= sym
->root
.string
;
1481 if (link_info
.pei386_auto_import
== -1)
1483 static bool warned
= false;
1485 info_msg (_("Info: resolving %s by linking to %s "
1486 "(auto-import)\n"), name
, impname
);
1488 /* PR linker/4844. */
1491 einfo (_("%P: warning: auto-importing has been activated "
1492 "without --enable-auto-import specified on the "
1493 "command line; this should work unless it "
1494 "involves constant data structures referencing "
1495 "symbols from auto-imported DLLs\n"));
1502 /* If we have the import hash table, walk the relocations only once. */
1505 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1506 bfd_hash_table_free (import_hash
);
1513 /* Gather all the relocations and build the .reloc section. */
1516 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1518 /* For .reloc stuff. */
1519 reloc_data_type
*reloc_data
;
1520 int total_relocs
= 0;
1522 bfd_vma sec_page
= (bfd_vma
) -1;
1525 struct bfd_section
*s
;
1527 if (reloc_s
== NULL
|| reloc_s
->output_section
== bfd_abs_section_ptr
)
1530 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1531 for (s
= b
->sections
; s
; s
= s
->next
)
1532 total_relocs
+= s
->reloc_count
;
1534 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1537 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1540 int relsize
, nrelocs
;
1542 for (s
= b
->sections
; s
; s
= s
->next
)
1544 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1547 /* If it's not loaded, we don't need to relocate it this way. */
1548 if (!(s
->output_section
->flags
& SEC_LOAD
))
1551 /* I don't know why there would be a reloc for these, but I've
1552 seen it happen - DJ */
1553 if (s
->output_section
== bfd_abs_section_ptr
)
1556 if (s
->output_section
->vma
== 0)
1558 /* Huh? Shouldn't happen, but punt if it does. */
1559 #if 0 /* This happens when linking with --just-symbols=<file>, so do not generate an error. */
1560 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1561 s
->output_section
->name
, s
->output_section
->index
,
1562 s
->output_section
->flags
);
1567 if (!bfd_generic_link_read_symbols (b
))
1569 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1573 symbols
= bfd_get_outsymbols (b
);
1574 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1575 relocs
= xmalloc (relsize
);
1576 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1578 for (i
= 0; i
< nrelocs
; i
++)
1580 if (pe_dll_extra_pe_debug
)
1582 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1583 printf ("rel: %s\n", sym
->name
);
1585 if (!relocs
[i
]->howto
->pc_relative
1586 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1588 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1589 const struct bfd_link_hash_entry
*blhe
1590 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1591 false, false, false);
1593 /* Don't create relocs for undefined weak symbols. */
1594 if (sym
->flags
== BSF_WEAK
)
1596 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1598 /* Check aux sym and see if it is defined or not. */
1599 struct coff_link_hash_entry
*h
, *h2
;
1600 h
= (struct coff_link_hash_entry
*)blhe
;
1601 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1603 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1604 [h
->aux
->x_sym
.x_tagndx
.l
];
1605 /* We don't want a base reloc if the aux sym is not
1606 found, undefined, or if it is the constant ABS
1607 zero default value. (We broaden that slightly by
1608 not testing the value, just the section; there's
1609 no reason we'd want a reference to any absolute
1610 address to get relocated during rebasing). */
1611 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1612 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1615 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1618 /* Nor for Dwarf FDE references to discarded sections. */
1619 else if (bfd_is_abs_section (sym
->section
->output_section
))
1621 /* We only ignore relocs from .eh_frame sections, as
1622 they are discarded by the final link rather than
1623 resolved against the kept section. */
1624 if (!strcmp (s
->name
, ".eh_frame"))
1627 /* Nor for absolute symbols. */
1628 else if (blhe
&& ldexp_is_final_sym_absolute (blhe
)
1629 && (!blhe
->linker_def
1630 || (strcmp (sym
->name
, "__image_base__")
1631 && strcmp (sym
->name
, U ("__ImageBase")))))
1634 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1635 reloc_data
[total_relocs
].idx
= total_relocs
;
1637 /* Since we're only about to determine .reloc's size,
1638 subsequent output section VMA calculations will shift up
1639 sections at this or higher addresses. Relocations for
1640 such sections would hence end up not being correct. */
1641 if (reloc_data
[total_relocs
].vma
1642 >= reloc_s
->output_section
->vma
)
1643 einfo (_("%P: base relocation for section `%s' above "
1644 ".reloc section\n"), s
->output_section
->name
);
1646 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1648 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1649 relocs
[i
]->howto
->rightshift
)
1652 case BITS_AND_SHIFT (64, 0):
1653 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_DIR64
;
1657 case BITS_AND_SHIFT (32, 0):
1658 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_HIGHLOW
;
1661 case BITS_AND_SHIFT (16, 0):
1662 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_LOW
;
1665 case BITS_AND_SHIFT (16, 16):
1666 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_HIGHADJ
;
1667 /* FIXME: we can't know the symbol's right value
1668 yet, but we probably can safely assume that
1669 CE will relocate us in 64k blocks, so leaving
1671 reloc_data
[total_relocs
].extra
= 0;
1674 case BITS_AND_SHIFT (26, 2):
1675 reloc_data
[total_relocs
].type
=
1676 IMAGE_REL_BASED_ARM_MOV32
;
1679 case BITS_AND_SHIFT (24, 2):
1680 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1681 Those ARM_xxx definitions should go in proper
1683 if (relocs
[i
]->howto
->type
== 0
1684 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1685 || relocs
[i
]->howto
->type
== 5)
1686 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1687 that has already been fully processed during a
1688 previous link stage, so ignore it here. */
1692 /* xgettext:c-format */
1693 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1694 relocs
[i
]->howto
->bitsize
);
1700 /* Warning: the allocated symbols are remembered in BFD and
1701 reused later, so don't free them! */
1705 /* At this point, we have total_relocs relocation addresses in
1706 reloc_addresses, which are all suitable for the .reloc section.
1707 We must now create the new sections. */
1708 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1710 for (i
= 0; i
< total_relocs
; i
++)
1712 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1714 if (this_page
!= sec_page
)
1716 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1718 sec_page
= this_page
;
1723 if (reloc_data
[i
].type
== IMAGE_REL_BASED_HIGHADJ
)
1727 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1728 reloc_d
= xmalloc (reloc_sz
);
1729 sec_page
= (bfd_vma
) -1;
1731 page_ptr
= (bfd_vma
) -1;
1733 for (i
= 0; i
< total_relocs
; i
++)
1735 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1736 bfd_vma this_page
= (rva
& ~0xfff);
1738 if (this_page
!= sec_page
)
1740 while (reloc_sz
& 3)
1741 reloc_d
[reloc_sz
++] = 0;
1743 if (page_ptr
!= (bfd_vma
) -1)
1744 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1746 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1747 page_ptr
= reloc_sz
;
1749 sec_page
= this_page
;
1752 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1753 reloc_d
+ reloc_sz
);
1756 if (reloc_data
[i
].type
== IMAGE_REL_BASED_HIGHADJ
)
1758 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1764 while (reloc_sz
& 3)
1765 reloc_d
[reloc_sz
++] = 0;
1767 if (page_ptr
!= (bfd_vma
) -1)
1768 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1771 /* Given the exiting def_file structure, print out a .DEF file that
1772 corresponds to it. */
1775 quoteput (char *s
, FILE *f
, int needs_quotes
)
1779 for (cp
= s
; *cp
; cp
++)
1794 if (*s
== '"' || *s
== '\\')
1808 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1811 FILE *out
= fopen (pe_out_def_filename
, "w");
1814 /* xgettext:c-format */
1815 einfo (_("%P: can't open output def file %s\n"),
1816 pe_out_def_filename
);
1820 if (pe_def_file
->name
)
1822 if (pe_def_file
->is_dll
)
1823 fprintf (out
, "LIBRARY ");
1825 fprintf (out
, "NAME ");
1827 quoteput (pe_def_file
->name
, out
, 1);
1829 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1830 fprintf (out
, " BASE=0x%" PRIx64
,
1831 (uint64_t) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
);
1832 fprintf (out
, "\n");
1835 if (pe_def_file
->description
)
1837 fprintf (out
, "DESCRIPTION ");
1838 quoteput (pe_def_file
->description
, out
, 1);
1839 fprintf (out
, "\n");
1842 if (pe_def_file
->version_minor
!= -1)
1843 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1844 pe_def_file
->version_minor
);
1845 else if (pe_def_file
->version_major
!= -1)
1846 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1848 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1849 fprintf (out
, "\n");
1851 if (pe_def_file
->stack_commit
!= -1)
1852 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1853 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1854 else if (pe_def_file
->stack_reserve
!= -1)
1855 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1857 if (pe_def_file
->heap_commit
!= -1)
1858 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1859 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1860 else if (pe_def_file
->heap_reserve
!= -1)
1861 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1863 if (pe_def_file
->num_section_defs
> 0)
1865 fprintf (out
, "\nSECTIONS\n\n");
1867 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1870 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1872 if (pe_def_file
->section_defs
[i
].class)
1874 fprintf (out
, " CLASS ");
1875 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1878 if (pe_def_file
->section_defs
[i
].flag_read
)
1879 fprintf (out
, " READ");
1881 if (pe_def_file
->section_defs
[i
].flag_write
)
1882 fprintf (out
, " WRITE");
1884 if (pe_def_file
->section_defs
[i
].flag_execute
)
1885 fprintf (out
, " EXECUTE");
1887 if (pe_def_file
->section_defs
[i
].flag_shared
)
1888 fprintf (out
, " SHARED");
1890 fprintf (out
, "\n");
1894 if (pe_def_file
->num_exports
> 0)
1896 fprintf (out
, "EXPORTS\n");
1898 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1900 def_file_export
*e
= pe_def_file
->exports
+ i
;
1902 quoteput (e
->name
, out
, 0);
1904 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1906 fprintf (out
, " = ");
1907 quoteput (e
->internal_name
, out
, 0);
1910 if (e
->ordinal
!= -1)
1911 fprintf (out
, " @%d", e
->ordinal
);
1913 if (e
->flag_private
)
1914 fprintf (out
, " PRIVATE");
1916 if (e
->flag_constant
)
1917 fprintf (out
, " CONSTANT");
1920 fprintf (out
, " NONAME");
1923 fprintf (out
, " DATA");
1925 fprintf (out
, "\n");
1929 if (pe_def_file
->num_imports
> 0)
1931 fprintf (out
, "\nIMPORTS\n\n");
1933 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1935 def_file_import
*im
= pe_def_file
->imports
+ i
;
1938 if (im
->internal_name
1939 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1941 quoteput (im
->internal_name
, out
, 0);
1942 fprintf (out
, " = ");
1945 quoteput (im
->module
->name
, out
, 0);
1949 quoteput (im
->name
, out
, 0);
1951 fprintf (out
, "%d", im
->ordinal
);
1955 fprintf (out
, " == ");
1956 quoteput (im
->its_name
, out
, 0);
1959 fprintf (out
, "\n");
1964 fprintf (out
, _("; no contents available\n"));
1966 if (fclose (out
) == EOF
)
1967 /* xgettext:c-format */
1968 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1971 /* Generate the import library. */
1973 static asymbol
**symtab
;
1976 static char *dll_symname
;
1978 #define UNDSEC bfd_und_section_ptr
1981 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1986 sec
= bfd_make_section_old_way (abfd
, name
);
1987 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1988 bfd_set_section_alignment (sec
, align
);
1989 /* Remember to undo this before trying to link internally! */
1990 sec
->output_section
= sec
;
1992 sym
= bfd_make_empty_symbol (abfd
);
1993 symtab
[symptr
++] = sym
;
1994 sym
->name
= sec
->name
;
1996 sym
->flags
= BSF_LOCAL
;
2003 quick_symbol (bfd
*abfd
,
2012 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
2017 sym
= bfd_make_empty_symbol (abfd
);
2022 symtab
[symptr
++] = sym
;
2025 static arelent
*reltab
= 0;
2026 static int relcount
= 0, relsize
= 0;
2029 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2031 if (relcount
>= relsize
- 1)
2035 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2037 reltab
= xmalloc (relsize
* sizeof (arelent
));
2039 reltab
[relcount
].address
= address
;
2040 reltab
[relcount
].addend
= 0;
2041 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2042 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2047 save_relocs (asection
*sec
)
2051 sec
->relocation
= reltab
;
2052 sec
->reloc_count
= relcount
;
2053 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2054 for (i
= 0; i
< relcount
; i
++)
2055 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2056 sec
->orelocation
[relcount
] = 0;
2057 sec
->flags
|= SEC_RELOC
;
2059 relcount
= relsize
= 0;
2062 /* .section .idata$2
2063 .global __head_my_dll
2080 make_head (bfd
*parent
)
2082 asection
*id2
, *id5
, *id4
;
2083 unsigned char *d2
, *d5
, *d4
;
2087 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2088 /* In theory we should return NULL here at let our caller decide what to
2089 do. But currently the return value is not checked, just used, and
2090 besides, this condition only happens when the system has run out of
2091 memory. So just give up. */
2092 exit (EXIT_FAILURE
);
2095 abfd
= bfd_create (oname
, parent
);
2096 bfd_find_target (pe_details
->object_target
, abfd
);
2097 bfd_make_writable (abfd
);
2099 bfd_set_format (abfd
, bfd_object
);
2100 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2103 symtab
= xmalloc (6 * sizeof (asymbol
*));
2104 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2105 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2106 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2107 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2108 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2110 /* OK, pay attention here. I got confused myself looking back at
2111 it. We create a four-byte section to mark the beginning of the
2112 list, and we include an offset of 4 in the section, so that the
2113 pointer to the list points to the *end* of this section, which is
2114 the start of the list of sections from other objects. */
2116 bfd_set_section_size (id2
, 20);
2120 if (pe_use_nul_prefixed_import_tables
)
2121 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2122 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2123 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2124 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2127 if (pe_use_nul_prefixed_import_tables
)
2128 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2130 bfd_set_section_size (id5
, 0);
2131 d5
= xmalloc (PE_IDATA5_SIZE
);
2133 memset (d5
, 0, PE_IDATA5_SIZE
);
2134 if (pe_use_nul_prefixed_import_tables
)
2135 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2137 bfd_set_section_size (id4
, 0);
2138 d4
= xmalloc (PE_IDATA4_SIZE
);
2140 memset (d4
, 0, PE_IDATA4_SIZE
);
2142 bfd_set_symtab (abfd
, symtab
, symptr
);
2144 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2145 if (pe_use_nul_prefixed_import_tables
)
2147 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2148 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2152 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2153 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2156 bfd_make_readable (abfd
);
2160 /* .section .idata$4
2167 .global __my_dll_iname
2172 make_tail (bfd
*parent
)
2174 asection
*id4
, *id5
, *id7
;
2175 unsigned char *d4
, *d5
, *d7
;
2180 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2181 /* In theory we should return NULL here at let our caller decide what to
2182 do. But currently the return value is not checked, just used, and
2183 besides, this condition only happens when the system has run out of
2184 memory. So just give up. */
2185 exit (EXIT_FAILURE
);
2188 abfd
= bfd_create (oname
, parent
);
2189 bfd_find_target (pe_details
->object_target
, abfd
);
2190 bfd_make_writable (abfd
);
2192 bfd_set_format (abfd
, bfd_object
);
2193 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2196 symtab
= xmalloc (5 * sizeof (asymbol
*));
2197 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2198 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2199 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2200 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2202 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2203 d4
= xmalloc (PE_IDATA4_SIZE
);
2205 memset (d4
, 0, PE_IDATA4_SIZE
);
2207 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2208 d5
= xmalloc (PE_IDATA5_SIZE
);
2210 memset (d5
, 0, PE_IDATA5_SIZE
);
2212 len
= strlen (dll_filename
) + 1;
2215 bfd_set_section_size (id7
, len
);
2218 strcpy ((char *) d7
, dll_filename
);
2219 /* If len was odd, the above
2220 strcpy leaves behind an undefined byte. That is harmless,
2221 but we set it to 0 just so the binary dumps are pretty. */
2224 bfd_set_symtab (abfd
, symtab
, symptr
);
2226 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2227 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2228 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2230 bfd_make_readable (abfd
);
2236 .global ___imp_function
2237 .global __imp__function
2239 jmp *__imp__function:
2253 .asciz "function" xlate? (add underscore, kill at) */
2255 static const unsigned char jmp_ix86_bytes
[] =
2257 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2263 static const unsigned char jmp_aarch64_bytes
[] =
2265 0x00, 0x00, 0x00, 0x14,
2266 0x1f, 0x20, 0x03, 0xD5
2274 .dw __imp_function */
2276 static const unsigned char jmp_sh_bytes
[] =
2278 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2282 lui $t0,<high:__imp_function>
2283 lw $t0,<low:__imp_function>
2287 static const unsigned char jmp_mips_bytes
[] =
2289 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2290 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2293 static const unsigned char jmp_arm_bytes
[] =
2295 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2296 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2302 make_one (def_file_export
*exp
, bfd
*parent
, bool include_jmp_stub
)
2304 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2305 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2309 const unsigned char *jmp_bytes
= NULL
;
2310 int jmp_byte_count
= 0;
2312 /* Include the jump stub section only if it is needed. A jump
2313 stub is needed if the symbol being imported <sym> is a function
2314 symbol and there is at least one undefined reference to that
2315 symbol. In other words, if all the import references to <sym> are
2316 explicitly through _declspec(dllimport) then the jump stub is not
2318 if (include_jmp_stub
)
2320 switch (pe_details
->pe_arch
)
2323 jmp_bytes
= jmp_ix86_bytes
;
2324 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2327 jmp_bytes
= jmp_sh_bytes
;
2328 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2331 jmp_bytes
= jmp_mips_bytes
;
2332 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2335 case PE_ARCH_arm_wince
:
2336 jmp_bytes
= jmp_arm_bytes
;
2337 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2339 case PE_ARCH_aarch64
:
2340 jmp_bytes
= jmp_aarch64_bytes
;
2341 jmp_byte_count
= sizeof (jmp_aarch64_bytes
);
2348 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2349 /* In theory we should return NULL here at let our caller decide what to
2350 do. But currently the return value is not checked, just used, and
2351 besides, this condition only happens when the system has run out of
2352 memory. So just give up. */
2353 exit (EXIT_FAILURE
);
2356 abfd
= bfd_create (oname
, parent
);
2357 bfd_find_target (pe_details
->object_target
, abfd
);
2358 bfd_make_writable (abfd
);
2360 bfd_set_format (abfd
, bfd_object
);
2361 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2364 symtab
= xmalloc (12 * sizeof (asymbol
*));
2366 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2367 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2368 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2369 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2370 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2372 if (*exp
->internal_name
== '@')
2374 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2376 if (include_jmp_stub
)
2377 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2378 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2380 /* Fastcall applies only to functions,
2381 so no need for auto-import symbol. */
2385 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2387 if (include_jmp_stub
)
2388 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2390 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2392 /* Symbol to reference ord/name of imported
2393 data symbol, used to implement auto-import. */
2395 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2398 if (pe_dll_compat_implib
)
2399 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2402 if (include_jmp_stub
)
2404 bfd_set_section_size (tx
, jmp_byte_count
);
2405 td
= xmalloc (jmp_byte_count
);
2407 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2409 switch (pe_details
->pe_arch
)
2413 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2415 /* Mark this object as SAFESEH compatible. */
2416 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2418 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2422 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2425 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2426 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2427 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2430 case PE_ARCH_arm_wince
:
2431 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2433 case PE_ARCH_aarch64
:
2434 quick_reloc (abfd
, 0, BFD_RELOC_AARCH64_JUMP26
, 2);
2442 bfd_set_section_size (tx
, 0);
2444 bfd_set_section_size (id7
, 4);
2448 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2451 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2452 d5
= xmalloc (PE_IDATA5_SIZE
);
2454 memset (d5
, 0, PE_IDATA5_SIZE
);
2456 if (exp
->flag_noname
)
2458 d5
[0] = exp
->ordinal
;
2459 d5
[1] = exp
->ordinal
>> 8;
2460 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2464 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2468 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2469 d4
= xmalloc (PE_IDATA4_SIZE
);
2471 memset (d4
, 0, PE_IDATA4_SIZE
);
2473 if (exp
->flag_noname
)
2475 d4
[0] = exp
->ordinal
;
2476 d4
[1] = exp
->ordinal
>> 8;
2477 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2481 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2485 if (exp
->flag_noname
)
2488 bfd_set_section_size (id6
, 0);
2494 /* { short, asciz } */
2496 len
= 2 + strlen (exp
->its_name
) + 1;
2498 len
= 2 + strlen (exp
->name
) + 1;
2501 bfd_set_section_size (id6
, len
);
2504 memset (d6
, 0, len
);
2506 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2507 contains an invalid value (-1). */
2508 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2513 strcpy ((char*) d6
+ 2, exp
->its_name
);
2515 strcpy ((char *) d6
+ 2, exp
->name
);
2518 bfd_set_symtab (abfd
, symtab
, symptr
);
2520 if (include_jmp_stub
)
2521 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2522 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2523 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2524 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2525 if (!exp
->flag_noname
)
2526 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2528 bfd_make_readable (abfd
);
2533 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2535 /* Name thunks go to idata$4. */
2541 if (asprintf (&oname
, "%s_nmth%06d.o", dll_symname
, tmp_seq
) < 4)
2542 /* In theory we should return NULL here at let our caller decide what to
2543 do. But currently the return value is not checked, just used, and
2544 besides, this condition only happens when the system has run out of
2545 memory. So just give up. */
2546 exit (EXIT_FAILURE
);
2549 abfd
= bfd_create (oname
, parent
);
2550 bfd_find_target (pe_details
->object_target
, abfd
);
2551 bfd_make_writable (abfd
);
2553 bfd_set_format (abfd
, bfd_object
);
2554 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2557 symtab
= xmalloc (3 * sizeof (asymbol
*));
2558 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2559 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2560 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2562 /* We need space for the real thunk and for the null terminator. */
2563 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2564 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2566 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2567 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2570 bfd_set_symtab (abfd
, symtab
, symptr
);
2572 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2574 bfd_make_readable (abfd
);
2579 make_import_fixup_mark (arelent
*rel
, char *name
)
2581 /* We convert reloc to symbol, for later reference. */
2582 static unsigned int counter
;
2583 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2584 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2585 struct bfd_link_hash_entry
*bh
;
2586 char *fixup_name
, buf
[256];
2589 /* "name" buffer has space before the symbol name for prefixes. */
2590 sprintf (buf
, "__fu%d_", counter
++);
2591 prefix_len
= strlen (buf
);
2592 fixup_name
= name
- prefix_len
;
2593 memcpy (fixup_name
, buf
, prefix_len
);
2596 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2597 current_sec
, /* sym->section, */
2598 rel
->address
, NULL
, true, false, &bh
);
2600 return bh
->root
.string
;
2603 /* .section .idata$2
2604 .rva __nm_thnk_SYM (singleton thunk with name of func)
2607 .rva __my_dll_iname (name of dll)
2608 .rva __fuNN_SYM (pointer to reference (address) in text) */
2611 make_import_fixup_entry (const char *name
,
2612 const char *fixup_name
,
2613 const char *symname
,
2621 if (asprintf (&oname
, "%s_fu%06d.o", dll_symname
, tmp_seq
) < 4)
2622 /* In theory we should return NULL here at let our caller decide what to
2623 do. But currently the return value is not checked, just used, and
2624 besides, this condition only happens when the system has run out of
2625 memory. So just give up. */
2626 exit (EXIT_FAILURE
);
2629 abfd
= bfd_create (oname
, parent
);
2630 bfd_find_target (pe_details
->object_target
, abfd
);
2631 bfd_make_writable (abfd
);
2633 bfd_set_format (abfd
, bfd_object
);
2634 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2637 symtab
= xmalloc (6 * sizeof (asymbol
*));
2638 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2640 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2641 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2642 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2644 bfd_set_section_size (id2
, 20);
2649 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2650 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2651 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2654 bfd_set_symtab (abfd
, symtab
, symptr
);
2656 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2658 bfd_make_readable (abfd
);
2662 /* .section .rdata_runtime_pseudo_reloc
2664 .rva __fuNN_SYM (pointer to reference (address) in text) */
2667 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2668 const char *fixup_name
,
2669 bfd_vma addend ATTRIBUTE_UNUSED
,
2674 unsigned char *rt_rel_d
;
2679 if (asprintf (&oname
, "%s_rtr%06d.o", dll_symname
, tmp_seq
) < 4)
2680 /* In theory we should return NULL here at let our caller decide what to
2681 do. But currently the return value is not checked, just used, and
2682 besides, this condition only happens when the system has run out of
2683 memory. So just give up. */
2684 exit (EXIT_FAILURE
);
2687 abfd
= bfd_create (oname
, parent
);
2688 bfd_find_target (pe_details
->object_target
, abfd
);
2689 bfd_make_writable (abfd
);
2691 bfd_set_format (abfd
, bfd_object
);
2692 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2694 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2696 if (runtime_pseudp_reloc_v2_init
)
2697 size
= 3 * sizeof (asymbol
*);
2699 size
= 6 * sizeof (asymbol
*);
2702 size
= 2 * sizeof (asymbol
*);
2705 symtab
= xmalloc (size
);
2708 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2710 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2712 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2715 if (!runtime_pseudp_reloc_v2_init
)
2718 runtime_pseudp_reloc_v2_init
= true;
2721 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2723 bfd_set_section_size (rt_rel
, size
);
2724 rt_rel_d
= xmalloc (size
);
2725 rt_rel
->contents
= rt_rel_d
;
2726 memset (rt_rel_d
, 0, size
);
2727 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2728 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2729 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2731 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2732 save_relocs (rt_rel
);
2734 bfd_set_symtab (abfd
, symtab
, symptr
);
2736 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2740 bfd_set_section_size (rt_rel
, 8);
2741 rt_rel_d
= xmalloc (8);
2742 rt_rel
->contents
= rt_rel_d
;
2743 memset (rt_rel_d
, 0, 8);
2745 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2746 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2748 save_relocs (rt_rel
);
2750 bfd_set_symtab (abfd
, symtab
, symptr
);
2752 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2755 bfd_make_readable (abfd
);
2760 .rva __pei386_runtime_relocator */
2763 pe_create_runtime_relocator_reference (bfd
*parent
)
2765 asection
*extern_rt_rel
;
2766 unsigned char *extern_rt_rel_d
;
2770 if (asprintf (&oname
, "%s_ertr%06d.o", dll_symname
, tmp_seq
) < 4)
2771 /* In theory we should return NULL here at let our caller decide what to
2772 do. But currently the return value is not checked, just used, and
2773 besides, this condition only happens when the system has run out of
2774 memory. So just give up. */
2775 exit (EXIT_FAILURE
);
2778 abfd
= bfd_create (oname
, parent
);
2779 bfd_find_target (pe_details
->object_target
, abfd
);
2780 bfd_make_writable (abfd
);
2782 bfd_set_format (abfd
, bfd_object
);
2783 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2786 symtab
= xmalloc (2 * sizeof (asymbol
*));
2787 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2789 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2792 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2793 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2794 extern_rt_rel
->contents
= extern_rt_rel_d
;
2796 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2797 save_relocs (extern_rt_rel
);
2799 bfd_set_symtab (abfd
, symtab
, symptr
);
2801 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2803 bfd_make_readable (abfd
);
2808 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2809 const char *symname
)
2811 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2814 /* This is the original implementation of the auto-import feature, which
2815 primarily relied on the OS loader to patch things up with some help
2816 from the pseudo-relocator to overcome the main limitation. See the
2817 comment at the beginning of the file for an overview of the feature. */
2818 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2820 struct bfd_link_hash_entry
*name_thunk_sym
;
2821 /* name buffer is allocated with space at beginning for prefixes. */
2822 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2823 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2824 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2826 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2828 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2829 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2831 /* If we ever use autoimport, we have to cast text section writable. */
2832 config
.text_read_only
= false;
2833 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2836 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2838 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2839 link_info
.output_bfd
);
2840 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2844 /* In the original implementation, the pseudo-relocator was only used when
2845 the addend was not null. In the new implementation, the OS loader is
2846 completely bypassed and the pseudo-relocator does the entire work. */
2847 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2848 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2850 if (pe_dll_extra_pe_debug
)
2851 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2852 fixup_name
, (int) addend
);
2854 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
,
2855 rel
->howto
->bitsize
,
2856 link_info
.output_bfd
);
2857 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2859 if (runtime_pseudo_relocs_created
++ == 0)
2861 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2862 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2866 else if (addend
!= 0)
2867 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2868 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2872 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2881 unlink_if_ordinary (impfilename
);
2883 outarch
= bfd_openw (impfilename
, 0);
2887 /* xgettext:c-format */
2888 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2893 /* xgettext:c-format */
2894 info_msg (_("Creating library file: %s\n"), impfilename
);
2896 bfd_set_format (outarch
, bfd_archive
);
2897 outarch
->has_armap
= 1;
2899 /* Work out a reasonable size of things to put onto one line. */
2900 ar_head
= make_head (outarch
);
2902 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2903 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2905 /* Iterate the exclude list. */
2906 struct exclude_list_struct
*ex
;
2908 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2910 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2912 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2914 /* If it matched, we must open a fresh BFD for it (the original
2915 input BFD is still needed for the DLL's final link) and add
2916 it into the archive member chain. */
2919 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2920 ? bfd_get_filename (ibfd
->my_archive
)
2921 : bfd_get_filename (ibfd
), NULL
);
2924 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2927 if (ibfd
->my_archive
)
2929 /* Must now iterate through archive until we find the
2930 required member. A minor shame that we'll open the
2931 archive once per member that we require from it, and
2932 leak those archive bfds rather than reuse them. */
2933 bfd
*arbfd
= newbfd
;
2934 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2936 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2937 bfd_get_filename (ibfd
->my_archive
),
2938 bfd_get_filename (ibfd
));
2942 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2944 if (filename_cmp (bfd_get_filename (newbfd
),
2945 bfd_get_filename (ibfd
)) == 0)
2950 einfo (_("%X%P: %s(%s): can't find member in archive"),
2951 bfd_get_filename (ibfd
->my_archive
),
2952 bfd_get_filename (ibfd
));
2956 newbfd
->archive_next
= head
;
2961 for (i
= 0; i
< def
->num_exports
; i
++)
2963 /* The import library doesn't know about the internal name. */
2964 char *internal
= def
->exports
[i
].internal_name
;
2967 /* Don't add PRIVATE entries to import lib. */
2968 if (pe_def_file
->exports
[i
].flag_private
)
2971 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2973 /* PR 19803: If a symbol has been discard due to garbage
2974 collection then do not create any exports for it. */
2976 struct coff_link_hash_entry
*h
;
2978 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2979 false, false, false);
2981 /* If the symbol is hidden and undefined then it
2982 has been swept up by garbage collection. */
2983 && h
->symbol_class
== C_HIDDEN
2984 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2987 /* If necessary, check with an underscore prefix as well. */
2988 if (pe_details
->underscored
&& internal
[0] != '@')
2992 name
= xmalloc (strlen (internal
) + 2);
2993 sprintf (name
, "_%s", internal
);
2995 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2996 false, false, false);
3000 /* If the symbol is hidden and undefined then it
3001 has been swept up by garbage collection. */
3002 && h
->symbol_class
== C_HIDDEN
3003 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
3008 n
= make_one (def
->exports
+ i
, outarch
, !(def
->exports
+ i
)->flag_data
);
3009 n
->archive_next
= head
;
3011 def
->exports
[i
].internal_name
= internal
;
3014 ar_tail
= make_tail (outarch
);
3016 if (ar_head
== NULL
|| ar_tail
== NULL
)
3019 /* Now stick them all into the archive. */
3020 ar_head
->archive_next
= head
;
3021 ar_tail
->archive_next
= ar_head
;
3024 if (! bfd_set_archive_head (outarch
, head
))
3025 einfo ("%X%P: bfd_set_archive_head: %E\n");
3027 if (! bfd_close (outarch
))
3028 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
3030 while (head
!= NULL
)
3032 bfd
*n
= head
->archive_next
;
3038 static int undef_count
= 0;
3046 static struct key_value
*udef_table
;
3048 static int undef_sort_cmp (const void *l1
, const void *r1
)
3050 const struct key_value
*l
= l1
;
3051 const struct key_value
*r
= r1
;
3053 return strcmp (l
->key
, r
->key
);
3056 static struct bfd_link_hash_entry
*
3057 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3059 struct bfd_link_hash_entry
*h
= NULL
;
3060 struct key_value
*kv
;
3061 struct key_value key
;
3062 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3064 strcpy (lname
, name
);
3066 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3071 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3076 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3077 if (h
->type
== bfd_link_hash_undefined
)
3081 if (lname
[0] == '?')
3084 if (at
|| lname
[0] == '@')
3086 if (lname
[0] == '@')
3088 if (pe_details
->underscored
)
3091 /* Use memmove rather than strcpy as that
3092 can handle overlapping buffers. */
3093 memmove (lname
, lname
+ 1, strlen (lname
));
3095 kv
= bsearch (&key
, udef_table
, undef_count
,
3096 sizeof (struct key_value
), undef_sort_cmp
);
3099 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3100 if (h
->type
== bfd_link_hash_undefined
)
3105 *strchr (lname
, '@') = 0;
3107 kv
= bsearch (&key
, udef_table
, undef_count
,
3108 sizeof (struct key_value
), undef_sort_cmp
);
3111 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3112 if (h
->type
== bfd_link_hash_undefined
)
3118 strcat (lname
, "@");
3120 kv
= bsearch (&key
, udef_table
, undef_count
,
3121 sizeof (struct key_value
), undef_sort_cmp
);
3125 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3126 if (h
->type
== bfd_link_hash_undefined
)
3130 if (lname
[0] == '_' && pe_details
->underscored
)
3134 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3139 kv
= bsearch (&key
, udef_table
, undef_count
,
3140 sizeof (struct key_value
), undef_sort_cmp
);
3144 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3145 if (h
->type
== bfd_link_hash_undefined
)
3157 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3158 void *inf ATTRIBUTE_UNUSED
)
3160 if (h
->type
== bfd_link_hash_undefined
)
3166 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3168 if (h
->type
== bfd_link_hash_undefined
)
3172 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3173 at
= strchr (udef_table
[undef_count
].key
3174 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3177 udef_table
[undef_count
].oname
= h
->root
.string
;
3184 pe_create_undef_table (void)
3188 /* count undefined symbols */
3190 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3192 /* create and fill the corresponding table */
3193 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3196 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3199 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3203 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3205 lang_input_statement_type
*fake_file
;
3207 fake_file
= lang_add_input_file (name
,
3208 lang_input_file_is_fake_enum
,
3210 fake_file
->the_bfd
= abfd
;
3211 ldlang_add_file (fake_file
);
3213 if (!bfd_link_add_symbols (abfd
, linfo
))
3214 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3218 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3220 pe_dll_id_target (bfd_get_target (output_bfd
));
3225 def_file_module
*module
;
3226 def_file_import
*imp
;
3228 imp
= pe_def_file
->imports
;
3230 pe_create_undef_table ();
3232 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3234 int do_this_dll
= 0;
3236 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
3237 if (imp
[i
].module
== module
)
3239 if (i
>= pe_def_file
->num_imports
)
3242 dll_filename
= module
->name
;
3243 dll_symname
= xstrdup (module
->name
);
3244 for (j
= 0; dll_symname
[j
]; j
++)
3245 if (!ISALNUM (dll_symname
[j
]))
3246 dll_symname
[j
] = '_';
3248 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3250 def_file_export exp
;
3251 struct bfd_link_hash_entry
*blhe
;
3252 int lead_at
= (*imp
[i
].internal_name
== '@');
3253 /* See if we need this import. */
3254 size_t len
= strlen (imp
[i
].internal_name
);
3255 char *name
= xmalloc (len
+ 2 + 6);
3256 bool include_jmp_stub
= false;
3257 bool is_cdecl
= false;
3258 bool is_undef
= false;
3260 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3264 sprintf (name
, "%s", imp
[i
].internal_name
);
3266 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3268 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3269 false, false, false);
3271 /* Include the jump stub for <sym> only if the <sym>
3273 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3276 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3278 sprintf (name
, "%s%s%s", "__imp_", U (""),
3279 imp
[i
].internal_name
);
3281 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3282 false, false, false);
3284 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3288 include_jmp_stub
= true;
3289 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3293 && (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3295 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3296 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3297 include_jmp_stub
= true;
3299 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3310 bfd
*ar_head
= make_head (output_bfd
);
3311 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
),
3315 exp
.internal_name
= imp
[i
].internal_name
;
3316 exp
.name
= imp
[i
].name
;
3317 exp
.its_name
= imp
[i
].its_name
;
3318 exp
.ordinal
= imp
[i
].ordinal
;
3319 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3320 exp
.flag_private
= 0;
3321 exp
.flag_constant
= 0;
3322 exp
.flag_data
= imp
[i
].data
;
3323 exp
.flag_noname
= exp
.name
? 0 : 1;
3324 one
= make_one (&exp
, output_bfd
,
3325 !exp
.flag_data
&& include_jmp_stub
);
3326 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3331 bfd
*ar_tail
= make_tail (output_bfd
);
3332 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3341 free (udef_table
[undef_count
].key
);
3346 if (pe_def_file
&& pe_def_file
->name
)
3347 dll_filename
= pe_def_file
->name
;
3350 dll_filename
= bfd_get_filename (output_bfd
);
3351 for (const char *p
= dll_filename
; *p
; p
++)
3352 if (*p
== '\\' || *p
== '/' || *p
== ':')
3353 dll_filename
= p
+ 1;
3355 dll_symname
= xstrdup (dll_filename
);
3356 for (int i
= 0; dll_symname
[i
]; i
++)
3357 if (!ISALNUM (dll_symname
[i
]))
3358 dll_symname
[i
] = '_';
3361 /* We were handed a *.DLL file. Parse it and turn it into a set of
3362 IMPORTS directives in the def file. Return TRUE if the file was
3363 handled, FALSE if not. */
3366 pe_get16 (bfd
*abfd
, int where
)
3370 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3371 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3372 return b
[0] + (b
[1] << 8);
3376 pe_get32 (bfd
*abfd
, int where
)
3380 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3381 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3382 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3388 unsigned char *b
= ptr
;
3390 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3394 pe_implied_import_dll (const char *filename
)
3397 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3398 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3399 bfd_vma exp_funcbase
;
3400 unsigned char *expdata
;
3402 bfd_vma name_rvas
, nexp
;
3403 const char *dllname
;
3404 /* Initialization with start > end guarantees that is_data
3405 will not be set by mistake, and avoids compiler warning. */
3406 bfd_vma data_start
= 1;
3407 bfd_vma data_end
= 0;
3408 bfd_vma rdata_start
= 1;
3409 bfd_vma rdata_end
= 0;
3410 bfd_vma bss_start
= 1;
3411 bfd_vma bss_end
= 0;
3414 /* No, I can't use bfd here. kernel32.dll puts its export table in
3415 the middle of the .rdata section. */
3416 dll
= bfd_openr (filename
, pe_details
->target_name
);
3419 einfo (_("%X%P: open %s: %E\n"), filename
);
3423 track_dependency_files (filename
);
3425 /* PEI dlls seem to be bfd_objects. */
3426 if (!bfd_check_format (dll
, bfd_object
))
3428 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3432 /* Get pe_header, optional header and numbers of directory entries. */
3433 pe_header_offset
= pe_get32 (dll
, 0x3c);
3434 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3436 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3438 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3441 /* No import or export directory entry. */
3442 if (num_entries
< 1)
3446 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3447 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3449 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3450 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3453 /* No export table - nothing to export. */
3454 if (export_size
== 0)
3457 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3458 secptr
= (pe_header_offset
+ 4 + 20 +
3459 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3462 /* Get the rva and size of the export section. */
3463 for (i
= 0; i
< nsections
; i
++)
3466 bfd_vma secptr1
= secptr
+ 40 * i
;
3467 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3468 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3469 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3471 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3472 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3474 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3476 expptr
= fptr
+ (export_rva
- vaddr
);
3477 if (export_rva
+ export_size
> vaddr
+ vsize
)
3478 export_size
= vsize
- (export_rva
- vaddr
);
3483 /* Scan sections and store the base and size of the
3484 data and bss segments in data/base_start/end. */
3485 for (i
= 0; i
< nsections
; i
++)
3487 bfd_vma secptr1
= secptr
+ 40 * i
;
3488 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3489 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3490 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3494 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3495 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3497 if (strcmp(sec_name
,".data") == 0)
3500 data_end
= vaddr
+ vsize
;
3502 if (pe_dll_extra_pe_debug
)
3503 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3504 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3505 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3507 else if (strcmp(sec_name
,".rdata") == 0)
3509 rdata_start
= vaddr
;
3510 rdata_end
= vaddr
+ vsize
;
3512 if (pe_dll_extra_pe_debug
)
3513 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3514 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3515 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3517 else if (strcmp (sec_name
,".bss") == 0)
3520 bss_end
= vaddr
+ vsize
;
3522 if (pe_dll_extra_pe_debug
)
3523 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3524 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3525 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3529 expdata
= xmalloc (export_size
);
3530 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3531 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3532 erva
= (char *) expdata
- export_rva
;
3534 if (pe_def_file
== 0)
3535 pe_def_file
= def_file_empty ();
3537 nexp
= pe_as32 (expdata
+ 24);
3538 name_rvas
= pe_as32 (expdata
+ 32);
3539 exp_funcbase
= pe_as32 (expdata
+ 28);
3541 /* Use internal dll name instead of filename
3542 to enable symbolic dll linking. */
3543 dllname
= erva
+ pe_as32 (expdata
+ 12);
3545 /* Check to see if the dll has already been added to
3546 the definition list and if so return without error.
3547 This avoids multiple symbol definitions. */
3548 if (def_get_module (pe_def_file
, dllname
))
3550 if (pe_dll_extra_pe_debug
)
3551 printf ("%s is already loaded\n", dllname
);
3555 /* This is an optimized version of the insertion loop, which avoids lots of
3556 calls to realloc and memmove from def_file_add_import. */
3557 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3558 erva
+ pe_as32 (erva
+ name_rvas
),
3559 dllname
, 0, NULL
, NULL
)) >= 0)
3561 for (i
= 0; i
< nexp
; i
++)
3563 /* Pointer to the names vector. */
3564 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3565 def_file_import
*imp
;
3566 /* Pointer to the function address vector. */
3567 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3568 /* is_data is true if the address is in the data, rdata or bss
3571 (func_rva
>= data_start
&& func_rva
< data_end
)
3572 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3573 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3575 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3576 dllname
, i
, NULL
, NULL
);
3577 /* Mark symbol type. */
3578 imp
->data
= is_data
;
3580 if (pe_dll_extra_pe_debug
)
3581 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3582 __FUNCTION__
, dllname
, erva
+ name_rva
,
3583 (unsigned long) func_rva
, is_data
? "(data)" : "");
3589 /* Iterate through the list of symbols. */
3590 for (i
= 0; i
< nexp
; i
++)
3592 /* Pointer to the names vector. */
3593 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3594 def_file_import
*imp
;
3595 /* Pointer to the function address vector. */
3596 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3599 /* Skip unwanted symbols, which are
3600 exported in buggy auto-import releases. */
3601 if (! startswith (erva
+ name_rva
, "__nm_"))
3603 bool is_dup
= false;
3604 /* is_data is true if the address is in the data, rdata or bss
3607 (func_rva
>= data_start
&& func_rva
< data_end
)
3608 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3609 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3611 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3612 dllname
, i
, NULL
, NULL
, &is_dup
);
3613 /* Mark symbol type. */
3615 imp
->data
= is_data
;
3617 if (pe_dll_extra_pe_debug
)
3618 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3619 __FUNCTION__
, dllname
, erva
+ name_rva
,
3620 (unsigned long) func_rva
, is_data
? "(data)" : "");
3628 pe_output_file_set_long_section_names (bfd
*abfd
)
3630 if (pe_use_coff_long_section_names
< 0)
3632 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3633 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3636 /* These are the main functions, called from the emulation. The first
3637 is called after the bfds are read, so we can guess at how much space
3638 we need. The second is called after everything is placed, so we
3639 can put the right values in place. */
3642 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3644 pe_dll_id_target (bfd_get_target (abfd
));
3645 pe_output_file_set_long_section_names (abfd
);
3646 process_def_file_and_drectve (abfd
, info
);
3648 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3650 if (pe_dll_enable_reloc_section
)
3652 build_filler_bfd (0);
3653 pe_output_file_set_long_section_names (filler_bfd
);
3659 build_filler_bfd (1);
3660 pe_output_file_set_long_section_names (filler_bfd
);
3664 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3666 pe_dll_id_target (bfd_get_target (abfd
));
3667 pe_output_file_set_long_section_names (abfd
);
3668 build_filler_bfd (0);
3669 pe_output_file_set_long_section_names (filler_bfd
);
3673 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3675 pe_exe_fill_sections (abfd
, info
);
3679 fill_edata (abfd
, info
);
3680 edata_s
->contents
= edata_d
;
3683 if (bfd_link_dll (info
))
3684 pe_data (abfd
)->dll
= 1;
3688 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3690 pe_dll_id_target (bfd_get_target (abfd
));
3691 pe_output_file_set_long_section_names (abfd
);
3692 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3694 generate_reloc (abfd
, info
);
3697 bfd_set_section_size (reloc_s
, reloc_sz
);
3699 /* Resize the sections. */
3700 lang_reset_memory_regions ();
3701 lang_size_sections (NULL
, true);
3703 /* Redo special stuff. */
3704 ldemul_after_allocation ();
3706 /* Do the assignments again. */
3707 lang_do_assignments (lang_final_phase_enum
);
3710 reloc_s
->contents
= reloc_d
;
3714 pe_bfd_is_dll (bfd
*abfd
)
3716 return (bfd_get_format (abfd
) == bfd_object
3718 && pe_data (abfd
)->dll
);