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
;
1547 if (!bfd_generic_link_read_symbols (b
))
1549 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1553 symbols
= bfd_get_outsymbols (b
);
1555 for (s
= b
->sections
; s
; s
= s
->next
)
1559 /* If the section is not going to be output, then ignore it. */
1560 if (s
->output_section
== NULL
)
1562 /* FIXME: This should not happen. Convert to the correct
1563 form here, but really, this should be investigated. */
1564 s
->output_section
= bfd_abs_section_ptr
;
1568 /* I don't know why there would be a reloc for these, but I've
1569 seen it happen - DJ */
1570 if (s
->output_section
== bfd_abs_section_ptr
)
1573 /* If it's not loaded, we don't need to relocate it this way. */
1574 if (!(s
->output_section
->flags
& SEC_LOAD
))
1577 /* This happens when linking with --just-symbols=<file>
1578 so do not generate an error. */
1579 if (s
->output_section
->vma
== 0)
1582 sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
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
.u32
];
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
);
2111 bfd_find_target (pe_details
->object_target
, abfd
);
2112 bfd_make_writable (abfd
);
2114 bfd_set_format (abfd
, bfd_object
);
2115 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2118 symtab
= xmalloc (6 * sizeof (asymbol
*));
2119 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2120 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2121 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2122 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2123 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2125 /* OK, pay attention here. I got confused myself looking back at
2126 it. We create a four-byte section to mark the beginning of the
2127 list, and we include an offset of 4 in the section, so that the
2128 pointer to the list points to the *end* of this section, which is
2129 the start of the list of sections from other objects. */
2131 bfd_set_section_size (id2
, 20);
2135 if (pe_use_nul_prefixed_import_tables
)
2136 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2137 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2138 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2139 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2142 if (pe_use_nul_prefixed_import_tables
)
2143 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2145 bfd_set_section_size (id5
, 0);
2146 d5
= xmalloc (PE_IDATA5_SIZE
);
2148 memset (d5
, 0, PE_IDATA5_SIZE
);
2149 if (pe_use_nul_prefixed_import_tables
)
2150 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2152 bfd_set_section_size (id4
, 0);
2153 d4
= xmalloc (PE_IDATA4_SIZE
);
2155 memset (d4
, 0, PE_IDATA4_SIZE
);
2157 bfd_set_symtab (abfd
, symtab
, symptr
);
2159 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2160 if (pe_use_nul_prefixed_import_tables
)
2162 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2163 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2167 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2168 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2171 bfd_make_readable (abfd
);
2175 /* .section .idata$4
2182 .global __my_dll_iname
2187 make_tail (bfd
*parent
)
2189 asection
*id4
, *id5
, *id7
;
2190 unsigned char *d4
, *d5
, *d7
;
2195 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2196 /* In theory we should return NULL here at let our caller decide what to
2197 do. But currently the return value is not checked, just used, and
2198 besides, this condition only happens when the system has run out of
2199 memory. So just give up. */
2200 exit (EXIT_FAILURE
);
2203 abfd
= bfd_create (oname
, parent
);
2205 bfd_find_target (pe_details
->object_target
, abfd
);
2206 bfd_make_writable (abfd
);
2208 bfd_set_format (abfd
, bfd_object
);
2209 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2212 symtab
= xmalloc (5 * sizeof (asymbol
*));
2213 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2214 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2215 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2216 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2218 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2219 d4
= xmalloc (PE_IDATA4_SIZE
);
2221 memset (d4
, 0, PE_IDATA4_SIZE
);
2223 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2224 d5
= xmalloc (PE_IDATA5_SIZE
);
2226 memset (d5
, 0, PE_IDATA5_SIZE
);
2228 len
= strlen (dll_filename
) + 1;
2231 bfd_set_section_size (id7
, len
);
2234 strcpy ((char *) d7
, dll_filename
);
2235 /* If len was odd, the above
2236 strcpy leaves behind an undefined byte. That is harmless,
2237 but we set it to 0 just so the binary dumps are pretty. */
2240 bfd_set_symtab (abfd
, symtab
, symptr
);
2242 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2243 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2244 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2246 bfd_make_readable (abfd
);
2252 .global ___imp_function
2253 .global __imp__function
2255 jmp *__imp__function:
2269 .asciz "function" xlate? (add underscore, kill at) */
2271 static const unsigned char jmp_ix86_bytes
[] =
2273 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2276 static const unsigned char jmp_aarch64_bytes
[] =
2278 0x10, 0x00, 0x00, 0x90, /* adrp x16, 0 */
2279 0x10, 0x02, 0x00, 0x91, /* add x16, x16, #0x0 */
2280 0x10, 0x02, 0x40, 0xf9, /* ldr x16, [x16] */
2281 0x00, 0x02, 0x1f, 0xd6 /* br x16 */
2289 .dw __imp_function */
2291 static const unsigned char jmp_sh_bytes
[] =
2293 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2297 lui $t0,<high:__imp_function>
2298 lw $t0,<low:__imp_function>
2302 static const unsigned char jmp_mips_bytes
[] =
2304 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2305 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2308 static const unsigned char jmp_arm_bytes
[] =
2310 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2311 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2317 make_one (def_file_export
*exp
, bfd
*parent
, bool include_jmp_stub
)
2319 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2320 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2324 const unsigned char *jmp_bytes
= NULL
;
2325 int jmp_byte_count
= 0;
2326 const char *internal_name
= exp
->internal_name
;
2328 if (!exp
->flag_noname
)
2330 /* Check for a decorated symbol name */
2331 struct decoration_hash_entry
*entry
;
2333 entry
= (struct decoration_hash_entry
*)
2334 bfd_hash_lookup (&(coff_hash_table (&link_info
)->decoration_hash
),
2335 internal_name
, false, false);
2338 if (entry
->decorated_link
)
2340 internal_name
= entry
->decorated_link
->root
.string
;
2342 if (pe_details
->underscored
&& internal_name
[0] == '_')
2347 einfo (_("%P: error: NULL decorated name for %s\n"), internal_name
);
2352 /* Include the jump stub section only if it is needed. A jump
2353 stub is needed if the symbol being imported <sym> is a function
2354 symbol and there is at least one undefined reference to that
2355 symbol. In other words, if all the import references to <sym> are
2356 explicitly through _declspec(dllimport) then the jump stub is not
2358 if (include_jmp_stub
)
2360 switch (pe_details
->pe_arch
)
2363 jmp_bytes
= jmp_ix86_bytes
;
2364 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2367 jmp_bytes
= jmp_sh_bytes
;
2368 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2371 jmp_bytes
= jmp_mips_bytes
;
2372 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2375 case PE_ARCH_arm_wince
:
2376 jmp_bytes
= jmp_arm_bytes
;
2377 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2379 case PE_ARCH_aarch64
:
2380 jmp_bytes
= jmp_aarch64_bytes
;
2381 jmp_byte_count
= sizeof (jmp_aarch64_bytes
);
2388 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2389 /* In theory we should return NULL here at let our caller decide what to
2390 do. But currently the return value is not checked, just used, and
2391 besides, this condition only happens when the system has run out of
2392 memory. So just give up. */
2393 exit (EXIT_FAILURE
);
2396 abfd
= bfd_create (oname
, parent
);
2398 bfd_find_target (pe_details
->object_target
, abfd
);
2399 bfd_make_writable (abfd
);
2401 bfd_set_format (abfd
, bfd_object
);
2402 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2405 symtab
= xmalloc (12 * sizeof (asymbol
*));
2407 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2408 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2409 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2410 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2411 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2413 if (*internal_name
== '@')
2415 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2417 if (include_jmp_stub
)
2418 quick_symbol (abfd
, "", internal_name
, "", tx
, BSF_GLOBAL
, 0);
2419 quick_symbol (abfd
, "__imp_", internal_name
, "", id5
,
2421 /* Fastcall applies only to functions,
2422 so no need for auto-import symbol. */
2426 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2428 if (include_jmp_stub
)
2429 quick_symbol (abfd
, U (""), internal_name
, "", tx
,
2431 quick_symbol (abfd
, "__imp_", U (""), internal_name
, id5
,
2433 /* Symbol to reference ord/name of imported
2434 data symbol, used to implement auto-import. */
2436 quick_symbol (abfd
, "__nm_", U (""), internal_name
, id6
,
2439 if (pe_dll_compat_implib
)
2440 quick_symbol (abfd
, "___imp_", internal_name
, "", id5
,
2443 if (include_jmp_stub
)
2445 bfd_set_section_size (tx
, jmp_byte_count
);
2446 td
= xmalloc (jmp_byte_count
);
2448 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2450 switch (pe_details
->pe_arch
)
2454 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2456 /* Mark this object as SAFESEH compatible. */
2457 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2459 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2463 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2466 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2467 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2468 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2471 case PE_ARCH_arm_wince
:
2472 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2474 case PE_ARCH_aarch64
:
2475 quick_reloc (abfd
, 0, BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL
, 2);
2476 quick_reloc (abfd
, 4, BFD_RELOC_AARCH64_ADD_LO12
, 2);
2484 bfd_set_section_size (tx
, 0);
2486 bfd_set_section_size (id7
, 4);
2490 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2493 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2494 d5
= xmalloc (PE_IDATA5_SIZE
);
2496 memset (d5
, 0, PE_IDATA5_SIZE
);
2498 if (exp
->flag_noname
)
2500 d5
[0] = exp
->ordinal
;
2501 d5
[1] = exp
->ordinal
>> 8;
2502 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2506 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2510 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2511 d4
= xmalloc (PE_IDATA4_SIZE
);
2513 memset (d4
, 0, PE_IDATA4_SIZE
);
2515 if (exp
->flag_noname
)
2517 d4
[0] = exp
->ordinal
;
2518 d4
[1] = exp
->ordinal
>> 8;
2519 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2523 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2527 if (exp
->flag_noname
)
2530 bfd_set_section_size (id6
, 0);
2536 /* { short, asciz } */
2538 len
= 2 + strlen (exp
->its_name
) + 1;
2540 len
= 2 + strlen (exp
->name
) + 1;
2543 bfd_set_section_size (id6
, len
);
2546 memset (d6
, 0, len
);
2548 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2549 contains an invalid value (-1). */
2550 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2555 strcpy ((char*) d6
+ 2, exp
->its_name
);
2557 strcpy ((char *) d6
+ 2, exp
->name
);
2560 bfd_set_symtab (abfd
, symtab
, symptr
);
2562 if (include_jmp_stub
)
2563 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2564 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2565 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2566 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2567 if (!exp
->flag_noname
)
2568 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2570 bfd_make_readable (abfd
);
2575 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2577 /* Name thunks go to idata$4. */
2583 if (asprintf (&oname
, "%s_nmth%06d.o", dll_symname
, tmp_seq
) < 4)
2584 /* In theory we should return NULL here at let our caller decide what to
2585 do. But currently the return value is not checked, just used, and
2586 besides, this condition only happens when the system has run out of
2587 memory. So just give up. */
2588 exit (EXIT_FAILURE
);
2591 abfd
= bfd_create (oname
, parent
);
2593 bfd_find_target (pe_details
->object_target
, abfd
);
2594 bfd_make_writable (abfd
);
2596 bfd_set_format (abfd
, bfd_object
);
2597 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2600 symtab
= xmalloc (3 * sizeof (asymbol
*));
2601 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2602 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2603 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2605 /* We need space for the real thunk and for the null terminator. */
2606 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2607 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2609 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2610 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2613 bfd_set_symtab (abfd
, symtab
, symptr
);
2615 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2617 bfd_make_readable (abfd
);
2622 make_import_fixup_mark (arelent
*rel
, char *name
)
2624 /* We convert reloc to symbol, for later reference. */
2625 static unsigned int counter
;
2626 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2627 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2628 struct bfd_link_hash_entry
*bh
;
2629 char *fixup_name
, buf
[256];
2632 /* "name" buffer has space before the symbol name for prefixes. */
2633 sprintf (buf
, "__fu%d_", counter
++);
2634 prefix_len
= strlen (buf
);
2635 fixup_name
= name
- prefix_len
;
2636 memcpy (fixup_name
, buf
, prefix_len
);
2639 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2640 current_sec
, /* sym->section, */
2641 rel
->address
, NULL
, true, false, &bh
);
2643 return bh
->root
.string
;
2646 /* .section .idata$2
2647 .rva __nm_thnk_SYM (singleton thunk with name of func)
2650 .rva __my_dll_iname (name of dll)
2651 .rva __fuNN_SYM (pointer to reference (address) in text) */
2654 make_import_fixup_entry (const char *name
,
2655 const char *fixup_name
,
2656 const char *symname
,
2664 if (asprintf (&oname
, "%s_fu%06d.o", dll_symname
, tmp_seq
) < 4)
2665 /* In theory we should return NULL here at let our caller decide what to
2666 do. But currently the return value is not checked, just used, and
2667 besides, this condition only happens when the system has run out of
2668 memory. So just give up. */
2669 exit (EXIT_FAILURE
);
2672 abfd
= bfd_create (oname
, parent
);
2674 bfd_find_target (pe_details
->object_target
, abfd
);
2675 bfd_make_writable (abfd
);
2677 bfd_set_format (abfd
, bfd_object
);
2678 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2681 symtab
= xmalloc (6 * sizeof (asymbol
*));
2682 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2684 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2685 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2686 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2688 bfd_set_section_size (id2
, 20);
2693 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2694 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2695 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2698 bfd_set_symtab (abfd
, symtab
, symptr
);
2700 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2702 bfd_make_readable (abfd
);
2706 /* .section .rdata_runtime_pseudo_reloc
2708 .rva __fuNN_SYM (pointer to reference (address) in text) */
2711 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2712 const char *fixup_name
,
2713 bfd_vma addend ATTRIBUTE_UNUSED
,
2718 unsigned char *rt_rel_d
;
2723 if (asprintf (&oname
, "%s_rtr%06d.o", dll_symname
, tmp_seq
) < 4)
2724 /* In theory we should return NULL here at let our caller decide what to
2725 do. But currently the return value is not checked, just used, and
2726 besides, this condition only happens when the system has run out of
2727 memory. So just give up. */
2728 exit (EXIT_FAILURE
);
2731 abfd
= bfd_create (oname
, parent
);
2733 bfd_find_target (pe_details
->object_target
, abfd
);
2734 bfd_make_writable (abfd
);
2736 bfd_set_format (abfd
, bfd_object
);
2737 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2739 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2741 if (runtime_pseudp_reloc_v2_init
)
2742 size
= 3 * sizeof (asymbol
*);
2744 size
= 6 * sizeof (asymbol
*);
2747 size
= 2 * sizeof (asymbol
*);
2750 symtab
= xmalloc (size
);
2753 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2754 bfd_coff_set_long_section_names (abfd
, true);
2756 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2758 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2761 if (!runtime_pseudp_reloc_v2_init
)
2764 runtime_pseudp_reloc_v2_init
= true;
2767 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2769 bfd_set_section_size (rt_rel
, size
);
2770 rt_rel_d
= xmalloc (size
);
2771 rt_rel
->contents
= rt_rel_d
;
2772 memset (rt_rel_d
, 0, size
);
2773 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2774 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2775 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2777 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2778 save_relocs (rt_rel
);
2780 bfd_set_symtab (abfd
, symtab
, symptr
);
2782 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2786 bfd_set_section_size (rt_rel
, 8);
2787 rt_rel_d
= xmalloc (8);
2788 rt_rel
->contents
= rt_rel_d
;
2789 memset (rt_rel_d
, 0, 8);
2791 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2792 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2794 save_relocs (rt_rel
);
2796 bfd_set_symtab (abfd
, symtab
, symptr
);
2798 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2801 bfd_make_readable (abfd
);
2806 .rva __pei386_runtime_relocator */
2809 pe_create_runtime_relocator_reference (bfd
*parent
)
2811 asection
*extern_rt_rel
;
2812 unsigned char *extern_rt_rel_d
;
2816 if (asprintf (&oname
, "%s_ertr%06d.o", dll_symname
, tmp_seq
) < 4)
2817 /* In theory we should return NULL here at let our caller decide what to
2818 do. But currently the return value is not checked, just used, and
2819 besides, this condition only happens when the system has run out of
2820 memory. So just give up. */
2821 exit (EXIT_FAILURE
);
2824 abfd
= bfd_create (oname
, parent
);
2826 bfd_find_target (pe_details
->object_target
, abfd
);
2827 bfd_make_writable (abfd
);
2829 bfd_set_format (abfd
, bfd_object
);
2830 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2833 symtab
= xmalloc (2 * sizeof (asymbol
*));
2834 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2836 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2839 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2840 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2841 extern_rt_rel
->contents
= extern_rt_rel_d
;
2843 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2844 save_relocs (extern_rt_rel
);
2846 bfd_set_symtab (abfd
, symtab
, symptr
);
2848 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2850 bfd_make_readable (abfd
);
2855 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2856 const char *symname
)
2858 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2861 /* This is the original implementation of the auto-import feature, which
2862 primarily relied on the OS loader to patch things up with some help
2863 from the pseudo-relocator to overcome the main limitation. See the
2864 comment at the beginning of the file for an overview of the feature. */
2865 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2867 struct bfd_link_hash_entry
*name_thunk_sym
;
2868 /* name buffer is allocated with space at beginning for prefixes. */
2869 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2870 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2871 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2873 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2875 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2876 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2878 /* If we ever use autoimport, we have to cast text section writable. */
2879 config
.text_read_only
= false;
2880 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2883 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2885 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2886 link_info
.output_bfd
);
2887 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2891 /* In the original implementation, the pseudo-relocator was only used when
2892 the addend was not null. In the new implementation, the OS loader is
2893 completely bypassed and the pseudo-relocator does the entire work. */
2894 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2895 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2897 if (pe_dll_extra_pe_debug
)
2898 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2899 fixup_name
, (int) addend
);
2901 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
,
2902 rel
->howto
->bitsize
,
2903 link_info
.output_bfd
);
2904 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2906 if (runtime_pseudo_relocs_created
++ == 0)
2908 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2909 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2913 else if (addend
!= 0)
2914 einfo (_("%X%P: %H: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2915 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2919 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2928 unlink_if_ordinary (impfilename
);
2930 outarch
= bfd_openw (impfilename
, 0);
2934 /* xgettext:c-format */
2935 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2940 /* xgettext:c-format */
2941 info_msg (_("Creating library file: %s\n"), impfilename
);
2943 bfd_set_format (outarch
, bfd_archive
);
2944 outarch
->has_armap
= 1;
2946 /* Work out a reasonable size of things to put onto one line. */
2947 ar_head
= make_head (outarch
);
2949 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2950 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2952 /* Iterate the exclude list. */
2953 struct exclude_list_struct
*ex
;
2955 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2957 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2959 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2961 /* If it matched, we must open a fresh BFD for it (the original
2962 input BFD is still needed for the DLL's final link) and add
2963 it into the archive member chain. */
2966 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2967 ? bfd_get_filename (ibfd
->my_archive
)
2968 : bfd_get_filename (ibfd
), NULL
);
2971 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2974 if (ibfd
->my_archive
)
2976 /* Must now iterate through archive until we find the
2977 required member. A minor shame that we'll open the
2978 archive once per member that we require from it, and
2979 leak those archive bfds rather than reuse them. */
2980 bfd
*arbfd
= newbfd
;
2981 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2983 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2984 bfd_get_filename (ibfd
->my_archive
),
2985 bfd_get_filename (ibfd
));
2989 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2991 if (filename_cmp (bfd_get_filename (newbfd
),
2992 bfd_get_filename (ibfd
)) == 0)
2997 einfo (_("%X%P: %s(%s): can't find member in archive"),
2998 bfd_get_filename (ibfd
->my_archive
),
2999 bfd_get_filename (ibfd
));
3003 newbfd
->archive_next
= head
;
3008 for (i
= 0; i
< def
->num_exports
; i
++)
3010 /* The import library doesn't know about the internal name. */
3011 char *internal
= def
->exports
[i
].internal_name
;
3014 /* Don't add PRIVATE entries to import lib. */
3015 if (pe_def_file
->exports
[i
].flag_private
)
3018 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
3020 /* PR 19803: If a symbol has been discard due to garbage
3021 collection then do not create any exports for it. */
3023 struct coff_link_hash_entry
*h
;
3025 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
3026 false, false, false);
3028 /* If the symbol is hidden and undefined then it
3029 has been swept up by garbage collection. */
3030 && h
->symbol_class
== C_HIDDEN
3031 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
3034 /* If necessary, check with an underscore prefix as well. */
3035 if (pe_details
->underscored
&& internal
[0] != '@')
3039 name
= xmalloc (strlen (internal
) + 2);
3040 sprintf (name
, "_%s", internal
);
3042 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
3043 false, false, false);
3047 /* If the symbol is hidden and undefined then it
3048 has been swept up by garbage collection. */
3049 && h
->symbol_class
== C_HIDDEN
3050 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
3055 n
= make_one (def
->exports
+ i
, outarch
, !(def
->exports
+ i
)->flag_data
);
3056 n
->archive_next
= head
;
3058 def
->exports
[i
].internal_name
= internal
;
3061 ar_tail
= make_tail (outarch
);
3063 if (ar_head
== NULL
|| ar_tail
== NULL
)
3066 /* Now stick them all into the archive. */
3067 ar_head
->archive_next
= head
;
3068 ar_tail
->archive_next
= ar_head
;
3071 if (! bfd_set_archive_head (outarch
, head
))
3072 einfo ("%X%P: bfd_set_archive_head: %E\n");
3074 if (! bfd_close (outarch
))
3075 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
3077 while (head
!= NULL
)
3079 bfd
*n
= head
->archive_next
;
3085 static int undef_count
= 0;
3093 static struct key_value
*udef_table
;
3095 static int undef_sort_cmp (const void *l1
, const void *r1
)
3097 const struct key_value
*l
= l1
;
3098 const struct key_value
*r
= r1
;
3100 return strcmp (l
->key
, r
->key
);
3103 static struct bfd_link_hash_entry
*
3104 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3106 struct bfd_link_hash_entry
*h
= NULL
;
3107 struct key_value
*kv
;
3108 struct key_value key
;
3109 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3111 strcpy (lname
, name
);
3113 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3118 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3123 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3124 if (h
->type
== bfd_link_hash_undefined
)
3128 if (lname
[0] == '?')
3131 if (at
|| lname
[0] == '@')
3133 if (lname
[0] == '@')
3135 if (pe_details
->underscored
)
3138 /* Use memmove rather than strcpy as that
3139 can handle overlapping buffers. */
3140 memmove (lname
, lname
+ 1, strlen (lname
));
3142 kv
= bsearch (&key
, udef_table
, undef_count
,
3143 sizeof (struct key_value
), undef_sort_cmp
);
3146 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3147 if (h
->type
== bfd_link_hash_undefined
)
3152 *strchr (lname
, '@') = 0;
3154 kv
= bsearch (&key
, udef_table
, undef_count
,
3155 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
)
3165 strcat (lname
, "@");
3167 kv
= bsearch (&key
, udef_table
, undef_count
,
3168 sizeof (struct key_value
), undef_sort_cmp
);
3172 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3173 if (h
->type
== bfd_link_hash_undefined
)
3177 if (lname
[0] == '_' && pe_details
->underscored
)
3181 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3186 kv
= bsearch (&key
, udef_table
, undef_count
,
3187 sizeof (struct key_value
), undef_sort_cmp
);
3191 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3192 if (h
->type
== bfd_link_hash_undefined
)
3204 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3205 void *inf ATTRIBUTE_UNUSED
)
3207 if (h
->type
== bfd_link_hash_undefined
)
3213 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3215 if (h
->type
== bfd_link_hash_undefined
)
3219 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3220 at
= strchr (udef_table
[undef_count
].key
3221 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3224 udef_table
[undef_count
].oname
= h
->root
.string
;
3231 pe_create_undef_table (void)
3235 /* count undefined symbols */
3237 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3239 /* create and fill the corresponding table */
3240 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3243 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3246 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3250 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3252 lang_input_statement_type
*fake_file
;
3254 fake_file
= lang_add_input_file (name
,
3255 lang_input_file_is_fake_enum
,
3257 fake_file
->the_bfd
= abfd
;
3258 ldlang_add_file (fake_file
);
3260 if (!bfd_link_add_symbols (abfd
, linfo
))
3261 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3265 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3267 pe_dll_id_target (bfd_get_target (output_bfd
));
3272 def_file_module
*module
;
3273 def_file_import
*imp
;
3275 imp
= pe_def_file
->imports
;
3277 pe_create_undef_table ();
3279 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3281 int do_this_dll
= 0;
3283 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
3284 if (imp
[i
].module
== module
)
3286 if (i
>= pe_def_file
->num_imports
)
3289 dll_filename
= module
->name
;
3290 dll_symname
= xstrdup (module
->name
);
3291 for (j
= 0; dll_symname
[j
]; j
++)
3292 if (!ISALNUM (dll_symname
[j
]))
3293 dll_symname
[j
] = '_';
3295 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3297 def_file_export exp
;
3298 struct bfd_link_hash_entry
*blhe
;
3299 int lead_at
= (*imp
[i
].internal_name
== '@');
3300 /* See if we need this import. */
3301 size_t len
= strlen (imp
[i
].internal_name
);
3302 char *name
= xmalloc (len
+ 2 + 6);
3303 bool include_jmp_stub
= false;
3304 bool is_cdecl
= false;
3305 bool is_undef
= false;
3307 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3311 sprintf (name
, "%s", imp
[i
].internal_name
);
3313 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3315 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3316 false, false, false);
3318 /* Include the jump stub for <sym> only if the <sym>
3320 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3323 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3325 sprintf (name
, "%s%s%s", "__imp_", U (""),
3326 imp
[i
].internal_name
);
3328 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3329 false, false, false);
3331 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3335 include_jmp_stub
= true;
3336 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3340 && (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3342 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3343 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3344 include_jmp_stub
= true;
3346 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3357 bfd
*ar_head
= make_head (output_bfd
);
3358 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
),
3362 exp
.internal_name
= imp
[i
].internal_name
;
3363 exp
.name
= imp
[i
].name
;
3364 exp
.its_name
= imp
[i
].its_name
;
3365 exp
.ordinal
= imp
[i
].ordinal
;
3366 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3367 exp
.flag_private
= 0;
3368 exp
.flag_constant
= 0;
3369 exp
.flag_data
= imp
[i
].data
;
3370 exp
.flag_noname
= exp
.name
? 0 : 1;
3371 one
= make_one (&exp
, output_bfd
,
3372 !exp
.flag_data
&& include_jmp_stub
);
3373 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3378 bfd
*ar_tail
= make_tail (output_bfd
);
3379 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3388 free (udef_table
[undef_count
].key
);
3393 if (pe_def_file
&& pe_def_file
->name
)
3394 dll_filename
= pe_def_file
->name
;
3397 dll_filename
= bfd_get_filename (output_bfd
);
3398 for (const char *p
= dll_filename
; *p
; p
++)
3399 if (*p
== '\\' || *p
== '/' || *p
== ':')
3400 dll_filename
= p
+ 1;
3402 dll_symname
= xstrdup (dll_filename
);
3403 for (int i
= 0; dll_symname
[i
]; i
++)
3404 if (!ISALNUM (dll_symname
[i
]))
3405 dll_symname
[i
] = '_';
3408 /* We were handed a *.DLL file. Parse it and turn it into a set of
3409 IMPORTS directives in the def file. Return TRUE if the file was
3410 handled, FALSE if not. */
3413 pe_get16 (bfd
*abfd
, int where
)
3417 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3418 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3419 return b
[0] + (b
[1] << 8);
3423 pe_get32 (bfd
*abfd
, int where
)
3427 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3428 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3429 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3435 unsigned char *b
= ptr
;
3437 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3441 pe_implied_import_dll (const char *filename
)
3444 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3445 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3446 bfd_vma exp_funcbase
;
3447 unsigned char *expdata
;
3449 bfd_vma name_rvas
, nexp
;
3450 const char *dllname
;
3451 /* Initialization with start > end guarantees that is_data
3452 will not be set by mistake, and avoids compiler warning. */
3453 bfd_vma data_start
= 1;
3454 bfd_vma data_end
= 0;
3455 bfd_vma rdata_start
= 1;
3456 bfd_vma rdata_end
= 0;
3457 bfd_vma bss_start
= 1;
3458 bfd_vma bss_end
= 0;
3461 /* No, I can't use bfd here. kernel32.dll puts its export table in
3462 the middle of the .rdata section. */
3463 dll
= bfd_openr (filename
, pe_details
->target_name
);
3466 einfo (_("%X%P: open %s: %E\n"), filename
);
3470 track_dependency_files (filename
);
3472 /* PEI dlls seem to be bfd_objects. */
3473 if (!bfd_check_format (dll
, bfd_object
))
3475 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3479 /* Get pe_header, optional header and numbers of directory entries. */
3480 pe_header_offset
= pe_get32 (dll
, 0x3c);
3481 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3483 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3485 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3488 /* No import or export directory entry. */
3489 if (num_entries
< 1)
3493 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3494 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3496 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3497 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3500 /* No export table - nothing to export. */
3501 if (export_size
== 0)
3504 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3505 secptr
= (pe_header_offset
+ 4 + 20 +
3506 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3509 /* Get the rva and size of the export section. */
3510 for (i
= 0; i
< nsections
; i
++)
3513 bfd_vma secptr1
= secptr
+ 40 * i
;
3514 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3515 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3516 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3518 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3519 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3521 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3523 expptr
= fptr
+ (export_rva
- vaddr
);
3524 if (export_rva
+ export_size
> vaddr
+ vsize
)
3525 export_size
= vsize
- (export_rva
- vaddr
);
3530 /* Scan sections and store the base and size of the
3531 data and bss segments in data/base_start/end. */
3532 for (i
= 0; i
< nsections
; i
++)
3534 bfd_vma secptr1
= secptr
+ 40 * i
;
3535 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3536 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3537 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3541 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3542 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3544 if (strcmp(sec_name
,".data") == 0)
3547 data_end
= vaddr
+ vsize
;
3549 if (pe_dll_extra_pe_debug
)
3550 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3551 __func__
, sec_name
, (unsigned long) vaddr
,
3552 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3554 else if (strcmp(sec_name
,".rdata") == 0)
3556 rdata_start
= vaddr
;
3557 rdata_end
= vaddr
+ vsize
;
3559 if (pe_dll_extra_pe_debug
)
3560 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3561 __func__
, sec_name
, (unsigned long) vaddr
,
3562 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3564 else if (strcmp (sec_name
,".bss") == 0)
3567 bss_end
= vaddr
+ vsize
;
3569 if (pe_dll_extra_pe_debug
)
3570 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3571 __func__
, sec_name
, (unsigned long) vaddr
,
3572 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3576 expdata
= xmalloc (export_size
);
3577 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3578 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3579 erva
= (char *) expdata
- export_rva
;
3581 if (pe_def_file
== 0)
3582 pe_def_file
= def_file_empty ();
3584 nexp
= pe_as32 (expdata
+ 24);
3585 name_rvas
= pe_as32 (expdata
+ 32);
3586 exp_funcbase
= pe_as32 (expdata
+ 28);
3588 /* Use internal dll name instead of filename
3589 to enable symbolic dll linking. */
3590 dllname
= erva
+ pe_as32 (expdata
+ 12);
3592 /* Check to see if the dll has already been added to
3593 the definition list and if so return without error.
3594 This avoids multiple symbol definitions. */
3595 if (def_get_module (pe_def_file
, dllname
))
3597 if (pe_dll_extra_pe_debug
)
3598 printf ("%s is already loaded\n", dllname
);
3602 /* This is an optimized version of the insertion loop, which avoids lots of
3603 calls to realloc and memmove from def_file_add_import. */
3604 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3605 erva
+ pe_as32 (erva
+ name_rvas
),
3606 dllname
, 0, NULL
, NULL
)) >= 0)
3608 for (i
= 0; i
< nexp
; i
++)
3610 /* Pointer to the names vector. */
3611 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3612 def_file_import
*imp
;
3613 /* Pointer to the function address vector. */
3614 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3615 /* is_data is true if the address is in the data, rdata or bss
3618 (func_rva
>= data_start
&& func_rva
< data_end
)
3619 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3620 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3622 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3623 dllname
, i
, NULL
, NULL
);
3624 /* Mark symbol type. */
3625 imp
->data
= is_data
;
3627 if (pe_dll_extra_pe_debug
)
3628 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3629 __func__
, dllname
, erva
+ name_rva
,
3630 (unsigned long) func_rva
, is_data
? "(data)" : "");
3636 /* Iterate through the list of symbols. */
3637 for (i
= 0; i
< nexp
; i
++)
3639 /* Pointer to the names vector. */
3640 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3641 def_file_import
*imp
;
3642 /* Pointer to the function address vector. */
3643 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3646 /* Skip unwanted symbols, which are
3647 exported in buggy auto-import releases. */
3648 if (! startswith (erva
+ name_rva
, "__nm_"))
3650 bool is_dup
= false;
3651 /* is_data is true if the address is in the data, rdata or bss
3654 (func_rva
>= data_start
&& func_rva
< data_end
)
3655 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3656 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3658 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3659 dllname
, i
, NULL
, NULL
, &is_dup
);
3660 /* Mark symbol type. */
3662 imp
->data
= is_data
;
3664 if (pe_dll_extra_pe_debug
)
3665 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3666 __func__
, dllname
, erva
+ name_rva
,
3667 (unsigned long) func_rva
, is_data
? "(data)" : "");
3675 pe_output_file_set_long_section_names (bfd
*abfd
)
3677 if (pe_use_coff_long_section_names
< 0)
3679 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3680 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3683 /* These are the main functions, called from the emulation. The first
3684 is called after the bfds are read, so we can guess at how much space
3685 we need. The second is called after everything is placed, so we
3686 can put the right values in place. */
3689 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3691 pe_dll_id_target (bfd_get_target (abfd
));
3692 pe_output_file_set_long_section_names (abfd
);
3693 process_def_file_and_drectve (abfd
, info
);
3695 if (pe_def_file
->num_exports
== 0
3696 && (!bfd_link_pic (info
) || pe_dll_exclude_all_symbols
))
3698 if (pe_dll_enable_reloc_section
)
3700 build_filler_bfd (false /* edata not needed. */);
3701 pe_output_file_set_long_section_names (filler_bfd
);
3707 build_filler_bfd (true /* edata is needed. */);
3708 pe_output_file_set_long_section_names (filler_bfd
);
3712 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3714 pe_dll_id_target (bfd_get_target (abfd
));
3715 pe_output_file_set_long_section_names (abfd
);
3716 build_filler_bfd (0);
3717 pe_output_file_set_long_section_names (filler_bfd
);
3721 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3723 pe_exe_fill_sections (abfd
, info
);
3727 fill_edata (abfd
, info
);
3728 edata_s
->contents
= edata_d
;
3731 if (bfd_link_dll (info
))
3732 pe_data (abfd
)->dll
= 1;
3736 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3738 pe_dll_id_target (bfd_get_target (abfd
));
3739 pe_output_file_set_long_section_names (abfd
);
3740 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3742 generate_reloc (abfd
, info
);
3746 bfd_set_section_size (reloc_s
, reloc_sz
);
3748 /* Resize the sections. */
3749 lang_reset_memory_regions ();
3750 lang_size_sections (NULL
, true);
3752 /* Redo special stuff. */
3753 ldemul_after_allocation ();
3755 /* Do the assignments again. */
3756 lang_do_assignments (lang_final_phase_enum
);
3758 reloc_s
->contents
= reloc_d
;
3762 /* Do not emit an empty reloc section. */
3763 bfd_set_section_flags (reloc_s
, SEC_IN_MEMORY
| SEC_EXCLUDE
);
3764 reloc_s
->output_section
= bfd_abs_section_ptr
;
3769 pe_bfd_is_dll (bfd
*abfd
)
3771 return (bfd_get_format (abfd
) == bfd_object
3773 && pe_data (abfd
)->dll
);