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 unsigned char *reloc_d
= NULL
;
172 static size_t edata_sz
, reloc_sz
= 0;
173 static int runtime_pseudo_relocs_created
= 0;
174 static bool runtime_pseudp_reloc_v2_init
= false;
181 autofilter_entry_type
;
185 const char *target_name
;
186 const char *object_target
;
187 unsigned int imagebase_reloc
;
191 const autofilter_entry_type
* autofilter_symbollist
;
195 static const autofilter_entry_type autofilter_symbollist_generic
[] =
197 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
198 /* Entry point symbols. */
199 { STRING_COMMA_LEN ("DllMain") },
200 { STRING_COMMA_LEN ("DllMainCRTStartup") },
201 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
202 /* Runtime pseudo-reloc. */
203 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
204 { STRING_COMMA_LEN ("do_pseudo_reloc") },
208 static const autofilter_entry_type autofilter_symbollist_i386
[] =
210 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
211 /* Entry point symbols, and entry hooks. */
212 { STRING_COMMA_LEN ("cygwin_crt0") },
214 { STRING_COMMA_LEN ("DllMain") },
215 { STRING_COMMA_LEN ("DllEntryPoint") },
216 { STRING_COMMA_LEN ("DllMainCRTStartup") },
217 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
218 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
219 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
221 { STRING_COMMA_LEN ("DllMain@12") },
222 { STRING_COMMA_LEN ("DllEntryPoint@0") },
223 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
224 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
225 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
226 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
227 { STRING_COMMA_LEN ("cygwin_attach_dll") },
229 { STRING_COMMA_LEN ("cygwin_premain0") },
230 { STRING_COMMA_LEN ("cygwin_premain1") },
231 { STRING_COMMA_LEN ("cygwin_premain2") },
232 { STRING_COMMA_LEN ("cygwin_premain3") },
233 /* Runtime pseudo-reloc. */
234 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
235 { STRING_COMMA_LEN ("do_pseudo_reloc") },
236 /* Global vars that should not be exported. */
237 { STRING_COMMA_LEN ("impure_ptr") },
238 { STRING_COMMA_LEN ("_impure_ptr") },
239 { STRING_COMMA_LEN ("_fmode") },
240 { STRING_COMMA_LEN ("environ") },
241 { STRING_COMMA_LEN ("__dso_handle") },
245 #define PE_ARCH_i386 1
247 #define PE_ARCH_mips 3
248 #define PE_ARCH_arm 4
249 #define PE_ARCH_arm_wince 5
250 #define PE_ARCH_aarch64 6
252 /* Don't make it constant as underscore mode gets possibly overriden
253 by target or -(no-)leading-underscore option. */
254 static pe_details_type pe_detail_list
[] =
273 autofilter_symbollist_i386
283 autofilter_symbollist_i386
293 autofilter_symbollist_i386
299 16 /* R_SH_IMAGEBASE */,
303 autofilter_symbollist_generic
312 autofilter_symbollist_generic
321 autofilter_symbollist_generic
324 "pei-arm-wince-little",
325 "pe-arm-wince-little",
326 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
330 autofilter_symbollist_generic
333 "pei-aarch64-little",
339 autofilter_symbollist_generic
341 { NULL
, NULL
, 0, 0, 0, false, NULL
}
344 static const pe_details_type
*pe_details
;
346 /* Do not specify library suffix explicitly, to allow for dllized versions. */
347 static const autofilter_entry_type autofilter_liblist
[] =
349 { STRING_COMMA_LEN ("libcegcc") },
350 { STRING_COMMA_LEN ("libcygwin") },
351 { STRING_COMMA_LEN ("libgcc") },
352 { STRING_COMMA_LEN ("libgcc_s") },
353 { STRING_COMMA_LEN ("libstdc++") },
354 { STRING_COMMA_LEN ("libmingw32") },
355 { STRING_COMMA_LEN ("libmingwex") },
356 { STRING_COMMA_LEN ("libg2c") },
357 { STRING_COMMA_LEN ("libsupc++") },
358 { STRING_COMMA_LEN ("libobjc") },
359 { STRING_COMMA_LEN ("libgcj") },
360 { STRING_COMMA_LEN ("libmsvcrt") },
361 { STRING_COMMA_LEN ("libmsvcrt-os") },
362 { STRING_COMMA_LEN ("libucrt") },
363 { STRING_COMMA_LEN ("libucrtbase") },
367 /* Regardless of the suffix issue mentioned above, we must ensure that
368 we do not falsely match on a leading substring, such as when libtool
369 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
370 This routine ensures that the leading part of the name matches and that
371 it is followed by only an optional version suffix and a file extension,
372 returning zero if so or -1 if not. */
373 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
375 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
378 libname
+= afptr
->len
;
380 /* Be liberal in interpreting what counts as a version suffix; we
381 accept anything that has a dash to separate it from the name and
382 begins with a digit. */
383 if (libname
[0] == '-')
385 if (!ISDIGIT (*++libname
))
387 /* Ensure the filename has an extension. */
388 while (*++libname
!= '.')
392 else if (libname
[0] != '.')
398 static const autofilter_entry_type autofilter_objlist
[] =
400 { STRING_COMMA_LEN ("crt0.o") },
401 { STRING_COMMA_LEN ("crt1.o") },
402 { STRING_COMMA_LEN ("crt2.o") },
403 { STRING_COMMA_LEN ("dllcrt1.o") },
404 { STRING_COMMA_LEN ("dllcrt2.o") },
405 { STRING_COMMA_LEN ("gcrt0.o") },
406 { STRING_COMMA_LEN ("gcrt1.o") },
407 { STRING_COMMA_LEN ("gcrt2.o") },
408 { STRING_COMMA_LEN ("crtbegin.o") },
409 { STRING_COMMA_LEN ("crtend.o") },
413 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
415 /* _imp_ is treated specially, as it is always underscored. */
416 /* { STRING_COMMA_LEN ("_imp_") }, */
417 /* Don't export some c++ symbols. */
418 { STRING_COMMA_LEN ("__rtti_") },
419 { STRING_COMMA_LEN ("__builtin_") },
420 /* Don't re-export auto-imported symbols. */
421 { STRING_COMMA_LEN ("__nm_") },
422 /* Don't export symbols specifying internal DLL layout. */
423 { STRING_COMMA_LEN ("_head_") },
424 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
425 /* Don't export section labels or artificial symbols
427 { STRING_COMMA_LEN (".") },
431 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
433 { STRING_COMMA_LEN ("_iname") },
434 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
438 #define U(str) (pe_details->underscored ? "_" str : str)
441 pe_dll_id_target (const char *target
)
445 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
446 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
447 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
449 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
451 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
454 pe_detail_list
[i
].underscored
= u
!= 0;
455 pe_details
= pe_detail_list
+ i
;
456 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
459 einfo (_("%X%P: unsupported PEI architecture: %s\n"), target
);
463 /* Helper functions for qsort. Relocs must be sorted so that we can write
464 them out by pages. */
476 reloc_sort (const void *va
, const void *vb
)
478 const reloc_data_type
*a
= (const reloc_data_type
*) va
;
479 const reloc_data_type
*b
= (const reloc_data_type
*) vb
;
493 pe_export_sort (const void *va
, const void *vb
)
495 const def_file_export
*a
= va
;
496 const def_file_export
*b
= vb
;
504 return strcmp (an
, bn
);
507 /* Read and process the .DEF file. */
509 /* These correspond to the entries in pe_def_file->exports[]. I use
510 exported_symbol_sections[i] to tag whether or not the symbol was
511 defined, since we can't export symbols we don't have. */
513 static bfd_vma
*exported_symbol_offsets
;
514 static struct bfd_section
**exported_symbol_sections
;
515 static int export_table_size
;
516 static int count_exported
;
517 static int count_exported_byname
;
518 static int count_with_ordinals
;
519 static const char *dll_filename
;
520 static int min_ordinal
, max_ordinal
;
521 static int *exported_symbols
;
523 typedef struct exclude_list_struct
526 struct exclude_list_struct
*next
;
531 static struct exclude_list_struct
*excludes
= 0;
534 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
537 char *exclude_string
;
539 local_copy
= xstrdup (new_excludes
);
541 exclude_string
= strtok (local_copy
, ",:");
542 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
544 struct exclude_list_struct
*new_exclude
;
546 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
547 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
548 strcpy (new_exclude
->string
, exclude_string
);
549 new_exclude
->type
= type
;
550 new_exclude
->next
= excludes
;
551 excludes
= new_exclude
;
558 is_import (const char* n
)
560 return (startswith (n
, "__imp_"));
563 /* abfd is a bfd containing n (or NULL)
564 It can be used for contextual checks. */
567 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
570 struct exclude_list_struct
*ex
;
571 const autofilter_entry_type
*afptr
;
572 const char * libname
= NULL
;
574 if (abfd
&& abfd
->my_archive
)
575 libname
= lbasename (bfd_get_filename (abfd
->my_archive
));
577 key
.name
= key
.its_name
= (char *) n
;
579 /* Return false if n is in the d->exports table. */
580 if (d
->num_exports
!= 0
581 && bsearch (&key
, d
->exports
, d
->num_exports
,
582 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
585 if (pe_dll_do_default_excludes
)
590 if (pe_dll_extra_pe_debug
)
591 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
592 n
, abfd
, abfd
->my_archive
);
594 /* First of all, make context checks:
595 Don't export anything from standard libs. */
598 afptr
= autofilter_liblist
;
602 if (libnamencmp (libname
, afptr
) == 0 )
608 /* Next, exclude symbols from certain startup objects. */
610 if (abfd
&& (p
= lbasename (bfd_get_filename (abfd
))))
612 afptr
= autofilter_objlist
;
615 if (strcmp (p
, afptr
->name
) == 0)
621 /* Don't try to blindly exclude all symbols
622 that begin with '__'; this was tried and
623 it is too restrictive. Instead we have
624 a target specific list to use: */
625 afptr
= pe_details
->autofilter_symbollist
;
629 if (strcmp (n
, afptr
->name
) == 0)
635 /* Next, exclude symbols starting with ... */
636 afptr
= autofilter_symbolprefixlist
;
639 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
645 /* Finally, exclude symbols ending with ... */
647 afptr
= autofilter_symbolsuffixlist
;
650 if ((len
>= afptr
->len
)
651 /* Add 1 to insure match with trailing '\0'. */
652 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
653 afptr
->len
+ 1) == 0)
660 for (ex
= excludes
; ex
; ex
= ex
->next
)
662 if (ex
->type
== EXCLUDELIBS
)
665 && ((filename_cmp (libname
, ex
->string
) == 0)
666 || (strcasecmp ("ALL", ex
->string
) == 0)))
669 else if (ex
->type
== EXCLUDEFORIMPLIB
)
671 if (filename_cmp (bfd_get_filename (abfd
), ex
->string
) == 0)
674 else if (strcmp (n
, ex
->string
) == 0)
682 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
686 struct bfd_link_hash_entry
*blhe
;
688 struct bfd_section
*s
;
689 def_file_export
*e
= 0;
693 pe_def_file
= def_file_empty ();
695 /* First, run around to all the objects looking for the .drectve
696 sections, and push those into the def file too. */
697 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
699 s
= bfd_get_section_by_name (b
, ".drectve");
703 char *buf
= xmalloc (size
);
705 bfd_get_section_contents (b
, s
, buf
, 0, size
);
706 def_file_add_directive (pe_def_file
, buf
, size
);
711 /* Process aligned common symbol information from the
712 .drectve sections now; common symbol allocation is
713 done before final link, so it will be too late to
714 process them in process_embedded_commands() called
715 from _bfd_coff_link_input_bfd(). */
716 if (pe_def_file
->aligncomms
)
718 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
721 struct coff_link_hash_entry
*sym_hash
;
722 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
723 ac
->symbol_name
, false, false, false);
724 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
725 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
727 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
733 if (pe_def_file
->exclude_symbols
)
735 for (ui
= 0; ui
< pe_def_file
->num_exclude_symbols
; ui
++)
737 pe_dll_add_excludes (pe_def_file
->exclude_symbols
[ui
].symbol_name
,
742 /* If we are building an executable and there is nothing
743 to export, we do not build an export table at all. */
744 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
745 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
748 /* Now, maybe export everything else the default way. */
749 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
750 && !pe_dll_exclude_all_symbols
)
752 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
757 if (!bfd_generic_link_read_symbols (b
))
759 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
763 symbols
= bfd_get_outsymbols (b
);
764 nsyms
= bfd_get_symcount (b
);
766 for (j
= 0; j
< nsyms
; j
++)
768 /* We should export symbols which are either global or not
769 anything at all. (.bss data is the latter)
770 We should not export undefined symbols. */
772 = (symbols
[j
]->section
!= bfd_und_section_ptr
773 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
774 || (symbols
[j
]->flags
== 0)));
775 if (link_info
.version_info
&& would_export
)
777 = !bfd_hide_sym_by_version (link_info
.version_info
,
781 const char *sn
= symbols
[j
]->name
;
783 /* We should not re-export imported stuff. */
789 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
790 sprintf (name
, "%s%s", "__imp_", sn
);
792 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
793 false, false, false);
796 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
800 if (pe_details
->underscored
&& *sn
== '_')
803 if (auto_export (b
, pe_def_file
, sn
))
808 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
810 /* Fill data flag properly, from dlltool.c. */
812 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
820 #define NE pe_def_file->num_exports
822 /* Don't create an empty export table. */
826 resort_needed
= false;
828 /* Canonicalize the export list. */
831 for (i
= 0; i
< NE
; i
++)
833 /* Check for fastcall/stdcall-decoration, but ignore
834 C++ mangled names. */
835 if (pe_def_file
->exports
[i
].name
[0] != '?'
836 && strchr (pe_def_file
->exports
[i
].name
, '@'))
838 /* This will preserve internal_name, which may have been
839 pointing to the same memory as name, or might not
841 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
842 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
843 char *tmp_at
= strrchr (tmp
, '@');
848 einfo (_("%X%P: cannot export %s: invalid export name\n"),
849 pe_def_file
->exports
[i
].name
);
850 pe_def_file
->exports
[i
].name
= tmp
;
851 resort_needed
= true;
856 /* Re-sort the exports table as we have possibly changed the order
857 by removing leading @. */
859 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
862 if (pe_dll_stdcall_aliases
)
864 for (i
= 0; i
< NE
; i
++)
866 if (is_import (pe_def_file
->exports
[i
].name
))
869 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
872 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
873 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
875 *(strchr (tmp
, '@')) = 0;
876 if (auto_export (NULL
, pe_def_file
, tmp
))
877 def_file_add_export (pe_def_file
, tmp
,
878 pe_def_file
->exports
[i
].internal_name
,
886 /* Convenience, but watch out for it changing. */
887 e
= pe_def_file
->exports
;
889 for (i
= 0, j
= 0; i
< NE
; i
++)
891 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
893 /* This is a duplicate. */
894 if (e
[j
- 1].ordinal
!= -1
895 && e
[i
].ordinal
!= -1
896 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
898 if (pe_dll_warn_dup_exports
)
899 /* xgettext:c-format */
900 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
901 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
905 if (pe_dll_warn_dup_exports
)
906 /* xgettext:c-format */
907 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
911 if (e
[i
].ordinal
!= -1)
912 e
[j
- 1].ordinal
= e
[i
].ordinal
;
913 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
914 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
915 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
916 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
918 free (e
[i
].internal_name
);
919 free (e
[i
].its_name
);
928 pe_def_file
->num_exports
= j
; /* == NE */
930 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
931 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
933 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
937 count_exported_byname
= 0;
938 count_with_ordinals
= 0;
940 for (i
= 0; i
< NE
; i
++)
942 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
945 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
946 lang_add_gc_name (int_name
);
948 name
= xmalloc (strlen (int_name
) + 2);
949 if (pe_details
->underscored
&& int_name
[0] != '@')
952 strcpy (name
+ 1, int_name
);
954 /* PR 19803: The alias must be preserved as well. */
955 lang_add_gc_name (xstrdup (name
));
958 strcpy (name
, int_name
);
960 blhe
= bfd_link_hash_lookup (info
->hash
,
965 && (blhe
->type
== bfd_link_hash_defined
966 || (blhe
->type
== bfd_link_hash_common
)))
969 if (!pe_def_file
->exports
[i
].flag_noname
)
970 count_exported_byname
++;
972 /* Only fill in the sections. The actual offsets are computed
973 in fill_exported_offsets() after common symbols are laid
975 if (blhe
->type
== bfd_link_hash_defined
)
976 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
978 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
980 if (pe_def_file
->exports
[i
].ordinal
!= -1)
982 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
983 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
984 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
985 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
986 count_with_ordinals
++;
989 /* Check for forward exports. These are indicated in DEF files by an
990 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
991 but we must take care not to be fooled when the user wants to export
992 a symbol that actually really has a dot in it, so we only check
993 for them here, after real defined symbols have already been matched. */
994 else if (strchr (int_name
, '.'))
997 if (!pe_def_file
->exports
[i
].flag_noname
)
998 count_exported_byname
++;
1000 pe_def_file
->exports
[i
].flag_forward
= 1;
1002 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1004 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
1005 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
1006 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
1007 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
1008 count_with_ordinals
++;
1011 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
1013 /* xgettext:c-format */
1014 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
1019 /* xgettext:c-format */
1020 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
1022 blhe
->type
, bfd_link_hash_defined
);
1026 /* xgettext:c-format */
1027 einfo (_("%X%P: cannot export %s: symbol not found\n"),
1034 /* Build the bfd that will contain .edata and .reloc sections. */
1037 build_filler_bfd (bool include_edata
)
1039 lang_input_statement_type
*filler_file
;
1041 filler_file
= lang_add_input_file ("dll stuff",
1042 lang_input_file_is_fake_enum
,
1044 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1045 link_info
.output_bfd
);
1046 if (filler_bfd
== NULL
1047 || !bfd_set_arch_mach (filler_bfd
,
1048 bfd_get_arch (link_info
.output_bfd
),
1049 bfd_get_mach (link_info
.output_bfd
)))
1051 einfo (_("%F%P: can not create BFD: %E\n"));
1057 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1059 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1065 einfo (_("%X%P: can not create .edata section: %E\n"));
1068 bfd_set_section_size (edata_s
, edata_sz
);
1071 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1073 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1079 einfo (_("%X%P: can not create .reloc section: %E\n"));
1083 bfd_set_section_size (reloc_s
, 0);
1085 ldlang_add_file (filler_file
);
1088 /* Gather all the exported symbols and build the .edata section. */
1091 generate_edata (void)
1093 int i
, next_ordinal
;
1094 int name_table_size
= 0;
1096 /* First, we need to know how many exported symbols there are,
1097 and what the range of ordinals is. */
1098 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1100 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1101 min_ordinal
= max_ordinal
- count_exported
+ 1;
1106 max_ordinal
= count_exported
;
1109 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1110 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1111 for (i
= 0; i
< export_table_size
; i
++)
1112 exported_symbols
[i
] = -1;
1114 /* Now we need to assign ordinals to those that don't have them. */
1115 for (i
= 0; i
< NE
; i
++)
1117 if (exported_symbol_sections
[i
]
1118 || pe_def_file
->exports
[i
].flag_forward
)
1120 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1122 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1123 int pi
= exported_symbols
[ei
];
1127 /* xgettext:c-format */
1128 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1129 pe_def_file
->exports
[i
].ordinal
,
1130 pe_def_file
->exports
[i
].name
,
1131 pe_def_file
->exports
[pi
].name
);
1133 exported_symbols
[ei
] = i
;
1135 if (pe_def_file
->exports
[i
].its_name
)
1136 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1138 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1141 /* Reserve space for the forward name. */
1142 if (pe_def_file
->exports
[i
].flag_forward
)
1144 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1148 next_ordinal
= min_ordinal
;
1149 for (i
= 0; i
< NE
; i
++)
1150 if ((exported_symbol_sections
[i
]
1151 || pe_def_file
->exports
[i
].flag_forward
)
1152 && pe_def_file
->exports
[i
].ordinal
== -1)
1154 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1157 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1158 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1161 /* PR 12969: Check for more than 1^16 ordinals. */
1162 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1163 /* xgettext:c-format */
1164 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1165 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1167 /* OK, now we can allocate some memory. */
1168 edata_sz
= (40 /* directory */
1169 + 4 * export_table_size
/* addresses */
1170 + 4 * count_exported_byname
/* name ptrs */
1171 + 2 * count_exported_byname
/* ordinals */
1172 + name_table_size
+ strlen (dll_filename
) + 1);
1175 /* Fill the exported symbol offsets. The preliminary work has already
1176 been done in process_def_file_and_drectve(). */
1179 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1182 struct bfd_link_hash_entry
*blhe
;
1184 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1188 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1189 if (pe_details
->underscored
1190 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1193 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1196 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1198 blhe
= bfd_link_hash_lookup (info
->hash
,
1200 false, false, true);
1202 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1203 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1210 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1213 unsigned char *edirectory
;
1214 unsigned char *eaddresses
;
1215 unsigned char *enameptrs
;
1216 unsigned char *eordinals
;
1219 edata_d
= xmalloc (edata_sz
);
1221 /* Note use of array pointer math here. */
1222 edirectory
= edata_d
;
1223 eaddresses
= edirectory
+ 40;
1224 enameptrs
= eaddresses
+ 4 * export_table_size
;
1225 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1226 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1228 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1229 + edata_s->output_section->vma - image_base)
1231 memset (edata_d
, 0, edata_sz
);
1233 if (pe_data (abfd
)->timestamp
== -1)
1234 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1236 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, edata_d
+ 4);
1238 if (pe_def_file
->version_major
!= -1)
1240 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1241 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1244 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1245 strcpy (enamestr
, dll_filename
);
1246 enamestr
+= strlen (enamestr
) + 1;
1247 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1248 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1249 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1250 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1251 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1252 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1254 fill_exported_offsets (abfd
, info
);
1256 /* Ok, now for the filling in part.
1257 Scan alphabetically - ie the ordering in the exports[] table,
1258 rather than by ordinal - the ordering in the exported_symbol[]
1259 table. See dlltool.c and:
1260 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1261 for more information. */
1263 for (s
= 0; s
< NE
; s
++)
1265 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1266 if (pe_def_file
->exports
[s
].ordinal
!= -1
1267 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1269 int ord
= pe_def_file
->exports
[s
].ordinal
;
1271 if (pe_def_file
->exports
[s
].flag_forward
)
1273 bfd_put_32 (abfd
, ERVA (enamestr
),
1274 eaddresses
+ 4 * (ord
- min_ordinal
));
1276 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1277 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1281 bfd_vma srva
= (exported_symbol_offsets
[s
]
1282 + ssec
->output_section
->vma
1283 + ssec
->output_offset
);
1285 bfd_put_32 (abfd
, srva
- image_base
,
1286 eaddresses
+ 4 * (ord
- min_ordinal
));
1289 if (!pe_def_file
->exports
[s
].flag_noname
)
1291 char *ename
= pe_def_file
->exports
[s
].name
;
1292 if (pe_def_file
->exports
[s
].its_name
)
1293 ename
= pe_def_file
->exports
[s
].its_name
;
1295 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1297 strcpy (enamestr
, ename
);
1298 enamestr
+= strlen (enamestr
) + 1;
1299 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1301 pe_def_file
->exports
[s
].hint
= hint
++;
1308 static struct bfd_section
*current_sec
;
1311 pe_walk_relocs (struct bfd_link_info
*info
,
1313 const char *symname
,
1314 struct bfd_hash_table
*import_hash
,
1315 void (*cb
) (arelent
*, asection
*, char *, const char *))
1320 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1324 if (!bfd_generic_link_read_symbols (b
))
1326 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1330 symbols
= bfd_get_outsymbols (b
);
1332 for (s
= b
->sections
; s
; s
= s
->next
)
1335 int relsize
, nrelocs
, i
;
1336 int flags
= bfd_section_flags (s
);
1338 /* Skip discarded linkonce sections. */
1339 if (flags
& SEC_LINK_ONCE
1340 && s
->output_section
== bfd_abs_section_ptr
)
1345 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1346 relocs
= xmalloc (relsize
);
1347 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1349 for (i
= 0; i
< nrelocs
; i
++)
1351 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1353 /* Warning: the callback needs to be passed NAME directly. */
1356 if (bfd_hash_lookup (import_hash
, sym
->name
, false, false))
1358 strcpy (name
, sym
->name
);
1359 cb (relocs
[i
], s
, name
, symname
);
1364 if (strcmp (name
, sym
->name
) == 0)
1365 cb (relocs
[i
], s
, name
, symname
);
1371 /* Warning: the allocated symbols are remembered in BFD and reused
1372 later, so don't free them! */
1373 /* free (symbols); */
1379 pe_find_data_imports (const char *symhead
,
1380 void (*cb
) (arelent
*, asection
*, char *, const char *))
1382 struct bfd_link_hash_entry
*undef
;
1383 const size_t headlen
= strlen (symhead
);
1386 struct bfd_hash_table
*import_hash
;
1388 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1389 if (undef
->type
== bfd_link_hash_undefined
)
1391 size_t len
= strlen (undef
->root
.string
);
1398 /* For the pseudo-relocation support version 2, we can collect the symbols
1399 that are subject to auto-import and adjust the relocations en masse. */
1400 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1403 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1404 if (!bfd_hash_table_init (import_hash
,
1406 sizeof (struct bfd_hash_entry
)))
1407 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1412 /* We are being a bit cunning here. The buffer will have space for
1413 prefixes at the beginning. The prefix is modified here and in a
1414 number of functions called from this function. */
1415 #define PREFIX_LEN 32
1416 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1417 name
= buf
+ PREFIX_LEN
;
1419 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1420 if (undef
->type
== bfd_link_hash_undefined
)
1422 struct bfd_link_hash_entry
*sym
;
1425 if (pe_dll_extra_pe_debug
)
1426 printf ("%s:%s\n", __func__
, undef
->root
.string
);
1428 strcpy (name
, undef
->root
.string
);
1429 impname
= name
- (sizeof "__imp_" - 1);
1430 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1432 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1434 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1437 bfd_hash_lookup (import_hash
, undef
->root
.string
, true, false);
1440 bfd
*b
= sym
->u
.def
.section
->owner
;
1441 const char *symname
= NULL
;
1445 if (!bfd_generic_link_read_symbols (b
))
1447 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1451 symbols
= bfd_get_outsymbols (b
);
1452 nsyms
= bfd_get_symcount (b
);
1454 for (i
= 0; i
< nsyms
; i
++)
1455 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1457 if (pe_dll_extra_pe_debug
)
1458 printf ("->%s\n", symbols
[i
]->name
);
1460 symname
= symbols
[i
]->name
+ headlen
;
1464 /* If the symobl isn't part of an import table, there is no
1465 point in building a fixup, this would give rise to link
1466 errors for mangled symbols instead of the original one. */
1468 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1473 /* Let's differentiate it somehow from defined. */
1474 undef
->type
= bfd_link_hash_defweak
;
1475 undef
->u
.def
.value
= sym
->u
.def
.value
;
1476 undef
->u
.def
.section
= sym
->u
.def
.section
;
1478 /* We replace the original name with the __imp_ prefixed one, this
1479 1) may trash memory 2) leads to duplicate symbols. But this is
1480 better than having a misleading name that can confuse GDB. */
1481 undef
->root
.string
= sym
->root
.string
;
1483 if (link_info
.pei386_auto_import
== -1)
1485 static bool warned
= false;
1487 info_msg (_("Info: resolving %s by linking to %s "
1488 "(auto-import)\n"), name
, impname
);
1490 /* PR linker/4844. */
1493 einfo (_("%P: warning: auto-importing has been activated "
1494 "without --enable-auto-import specified on the "
1495 "command line; this should work unless it "
1496 "involves constant data structures referencing "
1497 "symbols from auto-imported DLLs\n"));
1504 /* If we have the import hash table, walk the relocations only once. */
1507 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1508 bfd_hash_table_free (import_hash
);
1515 /* Gather all the relocations and build the .reloc section. */
1518 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1520 /* For .reloc stuff. */
1521 reloc_data_type
*reloc_data
;
1522 int total_relocs
= 0;
1524 bfd_vma sec_page
= (bfd_vma
) -1;
1527 struct bfd_section
*s
;
1529 if (reloc_s
== NULL
|| reloc_s
->output_section
== bfd_abs_section_ptr
)
1532 /* Set an upper bound for the total number of relocations we will have to generate. */
1534 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1535 for (s
= b
->sections
; s
; s
= s
->next
)
1536 total_relocs
+= s
->reloc_count
;
1538 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1541 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1544 int relsize
, nrelocs
;
1546 for (s
= b
->sections
; s
; s
= s
->next
)
1551 /* If the section is not going to be output, then ignore it. */
1552 if (s
->output_section
== NULL
)
1554 /* PR 29998: LTO processing can elminate whole code sections,
1555 but it sets the output section to NULL rather than *ABS*.
1556 Fix that here, then ignore the section. */
1557 s
->output_section
= bfd_abs_section_ptr
;
1561 /* I don't know why there would be a reloc for these, but I've
1562 seen it happen - DJ */
1563 if (s
->output_section
== bfd_abs_section_ptr
)
1566 /* If it's not loaded, we don't need to relocate it this way. */
1567 if (!(s
->output_section
->flags
& SEC_LOAD
))
1570 /* This happens when linking with --just-symbols=<file>
1571 so do not generate an error. */
1572 if (s
->output_section
->vma
== 0)
1575 sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1577 if (!bfd_generic_link_read_symbols (b
))
1579 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1583 symbols
= bfd_get_outsymbols (b
);
1584 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1585 relocs
= xmalloc (relsize
);
1586 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1588 for (i
= 0; i
< nrelocs
; i
++)
1590 if (pe_dll_extra_pe_debug
)
1592 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1593 printf ("rel: %s\n", sym
->name
);
1595 if (!relocs
[i
]->howto
->pc_relative
1596 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1598 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1599 const struct bfd_link_hash_entry
*blhe
1600 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1601 false, false, false);
1603 /* Don't create relocs for undefined weak symbols. */
1604 if (sym
->flags
== BSF_WEAK
)
1606 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1608 /* Check aux sym and see if it is defined or not. */
1609 struct coff_link_hash_entry
*h
, *h2
;
1610 h
= (struct coff_link_hash_entry
*)blhe
;
1611 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1613 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1614 [h
->aux
->x_sym
.x_tagndx
.l
];
1615 /* We don't want a base reloc if the aux sym is not
1616 found, undefined, or if it is the constant ABS
1617 zero default value. (We broaden that slightly by
1618 not testing the value, just the section; there's
1619 no reason we'd want a reference to any absolute
1620 address to get relocated during rebasing). */
1621 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1622 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1625 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1628 /* Nor for Dwarf FDE references to discarded sections. */
1629 else if (bfd_is_abs_section (sym
->section
->output_section
))
1631 /* We only ignore relocs from .eh_frame sections, as
1632 they are discarded by the final link rather than
1633 resolved against the kept section. */
1634 if (!strcmp (s
->name
, ".eh_frame"))
1637 /* Nor for absolute symbols. */
1638 else if (blhe
&& ldexp_is_final_sym_absolute (blhe
)
1639 && (!blhe
->linker_def
1640 || (strcmp (sym
->name
, "__image_base__")
1641 && strcmp (sym
->name
, U ("__ImageBase")))))
1644 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1645 reloc_data
[total_relocs
].idx
= total_relocs
;
1647 /* Since we're only about to determine .reloc's size,
1648 subsequent output section VMA calculations will shift up
1649 sections at this or higher addresses. Relocations for
1650 such sections would hence end up not being correct. */
1651 if (reloc_data
[total_relocs
].vma
1652 >= reloc_s
->output_section
->vma
)
1653 einfo (_("%P: base relocation for section `%s' above "
1654 ".reloc section\n"), s
->output_section
->name
);
1656 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1658 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1659 relocs
[i
]->howto
->rightshift
)
1662 case BITS_AND_SHIFT (64, 0):
1663 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_DIR64
;
1667 case BITS_AND_SHIFT (32, 0):
1668 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_HIGHLOW
;
1671 case BITS_AND_SHIFT (16, 0):
1672 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_LOW
;
1675 case BITS_AND_SHIFT (16, 16):
1676 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_HIGHADJ
;
1677 /* FIXME: we can't know the symbol's right value
1678 yet, but we probably can safely assume that
1679 CE will relocate us in 64k blocks, so leaving
1681 reloc_data
[total_relocs
].extra
= 0;
1684 case BITS_AND_SHIFT (26, 2):
1685 reloc_data
[total_relocs
].type
=
1686 IMAGE_REL_BASED_ARM_MOV32
;
1689 case BITS_AND_SHIFT (24, 2):
1690 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1691 Those ARM_xxx definitions should go in proper
1693 if (relocs
[i
]->howto
->type
== 0
1694 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1695 || relocs
[i
]->howto
->type
== 5)
1696 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1697 that has already been fully processed during a
1698 previous link stage, so ignore it here. */
1702 /* xgettext:c-format */
1703 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1704 relocs
[i
]->howto
->bitsize
);
1711 /* Warning: the allocated symbols are remembered in BFD and
1712 reused later, so don't free them! */
1716 /* This can happen for example when LTO has eliminated all code. */
1717 if (total_relocs
== 0)
1720 /* At this point, we have total_relocs relocation addresses in
1721 reloc_addresses, which are all suitable for the .reloc section.
1722 We must now create the new sections. */
1723 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1725 for (i
= 0; i
< total_relocs
; i
++)
1727 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1729 if (this_page
!= sec_page
)
1731 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1733 sec_page
= this_page
;
1738 if (reloc_data
[i
].type
== IMAGE_REL_BASED_HIGHADJ
)
1742 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1743 reloc_d
= xmalloc (reloc_sz
);
1745 page_ptr
= sec_page
= (bfd_vma
) -1;
1748 for (i
= 0; i
< total_relocs
; i
++)
1750 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1751 bfd_vma this_page
= (rva
& ~0xfff);
1753 if (this_page
!= sec_page
)
1755 while (reloc_sz
& 3)
1756 reloc_d
[reloc_sz
++] = 0;
1758 if (page_ptr
!= (bfd_vma
) -1)
1759 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1761 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1762 page_ptr
= reloc_sz
;
1764 sec_page
= this_page
;
1767 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1768 reloc_d
+ reloc_sz
);
1771 if (reloc_data
[i
].type
== IMAGE_REL_BASED_HIGHADJ
)
1773 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1778 while (reloc_sz
& 3)
1779 reloc_d
[reloc_sz
++] = 0;
1781 if (page_ptr
!= (bfd_vma
) -1)
1782 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1785 /* Given the exiting def_file structure, print out a .DEF file that
1786 corresponds to it. */
1789 quoteput (char *s
, FILE *f
, int needs_quotes
)
1793 for (cp
= s
; *cp
; cp
++)
1808 if (*s
== '"' || *s
== '\\')
1822 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1825 FILE *out
= fopen (pe_out_def_filename
, "w");
1828 /* xgettext:c-format */
1829 einfo (_("%P: can't open output def file %s\n"),
1830 pe_out_def_filename
);
1834 if (pe_def_file
->name
)
1836 if (pe_def_file
->is_dll
)
1837 fprintf (out
, "LIBRARY ");
1839 fprintf (out
, "NAME ");
1841 quoteput (pe_def_file
->name
, out
, 1);
1843 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1844 fprintf (out
, " BASE=0x%" PRIx64
,
1845 (uint64_t) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
);
1846 fprintf (out
, "\n");
1849 if (pe_def_file
->description
)
1851 fprintf (out
, "DESCRIPTION ");
1852 quoteput (pe_def_file
->description
, out
, 1);
1853 fprintf (out
, "\n");
1856 if (pe_def_file
->version_minor
!= -1)
1857 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1858 pe_def_file
->version_minor
);
1859 else if (pe_def_file
->version_major
!= -1)
1860 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1862 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1863 fprintf (out
, "\n");
1865 if (pe_def_file
->stack_commit
!= -1)
1866 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1867 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1868 else if (pe_def_file
->stack_reserve
!= -1)
1869 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1871 if (pe_def_file
->heap_commit
!= -1)
1872 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1873 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1874 else if (pe_def_file
->heap_reserve
!= -1)
1875 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1877 if (pe_def_file
->num_section_defs
> 0)
1879 fprintf (out
, "\nSECTIONS\n\n");
1881 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1884 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1886 if (pe_def_file
->section_defs
[i
].class)
1888 fprintf (out
, " CLASS ");
1889 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1892 if (pe_def_file
->section_defs
[i
].flag_read
)
1893 fprintf (out
, " READ");
1895 if (pe_def_file
->section_defs
[i
].flag_write
)
1896 fprintf (out
, " WRITE");
1898 if (pe_def_file
->section_defs
[i
].flag_execute
)
1899 fprintf (out
, " EXECUTE");
1901 if (pe_def_file
->section_defs
[i
].flag_shared
)
1902 fprintf (out
, " SHARED");
1904 fprintf (out
, "\n");
1908 if (pe_def_file
->num_exports
> 0)
1910 fprintf (out
, "EXPORTS\n");
1912 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1914 def_file_export
*e
= pe_def_file
->exports
+ i
;
1916 quoteput (e
->name
, out
, 0);
1918 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1920 fprintf (out
, " = ");
1921 quoteput (e
->internal_name
, out
, 0);
1924 if (e
->ordinal
!= -1)
1925 fprintf (out
, " @%d", e
->ordinal
);
1927 if (e
->flag_private
)
1928 fprintf (out
, " PRIVATE");
1930 if (e
->flag_constant
)
1931 fprintf (out
, " CONSTANT");
1934 fprintf (out
, " NONAME");
1937 fprintf (out
, " DATA");
1939 fprintf (out
, "\n");
1943 if (pe_def_file
->num_imports
> 0)
1945 fprintf (out
, "\nIMPORTS\n\n");
1947 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1949 def_file_import
*im
= pe_def_file
->imports
+ i
;
1952 if (im
->internal_name
1953 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1955 quoteput (im
->internal_name
, out
, 0);
1956 fprintf (out
, " = ");
1959 quoteput (im
->module
->name
, out
, 0);
1963 quoteput (im
->name
, out
, 0);
1965 fprintf (out
, "%d", im
->ordinal
);
1969 fprintf (out
, " == ");
1970 quoteput (im
->its_name
, out
, 0);
1973 fprintf (out
, "\n");
1978 fprintf (out
, _("; no contents available\n"));
1980 if (fclose (out
) == EOF
)
1981 /* xgettext:c-format */
1982 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1985 /* Generate the import library. */
1987 static asymbol
**symtab
;
1990 static char *dll_symname
;
1992 #define UNDSEC bfd_und_section_ptr
1995 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
2000 sec
= bfd_make_section_old_way (abfd
, name
);
2001 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
2002 bfd_set_section_alignment (sec
, align
);
2003 /* Remember to undo this before trying to link internally! */
2004 sec
->output_section
= sec
;
2006 sym
= bfd_make_empty_symbol (abfd
);
2007 symtab
[symptr
++] = sym
;
2008 sym
->name
= sec
->name
;
2010 sym
->flags
= BSF_LOCAL
;
2017 quick_symbol (bfd
*abfd
,
2026 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
2031 sym
= bfd_make_empty_symbol (abfd
);
2036 symtab
[symptr
++] = sym
;
2039 static arelent
*reltab
= 0;
2040 static int relcount
= 0, relsize
= 0;
2043 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2045 if (relcount
>= relsize
- 1)
2049 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2051 reltab
= xmalloc (relsize
* sizeof (arelent
));
2053 reltab
[relcount
].address
= address
;
2054 reltab
[relcount
].addend
= 0;
2055 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2056 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2061 save_relocs (asection
*sec
)
2065 sec
->relocation
= reltab
;
2066 sec
->reloc_count
= relcount
;
2067 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2068 for (i
= 0; i
< relcount
; i
++)
2069 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2070 sec
->orelocation
[relcount
] = 0;
2071 sec
->flags
|= SEC_RELOC
;
2073 relcount
= relsize
= 0;
2076 /* .section .idata$2
2077 .global __head_my_dll
2094 make_head (bfd
*parent
)
2096 asection
*id2
, *id5
, *id4
;
2097 unsigned char *d2
, *d5
, *d4
;
2101 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2102 /* In theory we should return NULL here at let our caller decide what to
2103 do. But currently the return value is not checked, just used, and
2104 besides, this condition only happens when the system has run out of
2105 memory. So just give up. */
2106 exit (EXIT_FAILURE
);
2109 abfd
= bfd_create (oname
, parent
);
2110 bfd_find_target (pe_details
->object_target
, abfd
);
2111 bfd_make_writable (abfd
);
2113 bfd_set_format (abfd
, bfd_object
);
2114 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2117 symtab
= xmalloc (6 * sizeof (asymbol
*));
2118 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2119 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2120 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2121 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2122 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2124 /* OK, pay attention here. I got confused myself looking back at
2125 it. We create a four-byte section to mark the beginning of the
2126 list, and we include an offset of 4 in the section, so that the
2127 pointer to the list points to the *end* of this section, which is
2128 the start of the list of sections from other objects. */
2130 bfd_set_section_size (id2
, 20);
2134 if (pe_use_nul_prefixed_import_tables
)
2135 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2136 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2137 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2138 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2141 if (pe_use_nul_prefixed_import_tables
)
2142 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2144 bfd_set_section_size (id5
, 0);
2145 d5
= xmalloc (PE_IDATA5_SIZE
);
2147 memset (d5
, 0, PE_IDATA5_SIZE
);
2148 if (pe_use_nul_prefixed_import_tables
)
2149 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2151 bfd_set_section_size (id4
, 0);
2152 d4
= xmalloc (PE_IDATA4_SIZE
);
2154 memset (d4
, 0, PE_IDATA4_SIZE
);
2156 bfd_set_symtab (abfd
, symtab
, symptr
);
2158 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2159 if (pe_use_nul_prefixed_import_tables
)
2161 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2162 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2166 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2167 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2170 bfd_make_readable (abfd
);
2174 /* .section .idata$4
2181 .global __my_dll_iname
2186 make_tail (bfd
*parent
)
2188 asection
*id4
, *id5
, *id7
;
2189 unsigned char *d4
, *d5
, *d7
;
2194 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2195 /* In theory we should return NULL here at let our caller decide what to
2196 do. But currently the return value is not checked, just used, and
2197 besides, this condition only happens when the system has run out of
2198 memory. So just give up. */
2199 exit (EXIT_FAILURE
);
2202 abfd
= bfd_create (oname
, parent
);
2203 bfd_find_target (pe_details
->object_target
, abfd
);
2204 bfd_make_writable (abfd
);
2206 bfd_set_format (abfd
, bfd_object
);
2207 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2210 symtab
= xmalloc (5 * sizeof (asymbol
*));
2211 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2212 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2213 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2214 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2216 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2217 d4
= xmalloc (PE_IDATA4_SIZE
);
2219 memset (d4
, 0, PE_IDATA4_SIZE
);
2221 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2222 d5
= xmalloc (PE_IDATA5_SIZE
);
2224 memset (d5
, 0, PE_IDATA5_SIZE
);
2226 len
= strlen (dll_filename
) + 1;
2229 bfd_set_section_size (id7
, len
);
2232 strcpy ((char *) d7
, dll_filename
);
2233 /* If len was odd, the above
2234 strcpy leaves behind an undefined byte. That is harmless,
2235 but we set it to 0 just so the binary dumps are pretty. */
2238 bfd_set_symtab (abfd
, symtab
, symptr
);
2240 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2241 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2242 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2244 bfd_make_readable (abfd
);
2250 .global ___imp_function
2251 .global __imp__function
2253 jmp *__imp__function:
2267 .asciz "function" xlate? (add underscore, kill at) */
2269 static const unsigned char jmp_ix86_bytes
[] =
2271 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2274 static const unsigned char jmp_aarch64_bytes
[] =
2276 0x10, 0x00, 0x00, 0x90, /* adrp x16, 0 */
2277 0x10, 0x02, 0x00, 0x91, /* add x16, x16, #0x0 */
2278 0x10, 0x02, 0x40, 0xf9, /* ldr x16, [x16] */
2279 0x00, 0x02, 0x1f, 0xd6 /* br x16 */
2287 .dw __imp_function */
2289 static const unsigned char jmp_sh_bytes
[] =
2291 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2295 lui $t0,<high:__imp_function>
2296 lw $t0,<low:__imp_function>
2300 static const unsigned char jmp_mips_bytes
[] =
2302 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2303 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2306 static const unsigned char jmp_arm_bytes
[] =
2308 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2309 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2315 make_one (def_file_export
*exp
, bfd
*parent
, bool include_jmp_stub
)
2317 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2318 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2322 const unsigned char *jmp_bytes
= NULL
;
2323 int jmp_byte_count
= 0;
2325 /* Include the jump stub section only if it is needed. A jump
2326 stub is needed if the symbol being imported <sym> is a function
2327 symbol and there is at least one undefined reference to that
2328 symbol. In other words, if all the import references to <sym> are
2329 explicitly through _declspec(dllimport) then the jump stub is not
2331 if (include_jmp_stub
)
2333 switch (pe_details
->pe_arch
)
2336 jmp_bytes
= jmp_ix86_bytes
;
2337 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2340 jmp_bytes
= jmp_sh_bytes
;
2341 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2344 jmp_bytes
= jmp_mips_bytes
;
2345 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2348 case PE_ARCH_arm_wince
:
2349 jmp_bytes
= jmp_arm_bytes
;
2350 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2352 case PE_ARCH_aarch64
:
2353 jmp_bytes
= jmp_aarch64_bytes
;
2354 jmp_byte_count
= sizeof (jmp_aarch64_bytes
);
2361 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2362 /* In theory we should return NULL here at let our caller decide what to
2363 do. But currently the return value is not checked, just used, and
2364 besides, this condition only happens when the system has run out of
2365 memory. So just give up. */
2366 exit (EXIT_FAILURE
);
2369 abfd
= bfd_create (oname
, parent
);
2370 bfd_find_target (pe_details
->object_target
, abfd
);
2371 bfd_make_writable (abfd
);
2373 bfd_set_format (abfd
, bfd_object
);
2374 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2377 symtab
= xmalloc (12 * sizeof (asymbol
*));
2379 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2380 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2381 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2382 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2383 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2385 if (*exp
->internal_name
== '@')
2387 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2389 if (include_jmp_stub
)
2390 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2391 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2393 /* Fastcall applies only to functions,
2394 so no need for auto-import symbol. */
2398 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2400 if (include_jmp_stub
)
2401 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2403 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2405 /* Symbol to reference ord/name of imported
2406 data symbol, used to implement auto-import. */
2408 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2411 if (pe_dll_compat_implib
)
2412 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2415 if (include_jmp_stub
)
2417 bfd_set_section_size (tx
, jmp_byte_count
);
2418 td
= xmalloc (jmp_byte_count
);
2420 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2422 switch (pe_details
->pe_arch
)
2426 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2428 /* Mark this object as SAFESEH compatible. */
2429 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2431 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2435 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2438 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2439 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2440 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2443 case PE_ARCH_arm_wince
:
2444 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2446 case PE_ARCH_aarch64
:
2447 quick_reloc (abfd
, 0, BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL
, 2);
2448 quick_reloc (abfd
, 4, BFD_RELOC_AARCH64_ADD_LO12
, 2);
2456 bfd_set_section_size (tx
, 0);
2458 bfd_set_section_size (id7
, 4);
2462 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2465 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2466 d5
= xmalloc (PE_IDATA5_SIZE
);
2468 memset (d5
, 0, PE_IDATA5_SIZE
);
2470 if (exp
->flag_noname
)
2472 d5
[0] = exp
->ordinal
;
2473 d5
[1] = exp
->ordinal
>> 8;
2474 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2478 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2482 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2483 d4
= xmalloc (PE_IDATA4_SIZE
);
2485 memset (d4
, 0, PE_IDATA4_SIZE
);
2487 if (exp
->flag_noname
)
2489 d4
[0] = exp
->ordinal
;
2490 d4
[1] = exp
->ordinal
>> 8;
2491 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2495 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2499 if (exp
->flag_noname
)
2502 bfd_set_section_size (id6
, 0);
2508 /* { short, asciz } */
2510 len
= 2 + strlen (exp
->its_name
) + 1;
2512 len
= 2 + strlen (exp
->name
) + 1;
2515 bfd_set_section_size (id6
, len
);
2518 memset (d6
, 0, len
);
2520 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2521 contains an invalid value (-1). */
2522 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2527 strcpy ((char*) d6
+ 2, exp
->its_name
);
2529 strcpy ((char *) d6
+ 2, exp
->name
);
2532 bfd_set_symtab (abfd
, symtab
, symptr
);
2534 if (include_jmp_stub
)
2535 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2536 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2537 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2538 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2539 if (!exp
->flag_noname
)
2540 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2542 bfd_make_readable (abfd
);
2547 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2549 /* Name thunks go to idata$4. */
2555 if (asprintf (&oname
, "%s_nmth%06d.o", dll_symname
, tmp_seq
) < 4)
2556 /* In theory we should return NULL here at let our caller decide what to
2557 do. But currently the return value is not checked, just used, and
2558 besides, this condition only happens when the system has run out of
2559 memory. So just give up. */
2560 exit (EXIT_FAILURE
);
2563 abfd
= bfd_create (oname
, parent
);
2564 bfd_find_target (pe_details
->object_target
, abfd
);
2565 bfd_make_writable (abfd
);
2567 bfd_set_format (abfd
, bfd_object
);
2568 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2571 symtab
= xmalloc (3 * sizeof (asymbol
*));
2572 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2573 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2574 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2576 /* We need space for the real thunk and for the null terminator. */
2577 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2578 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2580 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2581 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2584 bfd_set_symtab (abfd
, symtab
, symptr
);
2586 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2588 bfd_make_readable (abfd
);
2593 make_import_fixup_mark (arelent
*rel
, char *name
)
2595 /* We convert reloc to symbol, for later reference. */
2596 static unsigned int counter
;
2597 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2598 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2599 struct bfd_link_hash_entry
*bh
;
2600 char *fixup_name
, buf
[256];
2603 /* "name" buffer has space before the symbol name for prefixes. */
2604 sprintf (buf
, "__fu%d_", counter
++);
2605 prefix_len
= strlen (buf
);
2606 fixup_name
= name
- prefix_len
;
2607 memcpy (fixup_name
, buf
, prefix_len
);
2610 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2611 current_sec
, /* sym->section, */
2612 rel
->address
, NULL
, true, false, &bh
);
2614 return bh
->root
.string
;
2617 /* .section .idata$2
2618 .rva __nm_thnk_SYM (singleton thunk with name of func)
2621 .rva __my_dll_iname (name of dll)
2622 .rva __fuNN_SYM (pointer to reference (address) in text) */
2625 make_import_fixup_entry (const char *name
,
2626 const char *fixup_name
,
2627 const char *symname
,
2635 if (asprintf (&oname
, "%s_fu%06d.o", dll_symname
, tmp_seq
) < 4)
2636 /* In theory we should return NULL here at let our caller decide what to
2637 do. But currently the return value is not checked, just used, and
2638 besides, this condition only happens when the system has run out of
2639 memory. So just give up. */
2640 exit (EXIT_FAILURE
);
2643 abfd
= bfd_create (oname
, parent
);
2644 bfd_find_target (pe_details
->object_target
, abfd
);
2645 bfd_make_writable (abfd
);
2647 bfd_set_format (abfd
, bfd_object
);
2648 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2651 symtab
= xmalloc (6 * sizeof (asymbol
*));
2652 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2654 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2655 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2656 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2658 bfd_set_section_size (id2
, 20);
2663 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2664 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2665 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2668 bfd_set_symtab (abfd
, symtab
, symptr
);
2670 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2672 bfd_make_readable (abfd
);
2676 /* .section .rdata_runtime_pseudo_reloc
2678 .rva __fuNN_SYM (pointer to reference (address) in text) */
2681 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2682 const char *fixup_name
,
2683 bfd_vma addend ATTRIBUTE_UNUSED
,
2688 unsigned char *rt_rel_d
;
2693 if (asprintf (&oname
, "%s_rtr%06d.o", dll_symname
, tmp_seq
) < 4)
2694 /* In theory we should return NULL here at let our caller decide what to
2695 do. But currently the return value is not checked, just used, and
2696 besides, this condition only happens when the system has run out of
2697 memory. So just give up. */
2698 exit (EXIT_FAILURE
);
2701 abfd
= bfd_create (oname
, parent
);
2702 bfd_find_target (pe_details
->object_target
, abfd
);
2703 bfd_make_writable (abfd
);
2705 bfd_set_format (abfd
, bfd_object
);
2706 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2708 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2710 if (runtime_pseudp_reloc_v2_init
)
2711 size
= 3 * sizeof (asymbol
*);
2713 size
= 6 * sizeof (asymbol
*);
2716 size
= 2 * sizeof (asymbol
*);
2719 symtab
= xmalloc (size
);
2722 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2724 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2726 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2729 if (!runtime_pseudp_reloc_v2_init
)
2732 runtime_pseudp_reloc_v2_init
= true;
2735 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2737 bfd_set_section_size (rt_rel
, size
);
2738 rt_rel_d
= xmalloc (size
);
2739 rt_rel
->contents
= rt_rel_d
;
2740 memset (rt_rel_d
, 0, size
);
2741 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2742 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2743 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2745 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2746 save_relocs (rt_rel
);
2748 bfd_set_symtab (abfd
, symtab
, symptr
);
2750 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2754 bfd_set_section_size (rt_rel
, 8);
2755 rt_rel_d
= xmalloc (8);
2756 rt_rel
->contents
= rt_rel_d
;
2757 memset (rt_rel_d
, 0, 8);
2759 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2760 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2762 save_relocs (rt_rel
);
2764 bfd_set_symtab (abfd
, symtab
, symptr
);
2766 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2769 bfd_make_readable (abfd
);
2774 .rva __pei386_runtime_relocator */
2777 pe_create_runtime_relocator_reference (bfd
*parent
)
2779 asection
*extern_rt_rel
;
2780 unsigned char *extern_rt_rel_d
;
2784 if (asprintf (&oname
, "%s_ertr%06d.o", dll_symname
, tmp_seq
) < 4)
2785 /* In theory we should return NULL here at let our caller decide what to
2786 do. But currently the return value is not checked, just used, and
2787 besides, this condition only happens when the system has run out of
2788 memory. So just give up. */
2789 exit (EXIT_FAILURE
);
2792 abfd
= bfd_create (oname
, parent
);
2793 bfd_find_target (pe_details
->object_target
, abfd
);
2794 bfd_make_writable (abfd
);
2796 bfd_set_format (abfd
, bfd_object
);
2797 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2800 symtab
= xmalloc (2 * sizeof (asymbol
*));
2801 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2803 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2806 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2807 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2808 extern_rt_rel
->contents
= extern_rt_rel_d
;
2810 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2811 save_relocs (extern_rt_rel
);
2813 bfd_set_symtab (abfd
, symtab
, symptr
);
2815 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2817 bfd_make_readable (abfd
);
2822 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2823 const char *symname
)
2825 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2828 /* This is the original implementation of the auto-import feature, which
2829 primarily relied on the OS loader to patch things up with some help
2830 from the pseudo-relocator to overcome the main limitation. See the
2831 comment at the beginning of the file for an overview of the feature. */
2832 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2834 struct bfd_link_hash_entry
*name_thunk_sym
;
2835 /* name buffer is allocated with space at beginning for prefixes. */
2836 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2837 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2838 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2840 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2842 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2843 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2845 /* If we ever use autoimport, we have to cast text section writable. */
2846 config
.text_read_only
= false;
2847 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2850 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2852 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2853 link_info
.output_bfd
);
2854 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2858 /* In the original implementation, the pseudo-relocator was only used when
2859 the addend was not null. In the new implementation, the OS loader is
2860 completely bypassed and the pseudo-relocator does the entire work. */
2861 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2862 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2864 if (pe_dll_extra_pe_debug
)
2865 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2866 fixup_name
, (int) addend
);
2868 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
,
2869 rel
->howto
->bitsize
,
2870 link_info
.output_bfd
);
2871 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2873 if (runtime_pseudo_relocs_created
++ == 0)
2875 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2876 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2880 else if (addend
!= 0)
2881 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2882 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2886 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2895 unlink_if_ordinary (impfilename
);
2897 outarch
= bfd_openw (impfilename
, 0);
2901 /* xgettext:c-format */
2902 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2907 /* xgettext:c-format */
2908 info_msg (_("Creating library file: %s\n"), impfilename
);
2910 bfd_set_format (outarch
, bfd_archive
);
2911 outarch
->has_armap
= 1;
2913 /* Work out a reasonable size of things to put onto one line. */
2914 ar_head
= make_head (outarch
);
2916 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2917 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2919 /* Iterate the exclude list. */
2920 struct exclude_list_struct
*ex
;
2922 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2924 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2926 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2928 /* If it matched, we must open a fresh BFD for it (the original
2929 input BFD is still needed for the DLL's final link) and add
2930 it into the archive member chain. */
2933 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2934 ? bfd_get_filename (ibfd
->my_archive
)
2935 : bfd_get_filename (ibfd
), NULL
);
2938 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2941 if (ibfd
->my_archive
)
2943 /* Must now iterate through archive until we find the
2944 required member. A minor shame that we'll open the
2945 archive once per member that we require from it, and
2946 leak those archive bfds rather than reuse them. */
2947 bfd
*arbfd
= newbfd
;
2948 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2950 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2951 bfd_get_filename (ibfd
->my_archive
),
2952 bfd_get_filename (ibfd
));
2956 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2958 if (filename_cmp (bfd_get_filename (newbfd
),
2959 bfd_get_filename (ibfd
)) == 0)
2964 einfo (_("%X%P: %s(%s): can't find member in archive"),
2965 bfd_get_filename (ibfd
->my_archive
),
2966 bfd_get_filename (ibfd
));
2970 newbfd
->archive_next
= head
;
2975 for (i
= 0; i
< def
->num_exports
; i
++)
2977 /* The import library doesn't know about the internal name. */
2978 char *internal
= def
->exports
[i
].internal_name
;
2981 /* Don't add PRIVATE entries to import lib. */
2982 if (pe_def_file
->exports
[i
].flag_private
)
2985 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2987 /* PR 19803: If a symbol has been discard due to garbage
2988 collection then do not create any exports for it. */
2990 struct coff_link_hash_entry
*h
;
2992 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2993 false, false, false);
2995 /* If the symbol is hidden and undefined then it
2996 has been swept up by garbage collection. */
2997 && h
->symbol_class
== C_HIDDEN
2998 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
3001 /* If necessary, check with an underscore prefix as well. */
3002 if (pe_details
->underscored
&& internal
[0] != '@')
3006 name
= xmalloc (strlen (internal
) + 2);
3007 sprintf (name
, "_%s", internal
);
3009 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
3010 false, false, false);
3014 /* If the symbol is hidden and undefined then it
3015 has been swept up by garbage collection. */
3016 && h
->symbol_class
== C_HIDDEN
3017 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
3022 n
= make_one (def
->exports
+ i
, outarch
, !(def
->exports
+ i
)->flag_data
);
3023 n
->archive_next
= head
;
3025 def
->exports
[i
].internal_name
= internal
;
3028 ar_tail
= make_tail (outarch
);
3030 if (ar_head
== NULL
|| ar_tail
== NULL
)
3033 /* Now stick them all into the archive. */
3034 ar_head
->archive_next
= head
;
3035 ar_tail
->archive_next
= ar_head
;
3038 if (! bfd_set_archive_head (outarch
, head
))
3039 einfo ("%X%P: bfd_set_archive_head: %E\n");
3041 if (! bfd_close (outarch
))
3042 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
3044 while (head
!= NULL
)
3046 bfd
*n
= head
->archive_next
;
3052 static int undef_count
= 0;
3060 static struct key_value
*udef_table
;
3062 static int undef_sort_cmp (const void *l1
, const void *r1
)
3064 const struct key_value
*l
= l1
;
3065 const struct key_value
*r
= r1
;
3067 return strcmp (l
->key
, r
->key
);
3070 static struct bfd_link_hash_entry
*
3071 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3073 struct bfd_link_hash_entry
*h
= NULL
;
3074 struct key_value
*kv
;
3075 struct key_value key
;
3076 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3078 strcpy (lname
, name
);
3080 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3085 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3090 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3091 if (h
->type
== bfd_link_hash_undefined
)
3095 if (lname
[0] == '?')
3098 if (at
|| lname
[0] == '@')
3100 if (lname
[0] == '@')
3102 if (pe_details
->underscored
)
3105 /* Use memmove rather than strcpy as that
3106 can handle overlapping buffers. */
3107 memmove (lname
, lname
+ 1, strlen (lname
));
3109 kv
= bsearch (&key
, udef_table
, undef_count
,
3110 sizeof (struct key_value
), undef_sort_cmp
);
3113 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3114 if (h
->type
== bfd_link_hash_undefined
)
3119 *strchr (lname
, '@') = 0;
3121 kv
= bsearch (&key
, udef_table
, undef_count
,
3122 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
)
3132 strcat (lname
, "@");
3134 kv
= bsearch (&key
, udef_table
, undef_count
,
3135 sizeof (struct key_value
), undef_sort_cmp
);
3139 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3140 if (h
->type
== bfd_link_hash_undefined
)
3144 if (lname
[0] == '_' && pe_details
->underscored
)
3148 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3153 kv
= bsearch (&key
, udef_table
, undef_count
,
3154 sizeof (struct key_value
), undef_sort_cmp
);
3158 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3159 if (h
->type
== bfd_link_hash_undefined
)
3171 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3172 void *inf ATTRIBUTE_UNUSED
)
3174 if (h
->type
== bfd_link_hash_undefined
)
3180 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3182 if (h
->type
== bfd_link_hash_undefined
)
3186 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3187 at
= strchr (udef_table
[undef_count
].key
3188 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3191 udef_table
[undef_count
].oname
= h
->root
.string
;
3198 pe_create_undef_table (void)
3202 /* count undefined symbols */
3204 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3206 /* create and fill the corresponding table */
3207 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3210 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3213 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3217 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3219 lang_input_statement_type
*fake_file
;
3221 fake_file
= lang_add_input_file (name
,
3222 lang_input_file_is_fake_enum
,
3224 fake_file
->the_bfd
= abfd
;
3225 ldlang_add_file (fake_file
);
3227 if (!bfd_link_add_symbols (abfd
, linfo
))
3228 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3232 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3234 pe_dll_id_target (bfd_get_target (output_bfd
));
3239 def_file_module
*module
;
3240 def_file_import
*imp
;
3242 imp
= pe_def_file
->imports
;
3244 pe_create_undef_table ();
3246 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3248 int do_this_dll
= 0;
3250 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
3251 if (imp
[i
].module
== module
)
3253 if (i
>= pe_def_file
->num_imports
)
3256 dll_filename
= module
->name
;
3257 dll_symname
= xstrdup (module
->name
);
3258 for (j
= 0; dll_symname
[j
]; j
++)
3259 if (!ISALNUM (dll_symname
[j
]))
3260 dll_symname
[j
] = '_';
3262 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3264 def_file_export exp
;
3265 struct bfd_link_hash_entry
*blhe
;
3266 int lead_at
= (*imp
[i
].internal_name
== '@');
3267 /* See if we need this import. */
3268 size_t len
= strlen (imp
[i
].internal_name
);
3269 char *name
= xmalloc (len
+ 2 + 6);
3270 bool include_jmp_stub
= false;
3271 bool is_cdecl
= false;
3272 bool is_undef
= false;
3274 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3278 sprintf (name
, "%s", imp
[i
].internal_name
);
3280 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3282 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3283 false, false, false);
3285 /* Include the jump stub for <sym> only if the <sym>
3287 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3290 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3292 sprintf (name
, "%s%s%s", "__imp_", U (""),
3293 imp
[i
].internal_name
);
3295 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3296 false, false, false);
3298 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3302 include_jmp_stub
= true;
3303 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3307 && (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3309 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3310 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3311 include_jmp_stub
= true;
3313 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3324 bfd
*ar_head
= make_head (output_bfd
);
3325 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
),
3329 exp
.internal_name
= imp
[i
].internal_name
;
3330 exp
.name
= imp
[i
].name
;
3331 exp
.its_name
= imp
[i
].its_name
;
3332 exp
.ordinal
= imp
[i
].ordinal
;
3333 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3334 exp
.flag_private
= 0;
3335 exp
.flag_constant
= 0;
3336 exp
.flag_data
= imp
[i
].data
;
3337 exp
.flag_noname
= exp
.name
? 0 : 1;
3338 one
= make_one (&exp
, output_bfd
,
3339 !exp
.flag_data
&& include_jmp_stub
);
3340 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3345 bfd
*ar_tail
= make_tail (output_bfd
);
3346 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3355 free (udef_table
[undef_count
].key
);
3360 if (pe_def_file
&& pe_def_file
->name
)
3361 dll_filename
= pe_def_file
->name
;
3364 dll_filename
= bfd_get_filename (output_bfd
);
3365 for (const char *p
= dll_filename
; *p
; p
++)
3366 if (*p
== '\\' || *p
== '/' || *p
== ':')
3367 dll_filename
= p
+ 1;
3369 dll_symname
= xstrdup (dll_filename
);
3370 for (int i
= 0; dll_symname
[i
]; i
++)
3371 if (!ISALNUM (dll_symname
[i
]))
3372 dll_symname
[i
] = '_';
3375 /* We were handed a *.DLL file. Parse it and turn it into a set of
3376 IMPORTS directives in the def file. Return TRUE if the file was
3377 handled, FALSE if not. */
3380 pe_get16 (bfd
*abfd
, int where
)
3384 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3385 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3386 return b
[0] + (b
[1] << 8);
3390 pe_get32 (bfd
*abfd
, int where
)
3394 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3395 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3396 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3402 unsigned char *b
= ptr
;
3404 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3408 pe_implied_import_dll (const char *filename
)
3411 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3412 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3413 bfd_vma exp_funcbase
;
3414 unsigned char *expdata
;
3416 bfd_vma name_rvas
, nexp
;
3417 const char *dllname
;
3418 /* Initialization with start > end guarantees that is_data
3419 will not be set by mistake, and avoids compiler warning. */
3420 bfd_vma data_start
= 1;
3421 bfd_vma data_end
= 0;
3422 bfd_vma rdata_start
= 1;
3423 bfd_vma rdata_end
= 0;
3424 bfd_vma bss_start
= 1;
3425 bfd_vma bss_end
= 0;
3428 /* No, I can't use bfd here. kernel32.dll puts its export table in
3429 the middle of the .rdata section. */
3430 dll
= bfd_openr (filename
, pe_details
->target_name
);
3433 einfo (_("%X%P: open %s: %E\n"), filename
);
3437 track_dependency_files (filename
);
3439 /* PEI dlls seem to be bfd_objects. */
3440 if (!bfd_check_format (dll
, bfd_object
))
3442 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3446 /* Get pe_header, optional header and numbers of directory entries. */
3447 pe_header_offset
= pe_get32 (dll
, 0x3c);
3448 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3450 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3452 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3455 /* No import or export directory entry. */
3456 if (num_entries
< 1)
3460 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3461 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3463 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3464 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3467 /* No export table - nothing to export. */
3468 if (export_size
== 0)
3471 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3472 secptr
= (pe_header_offset
+ 4 + 20 +
3473 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3476 /* Get the rva and size of the export section. */
3477 for (i
= 0; i
< nsections
; i
++)
3480 bfd_vma secptr1
= secptr
+ 40 * i
;
3481 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3482 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3483 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3485 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3486 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3488 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3490 expptr
= fptr
+ (export_rva
- vaddr
);
3491 if (export_rva
+ export_size
> vaddr
+ vsize
)
3492 export_size
= vsize
- (export_rva
- vaddr
);
3497 /* Scan sections and store the base and size of the
3498 data and bss segments in data/base_start/end. */
3499 for (i
= 0; i
< nsections
; i
++)
3501 bfd_vma secptr1
= secptr
+ 40 * i
;
3502 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3503 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3504 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3508 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3509 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3511 if (strcmp(sec_name
,".data") == 0)
3514 data_end
= vaddr
+ vsize
;
3516 if (pe_dll_extra_pe_debug
)
3517 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3518 __func__
, sec_name
, (unsigned long) vaddr
,
3519 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3521 else if (strcmp(sec_name
,".rdata") == 0)
3523 rdata_start
= vaddr
;
3524 rdata_end
= vaddr
+ vsize
;
3526 if (pe_dll_extra_pe_debug
)
3527 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3528 __func__
, sec_name
, (unsigned long) vaddr
,
3529 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3531 else if (strcmp (sec_name
,".bss") == 0)
3534 bss_end
= vaddr
+ vsize
;
3536 if (pe_dll_extra_pe_debug
)
3537 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3538 __func__
, sec_name
, (unsigned long) vaddr
,
3539 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3543 expdata
= xmalloc (export_size
);
3544 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3545 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3546 erva
= (char *) expdata
- export_rva
;
3548 if (pe_def_file
== 0)
3549 pe_def_file
= def_file_empty ();
3551 nexp
= pe_as32 (expdata
+ 24);
3552 name_rvas
= pe_as32 (expdata
+ 32);
3553 exp_funcbase
= pe_as32 (expdata
+ 28);
3555 /* Use internal dll name instead of filename
3556 to enable symbolic dll linking. */
3557 dllname
= erva
+ pe_as32 (expdata
+ 12);
3559 /* Check to see if the dll has already been added to
3560 the definition list and if so return without error.
3561 This avoids multiple symbol definitions. */
3562 if (def_get_module (pe_def_file
, dllname
))
3564 if (pe_dll_extra_pe_debug
)
3565 printf ("%s is already loaded\n", dllname
);
3569 /* This is an optimized version of the insertion loop, which avoids lots of
3570 calls to realloc and memmove from def_file_add_import. */
3571 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3572 erva
+ pe_as32 (erva
+ name_rvas
),
3573 dllname
, 0, NULL
, NULL
)) >= 0)
3575 for (i
= 0; i
< nexp
; i
++)
3577 /* Pointer to the names vector. */
3578 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3579 def_file_import
*imp
;
3580 /* Pointer to the function address vector. */
3581 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3582 /* is_data is true if the address is in the data, rdata or bss
3585 (func_rva
>= data_start
&& func_rva
< data_end
)
3586 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3587 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3589 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3590 dllname
, i
, NULL
, NULL
);
3591 /* Mark symbol type. */
3592 imp
->data
= is_data
;
3594 if (pe_dll_extra_pe_debug
)
3595 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3596 __func__
, dllname
, erva
+ name_rva
,
3597 (unsigned long) func_rva
, is_data
? "(data)" : "");
3603 /* Iterate through the list of symbols. */
3604 for (i
= 0; i
< nexp
; i
++)
3606 /* Pointer to the names vector. */
3607 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3608 def_file_import
*imp
;
3609 /* Pointer to the function address vector. */
3610 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3613 /* Skip unwanted symbols, which are
3614 exported in buggy auto-import releases. */
3615 if (! startswith (erva
+ name_rva
, "__nm_"))
3617 bool is_dup
= false;
3618 /* is_data is true if the address is in the data, rdata or bss
3621 (func_rva
>= data_start
&& func_rva
< data_end
)
3622 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3623 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3625 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3626 dllname
, i
, NULL
, NULL
, &is_dup
);
3627 /* Mark symbol type. */
3629 imp
->data
= is_data
;
3631 if (pe_dll_extra_pe_debug
)
3632 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3633 __func__
, dllname
, erva
+ name_rva
,
3634 (unsigned long) func_rva
, is_data
? "(data)" : "");
3642 pe_output_file_set_long_section_names (bfd
*abfd
)
3644 if (pe_use_coff_long_section_names
< 0)
3646 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3647 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3650 /* These are the main functions, called from the emulation. The first
3651 is called after the bfds are read, so we can guess at how much space
3652 we need. The second is called after everything is placed, so we
3653 can put the right values in place. */
3656 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3658 pe_dll_id_target (bfd_get_target (abfd
));
3659 pe_output_file_set_long_section_names (abfd
);
3660 process_def_file_and_drectve (abfd
, info
);
3662 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3664 if (pe_dll_enable_reloc_section
)
3666 build_filler_bfd (false /* edata not needed. */);
3667 pe_output_file_set_long_section_names (filler_bfd
);
3673 build_filler_bfd (true /* edata is needed. */);
3674 pe_output_file_set_long_section_names (filler_bfd
);
3678 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3680 pe_dll_id_target (bfd_get_target (abfd
));
3681 pe_output_file_set_long_section_names (abfd
);
3682 build_filler_bfd (0);
3683 pe_output_file_set_long_section_names (filler_bfd
);
3687 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3689 pe_exe_fill_sections (abfd
, info
);
3693 fill_edata (abfd
, info
);
3694 edata_s
->contents
= edata_d
;
3697 if (bfd_link_dll (info
))
3698 pe_data (abfd
)->dll
= 1;
3702 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3704 pe_dll_id_target (bfd_get_target (abfd
));
3705 pe_output_file_set_long_section_names (abfd
);
3706 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3708 generate_reloc (abfd
, info
);
3712 bfd_set_section_size (reloc_s
, reloc_sz
);
3714 /* Resize the sections. */
3715 lang_reset_memory_regions ();
3716 lang_size_sections (NULL
, true);
3718 /* Redo special stuff. */
3719 ldemul_after_allocation ();
3721 /* Do the assignments again. */
3722 lang_do_assignments (lang_final_phase_enum
);
3724 reloc_s
->contents
= reloc_d
;
3728 /* Do not emit an empty reloc section. */
3729 bfd_set_section_flags (reloc_s
, SEC_IN_MEMORY
| SEC_EXCLUDE
);
3730 reloc_s
->output_section
= bfd_abs_section_ptr
;
3735 pe_bfd_is_dll (bfd
*abfd
)
3737 return (bfd_get_format (abfd
) == bfd_object
3739 && pe_data (abfd
)->dll
);