1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2022 Free Software Foundation, Inc.
3 Written by DJ Delorie <dj@cygnus.com>
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
25 #include "libiberty.h"
26 #include "filenames.h"
27 #include "safe-ctype.h"
41 #include "coff/internal.h"
42 #include "../bfd/libcoff.h"
47 #define PE_IDATA4_SIZE 8
48 #define PE_IDATA5_SIZE 8
51 #define AOUTSZ PEPAOUTSZ
52 #define PEAOUTHDR PEPAOUTHDR
60 #ifndef PE_IDATA4_SIZE
61 #define PE_IDATA4_SIZE 4
64 #ifndef PE_IDATA5_SIZE
65 #define PE_IDATA5_SIZE 4
68 /* This file turns a regular Windows PE image into a DLL. Because of
69 the complexity of this operation, it has been broken down into a
70 number of separate modules which are all called by the main function
71 at the end of this file. This function is not re-entrant and is
72 normally only called once, so static variables are used to reduce
73 the number of parameters and return values required.
75 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
77 /* Auto-import feature by Paul Sokolovsky
81 1. With this feature on, DLL clients can import variables from DLL
82 without any concern from their side (for example, without any source
85 2. This is done completely in bounds of the PE specification (to be fair,
86 there's a place where it pokes nose out of, but in practice it works).
87 So, resulting module can be used with any other PE compiler/linker.
89 3. Auto-import is fully compatible with standard import method and they
90 can be mixed together.
92 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
93 reference to it; load time: negligible; virtual/physical memory: should be
94 less than effect of DLL relocation, and I sincerely hope it doesn't affect
95 DLL sharability (too much).
99 The obvious and only way to get rid of dllimport insanity is to make client
100 access variable directly in the DLL, bypassing extra dereference. I.e.,
101 whenever client contains something like
105 address of dll_var in the command should be relocated to point into loaded
106 DLL. The aim is to make OS loader do so, and than make ld help with that.
107 Import section of PE made following way: there's a vector of structures
108 each describing imports from particular DLL. Each such structure points
109 to two other parallel vectors: one holding imported names, and one which
110 will hold address of corresponding imported name. So, the solution is
111 de-vectorize these structures, making import locations be sparse and
112 pointing directly into code. Before continuing, it is worth a note that,
113 while authors strives to make PE act ELF-like, there're some other people
114 make ELF act PE-like: elfvector, ;-) .
118 For each reference of data symbol to be imported from DLL (to set of which
119 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
120 import fixup entry is generated. That entry is of type
121 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
122 fixup entry contains pointer to symbol's address within .text section
123 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
124 (so, DLL name is referenced by multiple entries), and pointer to symbol
125 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
126 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
127 containing imported name. Here comes that "on the edge" problem mentioned
128 above: PE specification rambles that name vector (OriginalFirstThunk)
129 should run in parallel with addresses vector (FirstThunk), i.e. that they
130 should have same number of elements and terminated with zero. We violate
131 this, since FirstThunk points directly into machine code. But in practice,
132 OS loader implemented the sane way: it goes through OriginalFirstThunk and
133 puts addresses to FirstThunk, not something else. It once again should be
134 noted that dll and symbol name structures are reused across fixup entries
135 and should be there anyway to support standard import stuff, so sustained
136 overhead is 20 bytes per reference. Other question is whether having several
137 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
138 done even by native compiler/linker (libth32's functions are in fact reside
139 in windows9x kernel32.dll, so if you use it, you have two
140 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
141 referencing the same PE structures several times is valid. The answer is why
142 not, prohibiting that (detecting violation) would require more work on
143 behalf of loader than not doing it.
145 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
147 static void add_bfd_to_link (bfd
*, const char *, struct bfd_link_info
*);
149 /* For emultempl/pe.em. */
151 def_file
* pe_def_file
= 0;
152 int pe_dll_export_everything
= 0;
153 int pe_dll_exclude_all_symbols
= 0;
154 int pe_dll_do_default_excludes
= 1;
155 int pe_dll_kill_ats
= 0;
156 int pe_dll_stdcall_aliases
= 0;
157 int pe_dll_warn_dup_exports
= 0;
158 int pe_dll_compat_implib
= 0;
159 int pe_dll_extra_pe_debug
= 0;
160 int pe_use_nul_prefixed_import_tables
= 0;
161 int pe_use_coff_long_section_names
= -1;
162 int pe_leading_underscore
= -1;
163 int pe_dll_enable_reloc_section
= 1;
165 /* Static variables and types. */
167 static bfd_vma image_base
;
168 static bfd
*filler_bfd
;
169 static struct bfd_section
*edata_s
, *reloc_s
;
170 static unsigned char *edata_d
, *reloc_d
;
171 static size_t edata_sz
, reloc_sz
;
172 static int runtime_pseudo_relocs_created
= 0;
173 static bool runtime_pseudp_reloc_v2_init
= false;
180 autofilter_entry_type
;
184 const char *target_name
;
185 const char *object_target
;
186 unsigned int imagebase_reloc
;
190 const autofilter_entry_type
* autofilter_symbollist
;
194 static const autofilter_entry_type autofilter_symbollist_generic
[] =
196 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
197 /* Entry point symbols. */
198 { STRING_COMMA_LEN ("DllMain") },
199 { STRING_COMMA_LEN ("DllMainCRTStartup") },
200 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
201 /* Runtime pseudo-reloc. */
202 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
203 { STRING_COMMA_LEN ("do_pseudo_reloc") },
207 static const autofilter_entry_type autofilter_symbollist_i386
[] =
209 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
210 /* Entry point symbols, and entry hooks. */
211 { STRING_COMMA_LEN ("cygwin_crt0") },
213 { STRING_COMMA_LEN ("DllMain") },
214 { STRING_COMMA_LEN ("DllEntryPoint") },
215 { STRING_COMMA_LEN ("DllMainCRTStartup") },
216 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
217 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
218 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
220 { STRING_COMMA_LEN ("DllMain@12") },
221 { STRING_COMMA_LEN ("DllEntryPoint@0") },
222 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
223 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
224 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
225 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
226 { STRING_COMMA_LEN ("cygwin_attach_dll") },
228 { STRING_COMMA_LEN ("cygwin_premain0") },
229 { STRING_COMMA_LEN ("cygwin_premain1") },
230 { STRING_COMMA_LEN ("cygwin_premain2") },
231 { STRING_COMMA_LEN ("cygwin_premain3") },
232 /* Runtime pseudo-reloc. */
233 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
234 { STRING_COMMA_LEN ("do_pseudo_reloc") },
235 /* Global vars that should not be exported. */
236 { STRING_COMMA_LEN ("impure_ptr") },
237 { STRING_COMMA_LEN ("_impure_ptr") },
238 { STRING_COMMA_LEN ("_fmode") },
239 { STRING_COMMA_LEN ("environ") },
240 { STRING_COMMA_LEN ("__dso_handle") },
244 #define PE_ARCH_i386 1
246 #define PE_ARCH_mips 3
247 #define PE_ARCH_arm 4
248 #define PE_ARCH_arm_wince 5
250 /* Don't make it constant as underscore mode gets possibly overriden
251 by target or -(no-)leading-underscore option. */
252 static pe_details_type pe_detail_list
[] =
271 autofilter_symbollist_i386
281 autofilter_symbollist_i386
291 autofilter_symbollist_i386
297 16 /* R_SH_IMAGEBASE */,
301 autofilter_symbollist_generic
310 autofilter_symbollist_generic
319 autofilter_symbollist_generic
322 "pei-arm-wince-little",
323 "pe-arm-wince-little",
324 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
328 autofilter_symbollist_generic
330 { NULL
, NULL
, 0, 0, 0, false, NULL
}
333 static const pe_details_type
*pe_details
;
335 /* Do not specify library suffix explicitly, to allow for dllized versions. */
336 static const autofilter_entry_type autofilter_liblist
[] =
338 { STRING_COMMA_LEN ("libcegcc") },
339 { STRING_COMMA_LEN ("libcygwin") },
340 { STRING_COMMA_LEN ("libgcc") },
341 { STRING_COMMA_LEN ("libgcc_s") },
342 { STRING_COMMA_LEN ("libstdc++") },
343 { STRING_COMMA_LEN ("libmingw32") },
344 { STRING_COMMA_LEN ("libmingwex") },
345 { STRING_COMMA_LEN ("libg2c") },
346 { STRING_COMMA_LEN ("libsupc++") },
347 { STRING_COMMA_LEN ("libobjc") },
348 { STRING_COMMA_LEN ("libgcj") },
349 { STRING_COMMA_LEN ("libmsvcrt") },
350 { STRING_COMMA_LEN ("libmsvcrt-os") },
351 { STRING_COMMA_LEN ("libucrt") },
352 { STRING_COMMA_LEN ("libucrtbase") },
356 /* Regardless of the suffix issue mentioned above, we must ensure that
357 we do not falsely match on a leading substring, such as when libtool
358 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
359 This routine ensures that the leading part of the name matches and that
360 it is followed by only an optional version suffix and a file extension,
361 returning zero if so or -1 if not. */
362 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
364 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
367 libname
+= afptr
->len
;
369 /* Be liberal in interpreting what counts as a version suffix; we
370 accept anything that has a dash to separate it from the name and
371 begins with a digit. */
372 if (libname
[0] == '-')
374 if (!ISDIGIT (*++libname
))
376 /* Ensure the filename has an extension. */
377 while (*++libname
!= '.')
381 else if (libname
[0] != '.')
387 static const autofilter_entry_type autofilter_objlist
[] =
389 { STRING_COMMA_LEN ("crt0.o") },
390 { STRING_COMMA_LEN ("crt1.o") },
391 { STRING_COMMA_LEN ("crt2.o") },
392 { STRING_COMMA_LEN ("dllcrt1.o") },
393 { STRING_COMMA_LEN ("dllcrt2.o") },
394 { STRING_COMMA_LEN ("gcrt0.o") },
395 { STRING_COMMA_LEN ("gcrt1.o") },
396 { STRING_COMMA_LEN ("gcrt2.o") },
397 { STRING_COMMA_LEN ("crtbegin.o") },
398 { STRING_COMMA_LEN ("crtend.o") },
402 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
404 /* _imp_ is treated specially, as it is always underscored. */
405 /* { STRING_COMMA_LEN ("_imp_") }, */
406 /* Don't export some c++ symbols. */
407 { STRING_COMMA_LEN ("__rtti_") },
408 { STRING_COMMA_LEN ("__builtin_") },
409 /* Don't re-export auto-imported symbols. */
410 { STRING_COMMA_LEN ("__nm_") },
411 /* Don't export symbols specifying internal DLL layout. */
412 { STRING_COMMA_LEN ("_head_") },
413 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
414 /* Don't export section labels or artificial symbols
416 { STRING_COMMA_LEN (".") },
420 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
422 { STRING_COMMA_LEN ("_iname") },
423 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
427 #define U(str) (pe_details->underscored ? "_" str : str)
430 pe_dll_id_target (const char *target
)
434 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
435 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
436 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
438 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
440 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
443 pe_detail_list
[i
].underscored
= u
!= 0;
444 pe_details
= pe_detail_list
+ i
;
445 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
448 einfo (_("%X%P: unsupported PEI architecture: %s\n"), target
);
452 /* Helper functions for qsort. Relocs must be sorted so that we can write
453 them out by pages. */
465 reloc_sort (const void *va
, const void *vb
)
467 const reloc_data_type
*a
= (const reloc_data_type
*) va
;
468 const reloc_data_type
*b
= (const reloc_data_type
*) vb
;
482 pe_export_sort (const void *va
, const void *vb
)
484 const def_file_export
*a
= va
;
485 const def_file_export
*b
= vb
;
493 return strcmp (an
, bn
);
496 /* Read and process the .DEF file. */
498 /* These correspond to the entries in pe_def_file->exports[]. I use
499 exported_symbol_sections[i] to tag whether or not the symbol was
500 defined, since we can't export symbols we don't have. */
502 static bfd_vma
*exported_symbol_offsets
;
503 static struct bfd_section
**exported_symbol_sections
;
504 static int export_table_size
;
505 static int count_exported
;
506 static int count_exported_byname
;
507 static int count_with_ordinals
;
508 static const char *dll_name
;
509 static int min_ordinal
, max_ordinal
;
510 static int *exported_symbols
;
512 typedef struct exclude_list_struct
515 struct exclude_list_struct
*next
;
520 static struct exclude_list_struct
*excludes
= 0;
523 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
526 char *exclude_string
;
528 local_copy
= xstrdup (new_excludes
);
530 exclude_string
= strtok (local_copy
, ",:");
531 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
533 struct exclude_list_struct
*new_exclude
;
535 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
536 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
537 strcpy (new_exclude
->string
, exclude_string
);
538 new_exclude
->type
= type
;
539 new_exclude
->next
= excludes
;
540 excludes
= new_exclude
;
547 is_import (const char* n
)
549 return (startswith (n
, "__imp_"));
552 /* abfd is a bfd containing n (or NULL)
553 It can be used for contextual checks. */
556 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
559 struct exclude_list_struct
*ex
;
560 const autofilter_entry_type
*afptr
;
561 const char * libname
= NULL
;
563 if (abfd
&& abfd
->my_archive
)
564 libname
= lbasename (bfd_get_filename (abfd
->my_archive
));
566 key
.name
= key
.its_name
= (char *) n
;
568 /* Return false if n is in the d->exports table. */
569 if (d
->num_exports
!= 0
570 && bsearch (&key
, d
->exports
, d
->num_exports
,
571 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
574 if (pe_dll_do_default_excludes
)
579 if (pe_dll_extra_pe_debug
)
580 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
581 n
, abfd
, abfd
->my_archive
);
583 /* First of all, make context checks:
584 Don't export anything from standard libs. */
587 afptr
= autofilter_liblist
;
591 if (libnamencmp (libname
, afptr
) == 0 )
597 /* Next, exclude symbols from certain startup objects. */
599 if (abfd
&& (p
= lbasename (bfd_get_filename (abfd
))))
601 afptr
= autofilter_objlist
;
604 if (strcmp (p
, afptr
->name
) == 0)
610 /* Don't try to blindly exclude all symbols
611 that begin with '__'; this was tried and
612 it is too restrictive. Instead we have
613 a target specific list to use: */
614 afptr
= pe_details
->autofilter_symbollist
;
618 if (strcmp (n
, afptr
->name
) == 0)
624 /* Next, exclude symbols starting with ... */
625 afptr
= autofilter_symbolprefixlist
;
628 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
634 /* Finally, exclude symbols ending with ... */
636 afptr
= autofilter_symbolsuffixlist
;
639 if ((len
>= afptr
->len
)
640 /* Add 1 to insure match with trailing '\0'. */
641 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
642 afptr
->len
+ 1) == 0)
649 for (ex
= excludes
; ex
; ex
= ex
->next
)
651 if (ex
->type
== EXCLUDELIBS
)
654 && ((filename_cmp (libname
, ex
->string
) == 0)
655 || (strcasecmp ("ALL", ex
->string
) == 0)))
658 else if (ex
->type
== EXCLUDEFORIMPLIB
)
660 if (filename_cmp (bfd_get_filename (abfd
), ex
->string
) == 0)
663 else if (strcmp (n
, ex
->string
) == 0)
671 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
674 struct bfd_link_hash_entry
*blhe
;
676 struct bfd_section
*s
;
677 def_file_export
*e
= 0;
681 pe_def_file
= def_file_empty ();
683 /* First, run around to all the objects looking for the .drectve
684 sections, and push those into the def file too. */
685 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
687 s
= bfd_get_section_by_name (b
, ".drectve");
691 char *buf
= xmalloc (size
);
693 bfd_get_section_contents (b
, s
, buf
, 0, size
);
694 def_file_add_directive (pe_def_file
, buf
, size
);
699 /* Process aligned common symbol information from the
700 .drectve sections now; common symbol allocation is
701 done before final link, so it will be too late to
702 process them in process_embedded_commands() called
703 from _bfd_coff_link_input_bfd(). */
704 if (pe_def_file
->aligncomms
)
706 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
709 struct coff_link_hash_entry
*sym_hash
;
710 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
711 ac
->symbol_name
, false, false, false);
712 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
713 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
715 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
721 /* If we are building an executable and there is nothing
722 to export, we do not build an export table at all. */
723 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
724 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
727 /* Now, maybe export everything else the default way. */
728 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
729 && !pe_dll_exclude_all_symbols
)
731 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
736 if (!bfd_generic_link_read_symbols (b
))
738 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
742 symbols
= bfd_get_outsymbols (b
);
743 nsyms
= bfd_get_symcount (b
);
745 for (j
= 0; j
< nsyms
; j
++)
747 /* We should export symbols which are either global or not
748 anything at all. (.bss data is the latter)
749 We should not export undefined symbols. */
751 = (symbols
[j
]->section
!= bfd_und_section_ptr
752 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
753 || (symbols
[j
]->flags
== 0)));
754 if (link_info
.version_info
&& would_export
)
756 = !bfd_hide_sym_by_version (link_info
.version_info
,
760 const char *sn
= symbols
[j
]->name
;
762 /* We should not re-export imported stuff. */
768 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
769 sprintf (name
, "%s%s", "__imp_", sn
);
771 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
772 false, false, false);
775 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
779 if (pe_details
->underscored
&& *sn
== '_')
782 if (auto_export (b
, pe_def_file
, sn
))
787 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
789 /* Fill data flag properly, from dlltool.c. */
791 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
799 #define NE pe_def_file->num_exports
801 /* Don't create an empty export table. */
805 resort_needed
= false;
807 /* Canonicalize the export list. */
810 for (i
= 0; i
< NE
; i
++)
812 /* Check for fastcall/stdcall-decoration, but ignore
813 C++ mangled names. */
814 if (pe_def_file
->exports
[i
].name
[0] != '?'
815 && strchr (pe_def_file
->exports
[i
].name
, '@'))
817 /* This will preserve internal_name, which may have been
818 pointing to the same memory as name, or might not
820 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
821 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
822 char *tmp_at
= strrchr (tmp
, '@');
827 einfo (_("%X%P: cannot export %s: invalid export name\n"),
828 pe_def_file
->exports
[i
].name
);
829 pe_def_file
->exports
[i
].name
= tmp
;
830 resort_needed
= true;
835 /* Re-sort the exports table as we have possibly changed the order
836 by removing leading @. */
838 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
841 if (pe_dll_stdcall_aliases
)
843 for (i
= 0; i
< NE
; i
++)
845 if (is_import (pe_def_file
->exports
[i
].name
))
848 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
851 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
852 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
854 *(strchr (tmp
, '@')) = 0;
855 if (auto_export (NULL
, pe_def_file
, tmp
))
856 def_file_add_export (pe_def_file
, tmp
,
857 pe_def_file
->exports
[i
].internal_name
,
865 /* Convenience, but watch out for it changing. */
866 e
= pe_def_file
->exports
;
868 for (i
= 0, j
= 0; i
< NE
; i
++)
870 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
872 /* This is a duplicate. */
873 if (e
[j
- 1].ordinal
!= -1
874 && e
[i
].ordinal
!= -1
875 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
877 if (pe_dll_warn_dup_exports
)
878 /* xgettext:c-format */
879 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
880 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
884 if (pe_dll_warn_dup_exports
)
885 /* xgettext:c-format */
886 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
890 if (e
[i
].ordinal
!= -1)
891 e
[j
- 1].ordinal
= e
[i
].ordinal
;
892 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
893 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
894 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
895 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
897 free (e
[i
].internal_name
);
898 free (e
[i
].its_name
);
907 pe_def_file
->num_exports
= j
; /* == NE */
909 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
910 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
912 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
916 count_exported_byname
= 0;
917 count_with_ordinals
= 0;
919 for (i
= 0; i
< NE
; i
++)
921 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
924 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
925 lang_add_gc_name (int_name
);
927 name
= xmalloc (strlen (int_name
) + 2);
928 if (pe_details
->underscored
&& int_name
[0] != '@')
931 strcpy (name
+ 1, int_name
);
933 /* PR 19803: The alias must be preserved as well. */
934 lang_add_gc_name (xstrdup (name
));
937 strcpy (name
, int_name
);
939 blhe
= bfd_link_hash_lookup (info
->hash
,
944 && (blhe
->type
== bfd_link_hash_defined
945 || (blhe
->type
== bfd_link_hash_common
)))
948 if (!pe_def_file
->exports
[i
].flag_noname
)
949 count_exported_byname
++;
951 /* Only fill in the sections. The actual offsets are computed
952 in fill_exported_offsets() after common symbols are laid
954 if (blhe
->type
== bfd_link_hash_defined
)
955 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
957 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
959 if (pe_def_file
->exports
[i
].ordinal
!= -1)
961 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
962 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
963 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
964 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
965 count_with_ordinals
++;
968 /* Check for forward exports. These are indicated in DEF files by an
969 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
970 but we must take care not to be fooled when the user wants to export
971 a symbol that actually really has a dot in it, so we only check
972 for them here, after real defined symbols have already been matched. */
973 else if (strchr (int_name
, '.'))
976 if (!pe_def_file
->exports
[i
].flag_noname
)
977 count_exported_byname
++;
979 pe_def_file
->exports
[i
].flag_forward
= 1;
981 if (pe_def_file
->exports
[i
].ordinal
!= -1)
983 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
984 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
985 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
986 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
987 count_with_ordinals
++;
990 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
992 /* xgettext:c-format */
993 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
998 /* xgettext:c-format */
999 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
1001 blhe
->type
, bfd_link_hash_defined
);
1005 /* xgettext:c-format */
1006 einfo (_("%X%P: cannot export %s: symbol not found\n"),
1013 /* Build the bfd that will contain .edata and .reloc sections. */
1016 build_filler_bfd (int include_edata
)
1018 lang_input_statement_type
*filler_file
;
1019 filler_file
= lang_add_input_file ("dll stuff",
1020 lang_input_file_is_fake_enum
,
1022 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1023 link_info
.output_bfd
);
1024 if (filler_bfd
== NULL
1025 || !bfd_set_arch_mach (filler_bfd
,
1026 bfd_get_arch (link_info
.output_bfd
),
1027 bfd_get_mach (link_info
.output_bfd
)))
1029 einfo (_("%F%P: can not create BFD: %E\n"));
1035 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1037 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1043 einfo (_("%X%P: can not create .edata section: %E\n"));
1046 bfd_set_section_size (edata_s
, edata_sz
);
1049 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1051 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1057 einfo (_("%X%P: can not create .reloc section: %E\n"));
1061 bfd_set_section_size (reloc_s
, 0);
1063 ldlang_add_file (filler_file
);
1066 /* Gather all the exported symbols and build the .edata section. */
1069 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1071 int i
, next_ordinal
;
1072 int name_table_size
= 0;
1075 /* First, we need to know how many exported symbols there are,
1076 and what the range of ordinals is. */
1077 if (pe_def_file
->name
)
1078 dll_name
= pe_def_file
->name
;
1081 dll_name
= bfd_get_filename (abfd
);
1083 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1084 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1085 dll_name
= dlnp
+ 1;
1088 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1090 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1091 min_ordinal
= max_ordinal
- count_exported
+ 1;
1096 max_ordinal
= count_exported
;
1099 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1100 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1101 for (i
= 0; i
< export_table_size
; i
++)
1102 exported_symbols
[i
] = -1;
1104 /* Now we need to assign ordinals to those that don't have them. */
1105 for (i
= 0; i
< NE
; i
++)
1107 if (exported_symbol_sections
[i
]
1108 || pe_def_file
->exports
[i
].flag_forward
)
1110 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1112 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1113 int pi
= exported_symbols
[ei
];
1117 /* xgettext:c-format */
1118 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1119 pe_def_file
->exports
[i
].ordinal
,
1120 pe_def_file
->exports
[i
].name
,
1121 pe_def_file
->exports
[pi
].name
);
1123 exported_symbols
[ei
] = i
;
1125 if (pe_def_file
->exports
[i
].its_name
)
1126 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1128 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1131 /* Reserve space for the forward name. */
1132 if (pe_def_file
->exports
[i
].flag_forward
)
1134 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1138 next_ordinal
= min_ordinal
;
1139 for (i
= 0; i
< NE
; i
++)
1140 if ((exported_symbol_sections
[i
]
1141 || pe_def_file
->exports
[i
].flag_forward
)
1142 && pe_def_file
->exports
[i
].ordinal
== -1)
1144 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1147 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1148 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1151 /* PR 12969: Check for more than 1^16 ordinals. */
1152 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1153 /* xgettext:c-format */
1154 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1155 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1157 /* OK, now we can allocate some memory. */
1158 edata_sz
= (40 /* directory */
1159 + 4 * export_table_size
/* addresses */
1160 + 4 * count_exported_byname
/* name ptrs */
1161 + 2 * count_exported_byname
/* ordinals */
1162 + name_table_size
+ strlen (dll_name
) + 1);
1165 /* Fill the exported symbol offsets. The preliminary work has already
1166 been done in process_def_file_and_drectve(). */
1169 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1172 struct bfd_link_hash_entry
*blhe
;
1174 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1178 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1179 if (pe_details
->underscored
1180 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1183 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1186 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1188 blhe
= bfd_link_hash_lookup (info
->hash
,
1190 false, false, true);
1192 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1193 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1200 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1203 unsigned char *edirectory
;
1204 unsigned char *eaddresses
;
1205 unsigned char *enameptrs
;
1206 unsigned char *eordinals
;
1209 edata_d
= xmalloc (edata_sz
);
1211 /* Note use of array pointer math here. */
1212 edirectory
= edata_d
;
1213 eaddresses
= edirectory
+ 40;
1214 enameptrs
= eaddresses
+ 4 * export_table_size
;
1215 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1216 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1218 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1219 + edata_s->output_section->vma - image_base)
1221 memset (edata_d
, 0, edata_sz
);
1223 if (pe_data (abfd
)->timestamp
== -1)
1224 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1226 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, edata_d
+ 4);
1228 if (pe_def_file
->version_major
!= -1)
1230 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1231 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1234 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1235 strcpy (enamestr
, dll_name
);
1236 enamestr
+= strlen (enamestr
) + 1;
1237 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1238 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1239 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1240 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1241 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1242 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1244 fill_exported_offsets (abfd
, info
);
1246 /* Ok, now for the filling in part.
1247 Scan alphabetically - ie the ordering in the exports[] table,
1248 rather than by ordinal - the ordering in the exported_symbol[]
1249 table. See dlltool.c and:
1250 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1251 for more information. */
1253 for (s
= 0; s
< NE
; s
++)
1255 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1256 if (pe_def_file
->exports
[s
].ordinal
!= -1
1257 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1259 int ord
= pe_def_file
->exports
[s
].ordinal
;
1261 if (pe_def_file
->exports
[s
].flag_forward
)
1263 bfd_put_32 (abfd
, ERVA (enamestr
),
1264 eaddresses
+ 4 * (ord
- min_ordinal
));
1266 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1267 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1271 bfd_vma srva
= (exported_symbol_offsets
[s
]
1272 + ssec
->output_section
->vma
1273 + ssec
->output_offset
);
1275 bfd_put_32 (abfd
, srva
- image_base
,
1276 eaddresses
+ 4 * (ord
- min_ordinal
));
1279 if (!pe_def_file
->exports
[s
].flag_noname
)
1281 char *ename
= pe_def_file
->exports
[s
].name
;
1282 if (pe_def_file
->exports
[s
].its_name
)
1283 ename
= pe_def_file
->exports
[s
].its_name
;
1285 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1287 strcpy (enamestr
, ename
);
1288 enamestr
+= strlen (enamestr
) + 1;
1289 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1291 pe_def_file
->exports
[s
].hint
= hint
++;
1298 static struct bfd_section
*current_sec
;
1301 pe_walk_relocs (struct bfd_link_info
*info
,
1303 const char *symname
,
1304 struct bfd_hash_table
*import_hash
,
1305 void (*cb
) (arelent
*, asection
*, char *, const char *))
1310 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1314 if (!bfd_generic_link_read_symbols (b
))
1316 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1320 symbols
= bfd_get_outsymbols (b
);
1322 for (s
= b
->sections
; s
; s
= s
->next
)
1325 int relsize
, nrelocs
, i
;
1326 int flags
= bfd_section_flags (s
);
1328 /* Skip discarded linkonce sections. */
1329 if (flags
& SEC_LINK_ONCE
1330 && s
->output_section
== bfd_abs_section_ptr
)
1335 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1336 relocs
= xmalloc (relsize
);
1337 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1339 for (i
= 0; i
< nrelocs
; i
++)
1341 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1343 /* Warning: the callback needs to be passed NAME directly. */
1346 if (bfd_hash_lookup (import_hash
, sym
->name
, false, false))
1348 strcpy (name
, sym
->name
);
1349 cb (relocs
[i
], s
, name
, symname
);
1354 if (strcmp (name
, sym
->name
) == 0)
1355 cb (relocs
[i
], s
, name
, symname
);
1361 /* Warning: the allocated symbols are remembered in BFD and reused
1362 later, so don't free them! */
1363 /* free (symbols); */
1369 pe_find_data_imports (const char *symhead
,
1370 void (*cb
) (arelent
*, asection
*, char *, const char *))
1372 struct bfd_link_hash_entry
*undef
;
1373 const size_t headlen
= strlen (symhead
);
1376 struct bfd_hash_table
*import_hash
;
1378 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1379 if (undef
->type
== bfd_link_hash_undefined
)
1381 size_t len
= strlen (undef
->root
.string
);
1388 /* For the pseudo-relocation support version 2, we can collect the symbols
1389 that are subject to auto-import and adjust the relocations en masse. */
1390 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1393 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1394 if (!bfd_hash_table_init (import_hash
,
1396 sizeof (struct bfd_hash_entry
)))
1397 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1402 /* We are being a bit cunning here. The buffer will have space for
1403 prefixes at the beginning. The prefix is modified here and in a
1404 number of functions called from this function. */
1405 #define PREFIX_LEN 32
1406 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1407 name
= buf
+ PREFIX_LEN
;
1409 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1410 if (undef
->type
== bfd_link_hash_undefined
)
1412 struct bfd_link_hash_entry
*sym
;
1415 if (pe_dll_extra_pe_debug
)
1416 printf ("%s:%s\n", __FUNCTION__
, undef
->root
.string
);
1418 strcpy (name
, undef
->root
.string
);
1419 impname
= name
- (sizeof "__imp_" - 1);
1420 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1422 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1424 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1427 bfd_hash_lookup (import_hash
, undef
->root
.string
, true, false);
1430 bfd
*b
= sym
->u
.def
.section
->owner
;
1431 const char *symname
= NULL
;
1435 if (!bfd_generic_link_read_symbols (b
))
1437 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1441 symbols
= bfd_get_outsymbols (b
);
1442 nsyms
= bfd_get_symcount (b
);
1444 for (i
= 0; i
< nsyms
; i
++)
1445 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1447 if (pe_dll_extra_pe_debug
)
1448 printf ("->%s\n", symbols
[i
]->name
);
1450 symname
= symbols
[i
]->name
+ headlen
;
1454 /* If the symobl isn't part of an import table, there is no
1455 point in building a fixup, this would give rise to link
1456 errors for mangled symbols instead of the original one. */
1458 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1463 /* Let's differentiate it somehow from defined. */
1464 undef
->type
= bfd_link_hash_defweak
;
1465 undef
->u
.def
.value
= sym
->u
.def
.value
;
1466 undef
->u
.def
.section
= sym
->u
.def
.section
;
1468 /* We replace the original name with the __imp_ prefixed one, this
1469 1) may trash memory 2) leads to duplicate symbols. But this is
1470 better than having a misleading name that can confuse GDB. */
1471 undef
->root
.string
= sym
->root
.string
;
1473 if (link_info
.pei386_auto_import
== -1)
1475 static bool warned
= false;
1477 info_msg (_("Info: resolving %s by linking to %s "
1478 "(auto-import)\n"), name
, impname
);
1480 /* PR linker/4844. */
1483 einfo (_("%P: warning: auto-importing has been activated "
1484 "without --enable-auto-import specified on the "
1485 "command line; this should work unless it "
1486 "involves constant data structures referencing "
1487 "symbols from auto-imported DLLs\n"));
1494 /* If we have the import hash table, walk the relocations only once. */
1497 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1498 bfd_hash_table_free (import_hash
);
1505 /* Gather all the relocations and build the .reloc section. */
1508 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1510 /* For .reloc stuff. */
1511 reloc_data_type
*reloc_data
;
1512 int total_relocs
= 0;
1514 bfd_vma sec_page
= (bfd_vma
) -1;
1515 bfd_vma page_ptr
, page_count
;
1518 struct bfd_section
*s
;
1520 if (reloc_s
== NULL
|| reloc_s
->output_section
== bfd_abs_section_ptr
)
1523 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1524 for (s
= b
->sections
; s
; s
= s
->next
)
1525 total_relocs
+= s
->reloc_count
;
1527 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1531 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1534 int relsize
, nrelocs
;
1536 for (s
= b
->sections
; s
; s
= s
->next
)
1538 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1541 /* If it's not loaded, we don't need to relocate it this way. */
1542 if (!(s
->output_section
->flags
& SEC_LOAD
))
1545 /* I don't know why there would be a reloc for these, but I've
1546 seen it happen - DJ */
1547 if (s
->output_section
== bfd_abs_section_ptr
)
1550 if (s
->output_section
->vma
== 0)
1552 /* Huh? Shouldn't happen, but punt if it does. */
1553 #if 0 /* This happens when linking with --just-symbols=<file>, so do not generate an error. */
1554 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1555 s
->output_section
->name
, s
->output_section
->index
,
1556 s
->output_section
->flags
);
1561 if (!bfd_generic_link_read_symbols (b
))
1563 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1567 symbols
= bfd_get_outsymbols (b
);
1568 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1569 relocs
= xmalloc (relsize
);
1570 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1572 for (i
= 0; i
< nrelocs
; i
++)
1574 if (pe_dll_extra_pe_debug
)
1576 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1577 printf ("rel: %s\n", sym
->name
);
1579 if (!relocs
[i
]->howto
->pc_relative
1580 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1582 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1583 const struct bfd_link_hash_entry
*blhe
1584 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1585 false, false, false);
1587 /* Don't create relocs for undefined weak symbols. */
1588 if (sym
->flags
== BSF_WEAK
)
1590 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1592 /* Check aux sym and see if it is defined or not. */
1593 struct coff_link_hash_entry
*h
, *h2
;
1594 h
= (struct coff_link_hash_entry
*)blhe
;
1595 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1597 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1598 [h
->aux
->x_sym
.x_tagndx
.l
];
1599 /* We don't want a base reloc if the aux sym is not
1600 found, undefined, or if it is the constant ABS
1601 zero default value. (We broaden that slightly by
1602 not testing the value, just the section; there's
1603 no reason we'd want a reference to any absolute
1604 address to get relocated during rebasing). */
1605 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1606 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1609 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1612 /* Nor for Dwarf FDE references to discarded sections. */
1613 else if (bfd_is_abs_section (sym
->section
->output_section
))
1615 /* We only ignore relocs from .eh_frame sections, as
1616 they are discarded by the final link rather than
1617 resolved against the kept section. */
1618 if (!strcmp (s
->name
, ".eh_frame"))
1621 /* Nor for absolute symbols. */
1622 else if (blhe
&& ldexp_is_final_sym_absolute (blhe
)
1623 && (!blhe
->linker_def
1624 || (strcmp (sym
->name
, "__image_base__")
1625 && strcmp (sym
->name
, U ("__ImageBase")))))
1628 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1629 reloc_data
[total_relocs
].idx
= total_relocs
;
1631 /* Since we're only about to determine .reloc's size,
1632 subsequent output section VMA calculations will shift up
1633 sections at this or higher addresses. Relocations for
1634 such sections would hence end up not being correct. */
1635 if (reloc_data
[total_relocs
].vma
1636 >= reloc_s
->output_section
->vma
)
1637 einfo (_("%P: base relocation for section `%s' above "
1638 ".reloc section\n"), s
->output_section
->name
);
1640 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1642 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1643 relocs
[i
]->howto
->rightshift
)
1645 #ifdef pe_use_x86_64
1646 case BITS_AND_SHIFT (64, 0):
1647 reloc_data
[total_relocs
].type
= 10;
1651 case BITS_AND_SHIFT (32, 0):
1652 reloc_data
[total_relocs
].type
= 3;
1655 case BITS_AND_SHIFT (16, 0):
1656 reloc_data
[total_relocs
].type
= 2;
1659 case BITS_AND_SHIFT (16, 16):
1660 reloc_data
[total_relocs
].type
= 4;
1661 /* FIXME: we can't know the symbol's right value
1662 yet, but we probably can safely assume that
1663 CE will relocate us in 64k blocks, so leaving
1665 reloc_data
[total_relocs
].extra
= 0;
1668 case BITS_AND_SHIFT (26, 2):
1669 reloc_data
[total_relocs
].type
= 5;
1672 case BITS_AND_SHIFT (24, 2):
1673 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1674 Those ARM_xxx definitions should go in proper
1676 if (relocs
[i
]->howto
->type
== 0
1677 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1678 || relocs
[i
]->howto
->type
== 5)
1679 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1680 that has already been fully processed during a
1681 previous link stage, so ignore it here. */
1685 /* xgettext:c-format */
1686 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1687 relocs
[i
]->howto
->bitsize
);
1693 /* Warning: the allocated symbols are remembered in BFD and
1694 reused later, so don't free them! */
1698 /* At this point, we have total_relocs relocation addresses in
1699 reloc_addresses, which are all suitable for the .reloc section.
1700 We must now create the new sections. */
1701 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1703 for (i
= 0; i
< total_relocs
; i
++)
1705 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1707 if (this_page
!= sec_page
)
1709 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1711 sec_page
= this_page
;
1716 if (reloc_data
[i
].type
== 4)
1720 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1721 reloc_d
= xmalloc (reloc_sz
);
1722 sec_page
= (bfd_vma
) -1;
1724 page_ptr
= (bfd_vma
) -1;
1727 for (i
= 0; i
< total_relocs
; i
++)
1729 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1730 bfd_vma this_page
= (rva
& ~0xfff);
1732 if (this_page
!= sec_page
)
1734 while (reloc_sz
& 3)
1735 reloc_d
[reloc_sz
++] = 0;
1737 if (page_ptr
!= (bfd_vma
) -1)
1738 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1740 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1741 page_ptr
= reloc_sz
;
1743 sec_page
= this_page
;
1747 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1748 reloc_d
+ reloc_sz
);
1751 if (reloc_data
[i
].type
== 4)
1753 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1760 while (reloc_sz
& 3)
1761 reloc_d
[reloc_sz
++] = 0;
1763 if (page_ptr
!= (bfd_vma
) -1)
1764 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1767 /* Given the exiting def_file structure, print out a .DEF file that
1768 corresponds to it. */
1771 quoteput (char *s
, FILE *f
, int needs_quotes
)
1775 for (cp
= s
; *cp
; cp
++)
1790 if (*s
== '"' || *s
== '\\')
1804 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1807 FILE *out
= fopen (pe_out_def_filename
, "w");
1810 /* xgettext:c-format */
1811 einfo (_("%P: can't open output def file %s\n"),
1812 pe_out_def_filename
);
1816 if (pe_def_file
->name
)
1818 if (pe_def_file
->is_dll
)
1819 fprintf (out
, "LIBRARY ");
1821 fprintf (out
, "NAME ");
1823 quoteput (pe_def_file
->name
, out
, 1);
1825 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1827 fprintf (out
, " BASE=0x");
1828 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1830 fprintf (out
, "\n");
1833 if (pe_def_file
->description
)
1835 fprintf (out
, "DESCRIPTION ");
1836 quoteput (pe_def_file
->description
, out
, 1);
1837 fprintf (out
, "\n");
1840 if (pe_def_file
->version_minor
!= -1)
1841 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1842 pe_def_file
->version_minor
);
1843 else if (pe_def_file
->version_major
!= -1)
1844 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1846 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1847 fprintf (out
, "\n");
1849 if (pe_def_file
->stack_commit
!= -1)
1850 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1851 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1852 else if (pe_def_file
->stack_reserve
!= -1)
1853 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1855 if (pe_def_file
->heap_commit
!= -1)
1856 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1857 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1858 else if (pe_def_file
->heap_reserve
!= -1)
1859 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1861 if (pe_def_file
->num_section_defs
> 0)
1863 fprintf (out
, "\nSECTIONS\n\n");
1865 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1868 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1870 if (pe_def_file
->section_defs
[i
].class)
1872 fprintf (out
, " CLASS ");
1873 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1876 if (pe_def_file
->section_defs
[i
].flag_read
)
1877 fprintf (out
, " READ");
1879 if (pe_def_file
->section_defs
[i
].flag_write
)
1880 fprintf (out
, " WRITE");
1882 if (pe_def_file
->section_defs
[i
].flag_execute
)
1883 fprintf (out
, " EXECUTE");
1885 if (pe_def_file
->section_defs
[i
].flag_shared
)
1886 fprintf (out
, " SHARED");
1888 fprintf (out
, "\n");
1892 if (pe_def_file
->num_exports
> 0)
1894 fprintf (out
, "EXPORTS\n");
1896 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1898 def_file_export
*e
= pe_def_file
->exports
+ i
;
1900 quoteput (e
->name
, out
, 0);
1902 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1904 fprintf (out
, " = ");
1905 quoteput (e
->internal_name
, out
, 0);
1908 if (e
->ordinal
!= -1)
1909 fprintf (out
, " @%d", e
->ordinal
);
1911 if (e
->flag_private
)
1912 fprintf (out
, " PRIVATE");
1914 if (e
->flag_constant
)
1915 fprintf (out
, " CONSTANT");
1918 fprintf (out
, " NONAME");
1921 fprintf (out
, " DATA");
1923 fprintf (out
, "\n");
1927 if (pe_def_file
->num_imports
> 0)
1929 fprintf (out
, "\nIMPORTS\n\n");
1931 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1933 def_file_import
*im
= pe_def_file
->imports
+ i
;
1936 if (im
->internal_name
1937 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1939 quoteput (im
->internal_name
, out
, 0);
1940 fprintf (out
, " = ");
1943 quoteput (im
->module
->name
, out
, 0);
1947 quoteput (im
->name
, out
, 0);
1949 fprintf (out
, "%d", im
->ordinal
);
1953 fprintf (out
, " == ");
1954 quoteput (im
->its_name
, out
, 0);
1957 fprintf (out
, "\n");
1962 fprintf (out
, _("; no contents available\n"));
1964 if (fclose (out
) == EOF
)
1965 /* xgettext:c-format */
1966 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1969 /* Generate the import library. */
1971 static asymbol
**symtab
;
1974 static const char *dll_filename
;
1975 static char *dll_symname
;
1976 static int dll_symname_len
;
1978 #define UNDSEC bfd_und_section_ptr
1981 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1986 sec
= bfd_make_section_old_way (abfd
, name
);
1987 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1988 bfd_set_section_alignment (sec
, align
);
1989 /* Remember to undo this before trying to link internally! */
1990 sec
->output_section
= sec
;
1992 sym
= bfd_make_empty_symbol (abfd
);
1993 symtab
[symptr
++] = sym
;
1994 sym
->name
= sec
->name
;
1996 sym
->flags
= BSF_LOCAL
;
2003 quick_symbol (bfd
*abfd
,
2012 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
2017 sym
= bfd_make_empty_symbol (abfd
);
2022 symtab
[symptr
++] = sym
;
2025 static arelent
*reltab
= 0;
2026 static int relcount
= 0, relsize
= 0;
2029 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2031 if (relcount
>= relsize
- 1)
2035 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2037 reltab
= xmalloc (relsize
* sizeof (arelent
));
2039 reltab
[relcount
].address
= address
;
2040 reltab
[relcount
].addend
= 0;
2041 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2042 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2047 save_relocs (asection
*sec
)
2051 sec
->relocation
= reltab
;
2052 sec
->reloc_count
= relcount
;
2053 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2054 for (i
= 0; i
< relcount
; i
++)
2055 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2056 sec
->orelocation
[relcount
] = 0;
2057 sec
->flags
|= SEC_RELOC
;
2059 relcount
= relsize
= 0;
2062 /* .section .idata$2
2063 .global __head_my_dll
2080 make_head (bfd
*parent
)
2082 asection
*id2
, *id5
, *id4
;
2083 unsigned char *d2
, *d5
, *d4
;
2087 oname
= xmalloc (20 + dll_symname_len
);
2088 sprintf (oname
, "%s_d%06d.o", dll_symname
, tmp_seq
);
2091 abfd
= bfd_create (oname
, parent
);
2092 bfd_find_target (pe_details
->object_target
, abfd
);
2093 bfd_make_writable (abfd
);
2095 bfd_set_format (abfd
, bfd_object
);
2096 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2099 symtab
= xmalloc (6 * sizeof (asymbol
*));
2100 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2101 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2102 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2103 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2104 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2106 /* OK, pay attention here. I got confused myself looking back at
2107 it. We create a four-byte section to mark the beginning of the
2108 list, and we include an offset of 4 in the section, so that the
2109 pointer to the list points to the *end* of this section, which is
2110 the start of the list of sections from other objects. */
2112 bfd_set_section_size (id2
, 20);
2116 if (pe_use_nul_prefixed_import_tables
)
2117 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2118 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2119 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2120 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2123 if (pe_use_nul_prefixed_import_tables
)
2124 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2126 bfd_set_section_size (id5
, 0);
2127 d5
= xmalloc (PE_IDATA5_SIZE
);
2129 memset (d5
, 0, PE_IDATA5_SIZE
);
2130 if (pe_use_nul_prefixed_import_tables
)
2131 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2133 bfd_set_section_size (id4
, 0);
2134 d4
= xmalloc (PE_IDATA4_SIZE
);
2136 memset (d4
, 0, PE_IDATA4_SIZE
);
2138 bfd_set_symtab (abfd
, symtab
, symptr
);
2140 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2141 if (pe_use_nul_prefixed_import_tables
)
2143 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2144 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2148 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2149 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2152 bfd_make_readable (abfd
);
2156 /* .section .idata$4
2163 .global __my_dll_iname
2168 make_tail (bfd
*parent
)
2170 asection
*id4
, *id5
, *id7
;
2171 unsigned char *d4
, *d5
, *d7
;
2176 oname
= xmalloc (20 + dll_symname_len
);
2177 sprintf (oname
, "%s_d%06d.o", dll_symname
, tmp_seq
);
2180 abfd
= bfd_create (oname
, parent
);
2181 bfd_find_target (pe_details
->object_target
, abfd
);
2182 bfd_make_writable (abfd
);
2184 bfd_set_format (abfd
, bfd_object
);
2185 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2188 symtab
= xmalloc (5 * sizeof (asymbol
*));
2189 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2190 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2191 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2192 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2194 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2195 d4
= xmalloc (PE_IDATA4_SIZE
);
2197 memset (d4
, 0, PE_IDATA4_SIZE
);
2199 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2200 d5
= xmalloc (PE_IDATA5_SIZE
);
2202 memset (d5
, 0, PE_IDATA5_SIZE
);
2204 len
= strlen (dll_filename
) + 1;
2207 bfd_set_section_size (id7
, len
);
2210 strcpy ((char *) d7
, dll_filename
);
2211 /* If len was odd, the above
2212 strcpy leaves behind an undefined byte. That is harmless,
2213 but we set it to 0 just so the binary dumps are pretty. */
2216 bfd_set_symtab (abfd
, symtab
, symptr
);
2218 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2219 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2220 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2222 bfd_make_readable (abfd
);
2228 .global ___imp_function
2229 .global __imp__function
2231 jmp *__imp__function:
2245 .asciz "function" xlate? (add underscore, kill at) */
2247 static const unsigned char jmp_ix86_bytes
[] =
2249 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2257 .dw __imp_function */
2259 static const unsigned char jmp_sh_bytes
[] =
2261 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2265 lui $t0,<high:__imp_function>
2266 lw $t0,<low:__imp_function>
2270 static const unsigned char jmp_mips_bytes
[] =
2272 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2273 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2276 static const unsigned char jmp_arm_bytes
[] =
2278 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2279 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2285 make_one (def_file_export
*exp
, bfd
*parent
, bool include_jmp_stub
)
2287 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2288 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2292 const unsigned char *jmp_bytes
= NULL
;
2293 int jmp_byte_count
= 0;
2295 /* Include the jump stub section only if it is needed. A jump
2296 stub is needed if the symbol being imported <sym> is a function
2297 symbol and there is at least one undefined reference to that
2298 symbol. In other words, if all the import references to <sym> are
2299 explicitly through _declspec(dllimport) then the jump stub is not
2301 if (include_jmp_stub
)
2303 switch (pe_details
->pe_arch
)
2306 jmp_bytes
= jmp_ix86_bytes
;
2307 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2310 jmp_bytes
= jmp_sh_bytes
;
2311 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2314 jmp_bytes
= jmp_mips_bytes
;
2315 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2318 case PE_ARCH_arm_wince
:
2319 jmp_bytes
= jmp_arm_bytes
;
2320 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2327 oname
= xmalloc (20 + dll_symname_len
);
2328 sprintf (oname
, "%s_d%06d.o", dll_symname
, tmp_seq
);
2331 abfd
= bfd_create (oname
, parent
);
2332 bfd_find_target (pe_details
->object_target
, abfd
);
2333 bfd_make_writable (abfd
);
2335 bfd_set_format (abfd
, bfd_object
);
2336 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2339 symtab
= xmalloc (12 * sizeof (asymbol
*));
2341 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2342 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2343 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2344 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2345 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2347 if (*exp
->internal_name
== '@')
2349 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2351 if (include_jmp_stub
)
2352 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2353 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2355 /* Fastcall applies only to functions,
2356 so no need for auto-import symbol. */
2360 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2362 if (include_jmp_stub
)
2363 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2365 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2367 /* Symbol to reference ord/name of imported
2368 data symbol, used to implement auto-import. */
2370 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2373 if (pe_dll_compat_implib
)
2374 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2377 if (include_jmp_stub
)
2379 bfd_set_section_size (tx
, jmp_byte_count
);
2380 td
= xmalloc (jmp_byte_count
);
2382 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2384 switch (pe_details
->pe_arch
)
2387 #ifdef pe_use_x86_64
2388 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2390 /* Mark this object as SAFESEH compatible. */
2391 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2393 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2397 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2400 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2401 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2402 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2405 case PE_ARCH_arm_wince
:
2406 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2414 bfd_set_section_size (tx
, 0);
2416 bfd_set_section_size (id7
, 4);
2420 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2423 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2424 d5
= xmalloc (PE_IDATA5_SIZE
);
2426 memset (d5
, 0, PE_IDATA5_SIZE
);
2428 if (exp
->flag_noname
)
2430 d5
[0] = exp
->ordinal
;
2431 d5
[1] = exp
->ordinal
>> 8;
2432 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2436 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2440 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2441 d4
= xmalloc (PE_IDATA4_SIZE
);
2443 memset (d4
, 0, PE_IDATA4_SIZE
);
2445 if (exp
->flag_noname
)
2447 d4
[0] = exp
->ordinal
;
2448 d4
[1] = exp
->ordinal
>> 8;
2449 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2453 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2457 if (exp
->flag_noname
)
2460 bfd_set_section_size (id6
, 0);
2466 /* { short, asciz } */
2468 len
= 2 + strlen (exp
->its_name
) + 1;
2470 len
= 2 + strlen (exp
->name
) + 1;
2473 bfd_set_section_size (id6
, len
);
2476 memset (d6
, 0, len
);
2478 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2479 contains an invalid value (-1). */
2480 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2485 strcpy ((char*) d6
+ 2, exp
->its_name
);
2487 strcpy ((char *) d6
+ 2, exp
->name
);
2490 bfd_set_symtab (abfd
, symtab
, symptr
);
2492 if (include_jmp_stub
)
2493 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2494 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2495 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2496 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2497 if (!exp
->flag_noname
)
2498 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2500 bfd_make_readable (abfd
);
2505 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2507 /* Name thunks go to idata$4. */
2513 oname
= xmalloc (20 + dll_symname_len
);
2514 sprintf (oname
, "%s_nmth%06d.o", dll_symname
, tmp_seq
);
2517 abfd
= bfd_create (oname
, parent
);
2518 bfd_find_target (pe_details
->object_target
, abfd
);
2519 bfd_make_writable (abfd
);
2521 bfd_set_format (abfd
, bfd_object
);
2522 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2525 symtab
= xmalloc (3 * sizeof (asymbol
*));
2526 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2527 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2528 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2530 /* We need space for the real thunk and for the null terminator. */
2531 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2532 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2534 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2535 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2538 bfd_set_symtab (abfd
, symtab
, symptr
);
2540 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2542 bfd_make_readable (abfd
);
2547 make_import_fixup_mark (arelent
*rel
, char *name
)
2549 /* We convert reloc to symbol, for later reference. */
2550 static unsigned int counter
;
2551 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2552 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2553 struct bfd_link_hash_entry
*bh
;
2554 char *fixup_name
, buf
[26];
2557 /* "name" buffer has space before the symbol name for prefixes. */
2558 sprintf (buf
, "__fu%d_", counter
++);
2559 prefix_len
= strlen (buf
);
2560 fixup_name
= name
- prefix_len
;
2561 memcpy (fixup_name
, buf
, prefix_len
);
2564 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2565 current_sec
, /* sym->section, */
2566 rel
->address
, NULL
, true, false, &bh
);
2568 return bh
->root
.string
;
2571 /* .section .idata$2
2572 .rva __nm_thnk_SYM (singleton thunk with name of func)
2575 .rva __my_dll_iname (name of dll)
2576 .rva __fuNN_SYM (pointer to reference (address) in text) */
2579 make_import_fixup_entry (const char *name
,
2580 const char *fixup_name
,
2581 const char *symname
,
2589 oname
= xmalloc (20 + dll_symname_len
);
2590 sprintf (oname
, "%s_fu%06d.o", dll_symname
, tmp_seq
);
2593 abfd
= bfd_create (oname
, parent
);
2594 bfd_find_target (pe_details
->object_target
, abfd
);
2595 bfd_make_writable (abfd
);
2597 bfd_set_format (abfd
, bfd_object
);
2598 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2601 symtab
= xmalloc (6 * sizeof (asymbol
*));
2602 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2604 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2605 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2606 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2608 bfd_set_section_size (id2
, 20);
2613 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2614 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2615 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2618 bfd_set_symtab (abfd
, symtab
, symptr
);
2620 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2622 bfd_make_readable (abfd
);
2626 /* .section .rdata_runtime_pseudo_reloc
2628 .rva __fuNN_SYM (pointer to reference (address) in text) */
2631 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2632 const char *fixup_name
,
2633 bfd_vma addend ATTRIBUTE_UNUSED
,
2638 unsigned char *rt_rel_d
;
2643 oname
= xmalloc (20 + dll_symname_len
);
2644 sprintf (oname
, "%s_rtr%06d.o", dll_symname
, tmp_seq
);
2647 abfd
= bfd_create (oname
, parent
);
2648 bfd_find_target (pe_details
->object_target
, abfd
);
2649 bfd_make_writable (abfd
);
2651 bfd_set_format (abfd
, bfd_object
);
2652 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2654 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2656 if (runtime_pseudp_reloc_v2_init
)
2657 size
= 3 * sizeof (asymbol
*);
2659 size
= 6 * sizeof (asymbol
*);
2662 size
= 2 * sizeof (asymbol
*);
2665 symtab
= xmalloc (size
);
2668 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2670 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2672 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2675 if (!runtime_pseudp_reloc_v2_init
)
2678 runtime_pseudp_reloc_v2_init
= true;
2681 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2683 bfd_set_section_size (rt_rel
, size
);
2684 rt_rel_d
= xmalloc (size
);
2685 rt_rel
->contents
= rt_rel_d
;
2686 memset (rt_rel_d
, 0, size
);
2687 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2688 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2689 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2691 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2692 save_relocs (rt_rel
);
2694 bfd_set_symtab (abfd
, symtab
, symptr
);
2696 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2700 bfd_set_section_size (rt_rel
, 8);
2701 rt_rel_d
= xmalloc (8);
2702 rt_rel
->contents
= rt_rel_d
;
2703 memset (rt_rel_d
, 0, 8);
2705 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2706 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2708 save_relocs (rt_rel
);
2710 bfd_set_symtab (abfd
, symtab
, symptr
);
2712 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2715 bfd_make_readable (abfd
);
2720 .rva __pei386_runtime_relocator */
2723 pe_create_runtime_relocator_reference (bfd
*parent
)
2725 asection
*extern_rt_rel
;
2726 unsigned char *extern_rt_rel_d
;
2730 oname
= xmalloc (20 + dll_symname_len
);
2731 sprintf (oname
, "%s_ertr%06d.o", dll_symname
, tmp_seq
);
2734 abfd
= bfd_create (oname
, parent
);
2735 bfd_find_target (pe_details
->object_target
, abfd
);
2736 bfd_make_writable (abfd
);
2738 bfd_set_format (abfd
, bfd_object
);
2739 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2742 symtab
= xmalloc (2 * sizeof (asymbol
*));
2743 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2745 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2748 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2749 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2750 extern_rt_rel
->contents
= extern_rt_rel_d
;
2752 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2753 save_relocs (extern_rt_rel
);
2755 bfd_set_symtab (abfd
, symtab
, symptr
);
2757 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2759 bfd_make_readable (abfd
);
2764 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2765 const char *symname
)
2767 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2770 /* This is the original implementation of the auto-import feature, which
2771 primarily relied on the OS loader to patch things up with some help
2772 from the pseudo-relocator to overcome the main limitation. See the
2773 comment at the beginning of the file for an overview of the feature. */
2774 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2776 struct bfd_link_hash_entry
*name_thunk_sym
;
2777 /* name buffer is allocated with space at beginning for prefixes. */
2778 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2779 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2780 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2782 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2784 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2785 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2787 /* If we ever use autoimport, we have to cast text section writable. */
2788 config
.text_read_only
= false;
2789 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2792 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2794 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2795 link_info
.output_bfd
);
2796 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2800 /* In the original implementation, the pseudo-relocator was only used when
2801 the addend was not null. In the new implementation, the OS loader is
2802 completely bypassed and the pseudo-relocator does the entire work. */
2803 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2804 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2806 if (pe_dll_extra_pe_debug
)
2807 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2808 fixup_name
, (int) addend
);
2810 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2811 link_info
.output_bfd
);
2812 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2814 if (runtime_pseudo_relocs_created
++ == 0)
2816 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2817 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2821 else if (addend
!= 0)
2822 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2823 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2827 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2836 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2837 dll_symname
= xstrdup (dll_filename
);
2838 dll_symname_len
= strlen (dll_symname
);
2839 for (i
= 0; dll_symname
[i
]; i
++)
2840 if (!ISALNUM (dll_symname
[i
]))
2841 dll_symname
[i
] = '_';
2843 unlink_if_ordinary (impfilename
);
2845 outarch
= bfd_openw (impfilename
, 0);
2849 /* xgettext:c-format */
2850 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2855 /* xgettext:c-format */
2856 info_msg (_("Creating library file: %s\n"), impfilename
);
2858 bfd_set_format (outarch
, bfd_archive
);
2859 outarch
->has_armap
= 1;
2861 /* Work out a reasonable size of things to put onto one line. */
2862 ar_head
= make_head (outarch
);
2864 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2865 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2867 /* Iterate the exclude list. */
2868 struct exclude_list_struct
*ex
;
2870 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2872 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2874 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2876 /* If it matched, we must open a fresh BFD for it (the original
2877 input BFD is still needed for the DLL's final link) and add
2878 it into the archive member chain. */
2881 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2882 ? bfd_get_filename (ibfd
->my_archive
)
2883 : bfd_get_filename (ibfd
), NULL
);
2886 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2889 if (ibfd
->my_archive
)
2891 /* Must now iterate through archive until we find the
2892 required member. A minor shame that we'll open the
2893 archive once per member that we require from it, and
2894 leak those archive bfds rather than reuse them. */
2895 bfd
*arbfd
= newbfd
;
2896 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2898 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2899 bfd_get_filename (ibfd
->my_archive
),
2900 bfd_get_filename (ibfd
));
2904 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2906 if (filename_cmp (bfd_get_filename (newbfd
),
2907 bfd_get_filename (ibfd
)) == 0)
2912 einfo (_("%X%P: %s(%s): can't find member in archive"),
2913 bfd_get_filename (ibfd
->my_archive
),
2914 bfd_get_filename (ibfd
));
2918 newbfd
->archive_next
= head
;
2923 for (i
= 0; i
< def
->num_exports
; i
++)
2925 /* The import library doesn't know about the internal name. */
2926 char *internal
= def
->exports
[i
].internal_name
;
2929 /* Don't add PRIVATE entries to import lib. */
2930 if (pe_def_file
->exports
[i
].flag_private
)
2933 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2935 /* PR 19803: If a symbol has been discard due to garbage
2936 collection then do not create any exports for it. */
2938 struct coff_link_hash_entry
*h
;
2940 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2941 false, false, false);
2943 /* If the symbol is hidden and undefined then it
2944 has been swept up by garbage collection. */
2945 && h
->symbol_class
== C_HIDDEN
2946 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2949 /* If necessary, check with an underscore prefix as well. */
2950 if (pe_details
->underscored
&& internal
[0] != '@')
2954 name
= xmalloc (strlen (internal
) + 2);
2955 sprintf (name
, "_%s", internal
);
2957 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2958 false, false, false);
2962 /* If the symbol is hidden and undefined then it
2963 has been swept up by garbage collection. */
2964 && h
->symbol_class
== C_HIDDEN
2965 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2970 n
= make_one (def
->exports
+ i
, outarch
,
2971 ! (def
->exports
+ i
)->flag_data
);
2972 n
->archive_next
= head
;
2974 def
->exports
[i
].internal_name
= internal
;
2977 ar_tail
= make_tail (outarch
);
2979 if (ar_head
== NULL
|| ar_tail
== NULL
)
2982 /* Now stick them all into the archive. */
2983 ar_head
->archive_next
= head
;
2984 ar_tail
->archive_next
= ar_head
;
2987 if (! bfd_set_archive_head (outarch
, head
))
2988 einfo ("%X%P: bfd_set_archive_head: %E\n");
2990 if (! bfd_close (outarch
))
2991 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
2993 while (head
!= NULL
)
2995 bfd
*n
= head
->archive_next
;
3001 static int undef_count
= 0;
3009 static struct key_value
*udef_table
;
3011 static int undef_sort_cmp (const void *l1
, const void *r1
)
3013 const struct key_value
*l
= l1
;
3014 const struct key_value
*r
= r1
;
3016 return strcmp (l
->key
, r
->key
);
3019 static struct bfd_link_hash_entry
*
3020 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3022 struct bfd_link_hash_entry
*h
= NULL
;
3023 struct key_value
*kv
;
3024 struct key_value key
;
3025 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3027 strcpy (lname
, name
);
3029 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3034 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3039 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3040 if (h
->type
== bfd_link_hash_undefined
)
3044 if (lname
[0] == '?')
3047 if (at
|| lname
[0] == '@')
3049 if (lname
[0] == '@')
3051 if (pe_details
->underscored
)
3054 /* Use memmove rather than strcpy as that
3055 can handle overlapping buffers. */
3056 memmove (lname
, lname
+ 1, strlen (lname
));
3058 kv
= bsearch (&key
, udef_table
, undef_count
,
3059 sizeof (struct key_value
), undef_sort_cmp
);
3062 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3063 if (h
->type
== bfd_link_hash_undefined
)
3068 *strchr (lname
, '@') = 0;
3070 kv
= bsearch (&key
, udef_table
, undef_count
,
3071 sizeof (struct key_value
), undef_sort_cmp
);
3074 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3075 if (h
->type
== bfd_link_hash_undefined
)
3081 strcat (lname
, "@");
3083 kv
= bsearch (&key
, udef_table
, undef_count
,
3084 sizeof (struct key_value
), undef_sort_cmp
);
3088 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3089 if (h
->type
== bfd_link_hash_undefined
)
3093 if (lname
[0] == '_' && pe_details
->underscored
)
3097 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3102 kv
= bsearch (&key
, udef_table
, undef_count
,
3103 sizeof (struct key_value
), undef_sort_cmp
);
3107 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3108 if (h
->type
== bfd_link_hash_undefined
)
3120 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3121 void *inf ATTRIBUTE_UNUSED
)
3123 if (h
->type
== bfd_link_hash_undefined
)
3129 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3131 if (h
->type
== bfd_link_hash_undefined
)
3135 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3136 at
= strchr (udef_table
[undef_count
].key
3137 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3140 udef_table
[undef_count
].oname
= h
->root
.string
;
3147 pe_create_undef_table (void)
3151 /* count undefined symbols */
3153 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3155 /* create and fill the corresponding table */
3156 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3159 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3162 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3166 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3168 lang_input_statement_type
*fake_file
;
3170 fake_file
= lang_add_input_file (name
,
3171 lang_input_file_is_fake_enum
,
3173 fake_file
->the_bfd
= abfd
;
3174 ldlang_add_file (fake_file
);
3176 if (!bfd_link_add_symbols (abfd
, linfo
))
3177 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3181 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3184 def_file_module
*module
;
3185 def_file_import
*imp
;
3187 pe_dll_id_target (bfd_get_target (output_bfd
));
3192 imp
= pe_def_file
->imports
;
3194 pe_create_undef_table ();
3196 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3198 int do_this_dll
= 0;
3200 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3202 if (i
>= pe_def_file
->num_imports
)
3205 dll_filename
= module
->name
;
3206 dll_symname
= xstrdup (module
->name
);
3207 dll_symname_len
= strlen (dll_symname
);
3208 for (j
= 0; dll_symname
[j
]; j
++)
3209 if (!ISALNUM (dll_symname
[j
]))
3210 dll_symname
[j
] = '_';
3212 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3214 def_file_export exp
;
3215 struct bfd_link_hash_entry
*blhe
;
3216 int lead_at
= (*imp
[i
].internal_name
== '@');
3217 /* See if we need this import. */
3218 size_t len
= strlen (imp
[i
].internal_name
);
3219 char *name
= xmalloc (len
+ 2 + 6);
3220 bool include_jmp_stub
= false;
3221 bool is_cdecl
= false;
3222 bool is_undef
= false;
3224 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3228 sprintf (name
, "%s", imp
[i
].internal_name
);
3230 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3232 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3233 false, false, false);
3235 /* Include the jump stub for <sym> only if the <sym>
3237 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3240 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3242 sprintf (name
, "%s%s%s", "__imp_", U (""),
3243 imp
[i
].internal_name
);
3245 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3246 false, false, false);
3248 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3252 include_jmp_stub
= true;
3253 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3256 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3258 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3259 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3260 include_jmp_stub
= true;
3262 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3273 bfd
*ar_head
= make_head (output_bfd
);
3274 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
), linfo
);
3277 exp
.internal_name
= imp
[i
].internal_name
;
3278 exp
.name
= imp
[i
].name
;
3279 exp
.its_name
= imp
[i
].its_name
;
3280 exp
.ordinal
= imp
[i
].ordinal
;
3281 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3282 exp
.flag_private
= 0;
3283 exp
.flag_constant
= 0;
3284 exp
.flag_data
= imp
[i
].data
;
3285 exp
.flag_noname
= exp
.name
? 0 : 1;
3286 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3287 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3292 bfd
*ar_tail
= make_tail (output_bfd
);
3293 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3302 free (udef_table
[undef_count
].key
);
3307 /* We were handed a *.DLL file. Parse it and turn it into a set of
3308 IMPORTS directives in the def file. Return TRUE if the file was
3309 handled, FALSE if not. */
3312 pe_get16 (bfd
*abfd
, int where
)
3316 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3317 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3318 return b
[0] + (b
[1] << 8);
3322 pe_get32 (bfd
*abfd
, int where
)
3326 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3327 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3328 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3334 unsigned char *b
= ptr
;
3336 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3340 pe_implied_import_dll (const char *filename
)
3343 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3344 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3345 bfd_vma exp_funcbase
;
3346 unsigned char *expdata
;
3348 bfd_vma name_rvas
, nexp
;
3349 const char *dllname
;
3350 /* Initialization with start > end guarantees that is_data
3351 will not be set by mistake, and avoids compiler warning. */
3352 bfd_vma data_start
= 1;
3353 bfd_vma data_end
= 0;
3354 bfd_vma rdata_start
= 1;
3355 bfd_vma rdata_end
= 0;
3356 bfd_vma bss_start
= 1;
3357 bfd_vma bss_end
= 0;
3360 /* No, I can't use bfd here. kernel32.dll puts its export table in
3361 the middle of the .rdata section. */
3362 dll
= bfd_openr (filename
, pe_details
->target_name
);
3365 einfo (_("%X%P: open %s: %E\n"), filename
);
3369 track_dependency_files (filename
);
3371 /* PEI dlls seem to be bfd_objects. */
3372 if (!bfd_check_format (dll
, bfd_object
))
3374 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3378 /* Get pe_header, optional header and numbers of directory entries. */
3379 pe_header_offset
= pe_get32 (dll
, 0x3c);
3380 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3381 #ifdef pe_use_x86_64
3382 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3384 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3387 /* No import or export directory entry. */
3388 if (num_entries
< 1)
3391 #ifdef pe_use_x86_64
3392 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3393 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3395 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3396 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3399 /* No export table - nothing to export. */
3400 if (export_size
== 0)
3403 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3404 secptr
= (pe_header_offset
+ 4 + 20 +
3405 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3408 /* Get the rva and size of the export section. */
3409 for (i
= 0; i
< nsections
; i
++)
3412 bfd_vma secptr1
= secptr
+ 40 * i
;
3413 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3414 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3415 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3417 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3418 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3420 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3422 expptr
= fptr
+ (export_rva
- vaddr
);
3423 if (export_rva
+ export_size
> vaddr
+ vsize
)
3424 export_size
= vsize
- (export_rva
- vaddr
);
3429 /* Scan sections and store the base and size of the
3430 data and bss segments in data/base_start/end. */
3431 for (i
= 0; i
< nsections
; i
++)
3433 bfd_vma secptr1
= secptr
+ 40 * i
;
3434 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3435 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3436 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3440 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3441 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3443 if (strcmp(sec_name
,".data") == 0)
3446 data_end
= vaddr
+ vsize
;
3448 if (pe_dll_extra_pe_debug
)
3449 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3450 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3451 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3453 else if (strcmp(sec_name
,".rdata") == 0)
3455 rdata_start
= vaddr
;
3456 rdata_end
= vaddr
+ vsize
;
3458 if (pe_dll_extra_pe_debug
)
3459 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3460 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3461 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3463 else if (strcmp (sec_name
,".bss") == 0)
3466 bss_end
= vaddr
+ vsize
;
3468 if (pe_dll_extra_pe_debug
)
3469 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3470 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3471 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3475 expdata
= xmalloc (export_size
);
3476 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3477 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3478 erva
= (char *) expdata
- export_rva
;
3480 if (pe_def_file
== 0)
3481 pe_def_file
= def_file_empty ();
3483 nexp
= pe_as32 (expdata
+ 24);
3484 name_rvas
= pe_as32 (expdata
+ 32);
3485 exp_funcbase
= pe_as32 (expdata
+ 28);
3487 /* Use internal dll name instead of filename
3488 to enable symbolic dll linking. */
3489 dllname
= erva
+ pe_as32 (expdata
+ 12);
3491 /* Check to see if the dll has already been added to
3492 the definition list and if so return without error.
3493 This avoids multiple symbol definitions. */
3494 if (def_get_module (pe_def_file
, dllname
))
3496 if (pe_dll_extra_pe_debug
)
3497 printf ("%s is already loaded\n", dllname
);
3501 /* This is an optimized version of the insertion loop, which avoids lots of
3502 calls to realloc and memmove from def_file_add_import. */
3503 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3504 erva
+ pe_as32 (erva
+ name_rvas
),
3505 dllname
, 0, NULL
, NULL
)) >= 0)
3507 for (i
= 0; i
< nexp
; i
++)
3509 /* Pointer to the names vector. */
3510 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3511 def_file_import
*imp
;
3512 /* Pointer to the function address vector. */
3513 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3514 /* is_data is true if the address is in the data, rdata or bss
3517 (func_rva
>= data_start
&& func_rva
< data_end
)
3518 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3519 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3521 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3522 dllname
, i
, NULL
, NULL
);
3523 /* Mark symbol type. */
3524 imp
->data
= is_data
;
3526 if (pe_dll_extra_pe_debug
)
3527 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3528 __FUNCTION__
, dllname
, erva
+ name_rva
,
3529 (unsigned long) func_rva
, is_data
? "(data)" : "");
3535 /* Iterate through the list of symbols. */
3536 for (i
= 0; i
< nexp
; i
++)
3538 /* Pointer to the names vector. */
3539 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3540 def_file_import
*imp
;
3541 /* Pointer to the function address vector. */
3542 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3545 /* Skip unwanted symbols, which are
3546 exported in buggy auto-import releases. */
3547 if (! startswith (erva
+ name_rva
, "__nm_"))
3550 /* is_data is true if the address is in the data, rdata or bss
3553 (func_rva
>= data_start
&& func_rva
< data_end
)
3554 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3555 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3557 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3558 dllname
, i
, NULL
, NULL
, &is_dup
);
3559 /* Mark symbol type. */
3561 imp
->data
= is_data
;
3563 if (pe_dll_extra_pe_debug
)
3564 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3565 __FUNCTION__
, dllname
, erva
+ name_rva
,
3566 (unsigned long) func_rva
, is_data
? "(data)" : "");
3574 pe_output_file_set_long_section_names (bfd
*abfd
)
3576 if (pe_use_coff_long_section_names
< 0)
3578 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3579 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3582 /* These are the main functions, called from the emulation. The first
3583 is called after the bfds are read, so we can guess at how much space
3584 we need. The second is called after everything is placed, so we
3585 can put the right values in place. */
3588 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3590 pe_dll_id_target (bfd_get_target (abfd
));
3591 pe_output_file_set_long_section_names (abfd
);
3592 process_def_file_and_drectve (abfd
, info
);
3594 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3596 if (pe_dll_enable_reloc_section
)
3598 build_filler_bfd (0);
3599 pe_output_file_set_long_section_names (filler_bfd
);
3604 generate_edata (abfd
, info
);
3605 build_filler_bfd (1);
3606 pe_output_file_set_long_section_names (filler_bfd
);
3610 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3612 pe_dll_id_target (bfd_get_target (abfd
));
3613 pe_output_file_set_long_section_names (abfd
);
3614 build_filler_bfd (0);
3615 pe_output_file_set_long_section_names (filler_bfd
);
3619 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3621 pe_exe_fill_sections (abfd
, info
);
3625 fill_edata (abfd
, info
);
3626 edata_s
->contents
= edata_d
;
3629 if (bfd_link_dll (info
))
3630 pe_data (abfd
)->dll
= 1;
3634 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3636 pe_dll_id_target (bfd_get_target (abfd
));
3637 pe_output_file_set_long_section_names (abfd
);
3638 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3640 generate_reloc (abfd
, info
);
3643 bfd_set_section_size (reloc_s
, reloc_sz
);
3645 /* Resize the sections. */
3646 lang_reset_memory_regions ();
3647 lang_size_sections (NULL
, true);
3649 /* Redo special stuff. */
3650 ldemul_after_allocation ();
3652 /* Do the assignments again. */
3653 lang_do_assignments (lang_final_phase_enum
);
3656 reloc_s
->contents
= reloc_d
;
3660 pe_bfd_is_dll (bfd
*abfd
)
3662 return (bfd_get_format (abfd
) == bfd_object
3664 && pe_data (abfd
)->dll
);