1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2020 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
= 0;
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 bfd_boolean 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
;
189 bfd_boolean underscored
;
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
287 16 /* R_SH_IMAGEBASE */,
291 autofilter_symbollist_generic
300 autofilter_symbollist_generic
309 autofilter_symbollist_generic
312 "pei-arm-wince-little",
313 "pe-arm-wince-little",
314 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
318 autofilter_symbollist_generic
320 { NULL
, NULL
, 0, 0, 0, FALSE
, NULL
}
323 static const pe_details_type
*pe_details
;
325 /* Do not specify library suffix explicitly, to allow for dllized versions. */
326 static const autofilter_entry_type autofilter_liblist
[] =
328 { STRING_COMMA_LEN ("libcegcc") },
329 { STRING_COMMA_LEN ("libcygwin") },
330 { STRING_COMMA_LEN ("libgcc") },
331 { STRING_COMMA_LEN ("libgcc_s") },
332 { STRING_COMMA_LEN ("libstdc++") },
333 { STRING_COMMA_LEN ("libmingw32") },
334 { STRING_COMMA_LEN ("libmingwex") },
335 { STRING_COMMA_LEN ("libg2c") },
336 { STRING_COMMA_LEN ("libsupc++") },
337 { STRING_COMMA_LEN ("libobjc") },
338 { STRING_COMMA_LEN ("libgcj") },
339 { STRING_COMMA_LEN ("libmsvcrt") },
340 { STRING_COMMA_LEN ("libmsvcrt-os") },
341 { STRING_COMMA_LEN ("libucrtbase") },
345 /* Regardless of the suffix issue mentioned above, we must ensure that
346 we do not falsely match on a leading substring, such as when libtool
347 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
348 This routine ensures that the leading part of the name matches and that
349 it is followed by only an optional version suffix and a file extension,
350 returning zero if so or -1 if not. */
351 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
353 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
356 libname
+= afptr
->len
;
358 /* Be liberal in interpreting what counts as a version suffix; we
359 accept anything that has a dash to separate it from the name and
360 begins with a digit. */
361 if (libname
[0] == '-')
363 if (!ISDIGIT (*++libname
))
365 /* Ensure the filename has an extension. */
366 while (*++libname
!= '.')
370 else if (libname
[0] != '.')
376 static const autofilter_entry_type autofilter_objlist
[] =
378 { STRING_COMMA_LEN ("crt0.o") },
379 { STRING_COMMA_LEN ("crt1.o") },
380 { STRING_COMMA_LEN ("crt2.o") },
381 { STRING_COMMA_LEN ("dllcrt1.o") },
382 { STRING_COMMA_LEN ("dllcrt2.o") },
383 { STRING_COMMA_LEN ("gcrt0.o") },
384 { STRING_COMMA_LEN ("gcrt1.o") },
385 { STRING_COMMA_LEN ("gcrt2.o") },
386 { STRING_COMMA_LEN ("crtbegin.o") },
387 { STRING_COMMA_LEN ("crtend.o") },
391 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
393 /* _imp_ is treated specially, as it is always underscored. */
394 /* { STRING_COMMA_LEN ("_imp_") }, */
395 /* Don't export some c++ symbols. */
396 { STRING_COMMA_LEN ("__rtti_") },
397 { STRING_COMMA_LEN ("__builtin_") },
398 /* Don't re-export auto-imported symbols. */
399 { STRING_COMMA_LEN ("__nm_") },
400 /* Don't export symbols specifying internal DLL layout. */
401 { STRING_COMMA_LEN ("_head_") },
402 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
403 /* Don't export section labels or artificial symbols
405 { STRING_COMMA_LEN (".") },
409 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
411 { STRING_COMMA_LEN ("_iname") },
412 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
416 #define U(str) (pe_details->underscored ? "_" str : str)
419 pe_dll_id_target (const char *target
)
423 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
424 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
425 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
427 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
429 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
432 pe_detail_list
[i
].underscored
= (u
!= 0 ? TRUE
: FALSE
);
433 pe_details
= pe_detail_list
+ i
;
434 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
437 einfo (_("%X%P: unsupported PEI architecture: %s\n"), target
);
441 /* Helper functions for qsort. Relocs must be sorted so that we can write
442 them out by pages. */
454 reloc_sort (const void *va
, const void *vb
)
456 const reloc_data_type
*a
= (const reloc_data_type
*) va
;
457 const reloc_data_type
*b
= (const reloc_data_type
*) vb
;
471 pe_export_sort (const void *va
, const void *vb
)
473 const def_file_export
*a
= va
;
474 const def_file_export
*b
= vb
;
482 return strcmp (an
, bn
);
485 /* Read and process the .DEF file. */
487 /* These correspond to the entries in pe_def_file->exports[]. I use
488 exported_symbol_sections[i] to tag whether or not the symbol was
489 defined, since we can't export symbols we don't have. */
491 static bfd_vma
*exported_symbol_offsets
;
492 static struct bfd_section
**exported_symbol_sections
;
493 static int export_table_size
;
494 static int count_exported
;
495 static int count_exported_byname
;
496 static int count_with_ordinals
;
497 static const char *dll_name
;
498 static int min_ordinal
, max_ordinal
;
499 static int *exported_symbols
;
501 typedef struct exclude_list_struct
504 struct exclude_list_struct
*next
;
509 static struct exclude_list_struct
*excludes
= 0;
512 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
515 char *exclude_string
;
517 local_copy
= xstrdup (new_excludes
);
519 exclude_string
= strtok (local_copy
, ",:");
520 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
522 struct exclude_list_struct
*new_exclude
;
524 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
525 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
526 strcpy (new_exclude
->string
, exclude_string
);
527 new_exclude
->type
= type
;
528 new_exclude
->next
= excludes
;
529 excludes
= new_exclude
;
536 is_import (const char* n
)
538 return (CONST_STRNEQ (n
, "__imp_"));
541 /* abfd is a bfd containing n (or NULL)
542 It can be used for contextual checks. */
545 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
548 struct exclude_list_struct
*ex
;
549 const autofilter_entry_type
*afptr
;
550 const char * libname
= NULL
;
552 if (abfd
&& abfd
->my_archive
)
553 libname
= lbasename (abfd
->my_archive
->filename
);
555 key
.name
= key
.its_name
= (char *) n
;
557 /* Return false if n is in the d->exports table. */
558 if (bsearch (&key
, d
->exports
, d
->num_exports
,
559 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
562 if (pe_dll_do_default_excludes
)
567 if (pe_dll_extra_pe_debug
)
568 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
569 n
, abfd
, abfd
->my_archive
);
571 /* First of all, make context checks:
572 Don't export anything from standard libs. */
575 afptr
= autofilter_liblist
;
579 if (libnamencmp (libname
, afptr
) == 0 )
585 /* Next, exclude symbols from certain startup objects. */
587 if (abfd
&& (p
= lbasename (abfd
->filename
)))
589 afptr
= autofilter_objlist
;
592 if (strcmp (p
, afptr
->name
) == 0)
598 /* Don't try to blindly exclude all symbols
599 that begin with '__'; this was tried and
600 it is too restrictive. Instead we have
601 a target specific list to use: */
602 afptr
= pe_details
->autofilter_symbollist
;
606 if (strcmp (n
, afptr
->name
) == 0)
612 /* Next, exclude symbols starting with ... */
613 afptr
= autofilter_symbolprefixlist
;
616 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
622 /* Finally, exclude symbols ending with ... */
624 afptr
= autofilter_symbolsuffixlist
;
627 if ((len
>= afptr
->len
)
628 /* Add 1 to insure match with trailing '\0'. */
629 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
630 afptr
->len
+ 1) == 0)
637 for (ex
= excludes
; ex
; ex
= ex
->next
)
639 if (ex
->type
== EXCLUDELIBS
)
642 && ((filename_cmp (libname
, ex
->string
) == 0)
643 || (strcasecmp ("ALL", ex
->string
) == 0)))
646 else if (ex
->type
== EXCLUDEFORIMPLIB
)
648 if (filename_cmp (abfd
->filename
, ex
->string
) == 0)
651 else if (strcmp (n
, ex
->string
) == 0)
659 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
662 struct bfd_link_hash_entry
*blhe
;
664 struct bfd_section
*s
;
665 def_file_export
*e
= 0;
666 bfd_boolean resort_needed
;
669 pe_def_file
= def_file_empty ();
671 /* First, run around to all the objects looking for the .drectve
672 sections, and push those into the def file too. */
673 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
675 s
= bfd_get_section_by_name (b
, ".drectve");
679 char *buf
= xmalloc (size
);
681 bfd_get_section_contents (b
, s
, buf
, 0, size
);
682 def_file_add_directive (pe_def_file
, buf
, size
);
687 /* Process aligned common symbol information from the
688 .drectve sections now; common symbol allocation is
689 done before final link, so it will be too late to
690 process them in process_embedded_commands() called
691 from _bfd_coff_link_input_bfd(). */
692 if (pe_def_file
->aligncomms
)
694 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
697 struct coff_link_hash_entry
*sym_hash
;
698 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
699 ac
->symbol_name
, FALSE
, FALSE
, FALSE
);
700 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
701 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
703 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
709 /* If we are building an executable and there is nothing
710 to export, we do not build an export table at all. */
711 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
712 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
715 /* Now, maybe export everything else the default way. */
716 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
717 && !pe_dll_exclude_all_symbols
)
719 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
724 if (!bfd_generic_link_read_symbols (b
))
726 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
730 symbols
= bfd_get_outsymbols (b
);
731 nsyms
= bfd_get_symcount (b
);
733 for (j
= 0; j
< nsyms
; j
++)
735 /* We should export symbols which are either global or not
736 anything at all. (.bss data is the latter)
737 We should not export undefined symbols. */
738 bfd_boolean would_export
739 = (symbols
[j
]->section
!= bfd_und_section_ptr
740 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
741 || (symbols
[j
]->flags
== 0)));
742 if (link_info
.version_info
&& would_export
)
744 = !bfd_hide_sym_by_version (link_info
.version_info
,
748 const char *sn
= symbols
[j
]->name
;
750 /* We should not re-export imported stuff. */
756 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
757 sprintf (name
, "%s%s", "__imp_", sn
);
759 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
760 FALSE
, FALSE
, FALSE
);
763 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
767 if (pe_details
->underscored
&& *sn
== '_')
770 if (auto_export (b
, pe_def_file
, sn
))
775 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
777 /* Fill data flag properly, from dlltool.c. */
779 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
787 #define NE pe_def_file->num_exports
789 /* Don't create an empty export table. */
793 resort_needed
= FALSE
;
795 /* Canonicalize the export list. */
798 for (i
= 0; i
< NE
; i
++)
800 /* Check for fastcall/stdcall-decoration, but ignore
801 C++ mangled names. */
802 if (pe_def_file
->exports
[i
].name
[0] != '?'
803 && strchr (pe_def_file
->exports
[i
].name
, '@'))
805 /* This will preserve internal_name, which may have been
806 pointing to the same memory as name, or might not
808 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
809 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
810 char *tmp_at
= strrchr (tmp
, '@');
815 einfo (_("%X%P: cannot export %s: invalid export name\n"),
816 pe_def_file
->exports
[i
].name
);
817 pe_def_file
->exports
[i
].name
= tmp
;
818 resort_needed
= TRUE
;
823 /* Re-sort the exports table as we have possibly changed the order
824 by removing leading @. */
826 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
829 if (pe_dll_stdcall_aliases
)
831 for (i
= 0; i
< NE
; i
++)
833 if (is_import (pe_def_file
->exports
[i
].name
))
836 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
839 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
840 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
842 *(strchr (tmp
, '@')) = 0;
843 if (auto_export (NULL
, pe_def_file
, tmp
))
844 def_file_add_export (pe_def_file
, tmp
,
845 pe_def_file
->exports
[i
].internal_name
,
853 /* Convenience, but watch out for it changing. */
854 e
= pe_def_file
->exports
;
856 for (i
= 0, j
= 0; i
< NE
; i
++)
858 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
860 /* This is a duplicate. */
861 if (e
[j
- 1].ordinal
!= -1
862 && e
[i
].ordinal
!= -1
863 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
865 if (pe_dll_warn_dup_exports
)
866 /* xgettext:c-format */
867 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
868 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
872 if (pe_dll_warn_dup_exports
)
873 /* xgettext:c-format */
874 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
878 if (e
[i
].ordinal
!= -1)
879 e
[j
- 1].ordinal
= e
[i
].ordinal
;
880 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
881 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
882 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
883 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
886 if (e
[i
].internal_name
)
887 free (e
[i
].internal_name
);
889 free (e
[i
].its_name
);
898 pe_def_file
->num_exports
= j
; /* == NE */
900 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
901 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
903 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
907 count_exported_byname
= 0;
908 count_with_ordinals
= 0;
910 for (i
= 0; i
< NE
; i
++)
912 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
915 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
916 lang_add_gc_name (int_name
);
918 name
= xmalloc (strlen (int_name
) + 2);
919 if (pe_details
->underscored
&& int_name
[0] != '@')
922 strcpy (name
+ 1, int_name
);
924 /* PR 19803: The alias must be preserved as well. */
925 lang_add_gc_name (xstrdup (name
));
928 strcpy (name
, int_name
);
930 blhe
= bfd_link_hash_lookup (info
->hash
,
935 && (blhe
->type
== bfd_link_hash_defined
936 || (blhe
->type
== bfd_link_hash_common
)))
939 if (!pe_def_file
->exports
[i
].flag_noname
)
940 count_exported_byname
++;
942 /* Only fill in the sections. The actual offsets are computed
943 in fill_exported_offsets() after common symbols are laid
945 if (blhe
->type
== bfd_link_hash_defined
)
946 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
948 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
950 if (pe_def_file
->exports
[i
].ordinal
!= -1)
952 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
953 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
954 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
955 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
956 count_with_ordinals
++;
959 /* Check for forward exports. These are indicated in DEF files by an
960 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
961 but we must take care not to be fooled when the user wants to export
962 a symbol that actually really has a dot in it, so we only check
963 for them here, after real defined symbols have already been matched. */
964 else if (strchr (int_name
, '.'))
967 if (!pe_def_file
->exports
[i
].flag_noname
)
968 count_exported_byname
++;
970 pe_def_file
->exports
[i
].flag_forward
= 1;
972 if (pe_def_file
->exports
[i
].ordinal
!= -1)
974 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
975 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
976 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
977 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
978 count_with_ordinals
++;
981 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
983 /* xgettext:c-format */
984 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
989 /* xgettext:c-format */
990 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
992 blhe
->type
, bfd_link_hash_defined
);
996 /* xgettext:c-format */
997 einfo (_("%X%P: cannot export %s: symbol not found\n"),
1004 /* Build the bfd that will contain .edata and .reloc sections. */
1007 build_filler_bfd (int include_edata
)
1009 lang_input_statement_type
*filler_file
;
1010 filler_file
= lang_add_input_file ("dll stuff",
1011 lang_input_file_is_fake_enum
,
1013 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1014 link_info
.output_bfd
);
1015 if (filler_bfd
== NULL
1016 || !bfd_set_arch_mach (filler_bfd
,
1017 bfd_get_arch (link_info
.output_bfd
),
1018 bfd_get_mach (link_info
.output_bfd
)))
1020 einfo (_("%F%P: can not create BFD: %E\n"));
1026 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1028 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1034 einfo (_("%X%P: can not create .edata section: %E\n"));
1037 bfd_set_section_size (edata_s
, edata_sz
);
1040 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1042 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1048 einfo (_("%X%P: can not create .reloc section: %E\n"));
1052 bfd_set_section_size (reloc_s
, 0);
1054 ldlang_add_file (filler_file
);
1057 /* Gather all the exported symbols and build the .edata section. */
1060 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1062 int i
, next_ordinal
;
1063 int name_table_size
= 0;
1066 /* First, we need to know how many exported symbols there are,
1067 and what the range of ordinals is. */
1068 if (pe_def_file
->name
)
1069 dll_name
= pe_def_file
->name
;
1072 dll_name
= abfd
->filename
;
1074 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1075 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1076 dll_name
= dlnp
+ 1;
1079 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1081 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1082 min_ordinal
= max_ordinal
- count_exported
+ 1;
1087 max_ordinal
= count_exported
;
1090 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1091 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1092 for (i
= 0; i
< export_table_size
; i
++)
1093 exported_symbols
[i
] = -1;
1095 /* Now we need to assign ordinals to those that don't have them. */
1096 for (i
= 0; i
< NE
; i
++)
1098 if (exported_symbol_sections
[i
]
1099 || pe_def_file
->exports
[i
].flag_forward
)
1101 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1103 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1104 int pi
= exported_symbols
[ei
];
1108 /* xgettext:c-format */
1109 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1110 pe_def_file
->exports
[i
].ordinal
,
1111 pe_def_file
->exports
[i
].name
,
1112 pe_def_file
->exports
[pi
].name
);
1114 exported_symbols
[ei
] = i
;
1116 if (pe_def_file
->exports
[i
].its_name
)
1117 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1119 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1122 /* Reserve space for the forward name. */
1123 if (pe_def_file
->exports
[i
].flag_forward
)
1125 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1129 next_ordinal
= min_ordinal
;
1130 for (i
= 0; i
< NE
; i
++)
1131 if ((exported_symbol_sections
[i
]
1132 || pe_def_file
->exports
[i
].flag_forward
)
1133 && pe_def_file
->exports
[i
].ordinal
== -1)
1135 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1138 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1139 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1142 /* PR 12969: Check for more than 1^16 ordinals. */
1143 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1144 /* xgettext:c-format */
1145 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1146 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1148 /* OK, now we can allocate some memory. */
1149 edata_sz
= (40 /* directory */
1150 + 4 * export_table_size
/* addresses */
1151 + 4 * count_exported_byname
/* name ptrs */
1152 + 2 * count_exported_byname
/* ordinals */
1153 + name_table_size
+ strlen (dll_name
) + 1);
1156 /* Fill the exported symbol offsets. The preliminary work has already
1157 been done in process_def_file_and_drectve(). */
1160 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1163 struct bfd_link_hash_entry
*blhe
;
1165 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1169 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1170 if (pe_details
->underscored
1171 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1174 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1177 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1179 blhe
= bfd_link_hash_lookup (info
->hash
,
1181 FALSE
, FALSE
, TRUE
);
1183 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1184 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1191 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1194 unsigned char *edirectory
;
1195 unsigned char *eaddresses
;
1196 unsigned char *enameptrs
;
1197 unsigned char *eordinals
;
1200 edata_d
= xmalloc (edata_sz
);
1202 /* Note use of array pointer math here. */
1203 edirectory
= edata_d
;
1204 eaddresses
= edirectory
+ 40;
1205 enameptrs
= eaddresses
+ 4 * export_table_size
;
1206 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1207 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1209 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1210 + edata_s->output_section->vma - image_base)
1212 memset (edata_d
, 0, edata_sz
);
1214 if (pe_data (abfd
)->timestamp
== -1)
1215 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1217 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, edata_d
+ 4);
1219 if (pe_def_file
->version_major
!= -1)
1221 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1222 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1225 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1226 strcpy (enamestr
, dll_name
);
1227 enamestr
+= strlen (enamestr
) + 1;
1228 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1229 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1230 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1231 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1232 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1233 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1235 fill_exported_offsets (abfd
, info
);
1237 /* Ok, now for the filling in part.
1238 Scan alphabetically - ie the ordering in the exports[] table,
1239 rather than by ordinal - the ordering in the exported_symbol[]
1240 table. See dlltool.c and:
1241 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1242 for more information. */
1244 for (s
= 0; s
< NE
; s
++)
1246 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1247 if (pe_def_file
->exports
[s
].ordinal
!= -1
1248 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1250 int ord
= pe_def_file
->exports
[s
].ordinal
;
1252 if (pe_def_file
->exports
[s
].flag_forward
)
1254 bfd_put_32 (abfd
, ERVA (enamestr
),
1255 eaddresses
+ 4 * (ord
- min_ordinal
));
1257 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1258 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1262 bfd_vma srva
= (exported_symbol_offsets
[s
]
1263 + ssec
->output_section
->vma
1264 + ssec
->output_offset
);
1266 bfd_put_32 (abfd
, srva
- image_base
,
1267 eaddresses
+ 4 * (ord
- min_ordinal
));
1270 if (!pe_def_file
->exports
[s
].flag_noname
)
1272 char *ename
= pe_def_file
->exports
[s
].name
;
1273 if (pe_def_file
->exports
[s
].its_name
)
1274 ename
= pe_def_file
->exports
[s
].its_name
;
1276 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1278 strcpy (enamestr
, ename
);
1279 enamestr
+= strlen (enamestr
) + 1;
1280 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1282 pe_def_file
->exports
[s
].hint
= hint
++;
1289 static struct bfd_section
*current_sec
;
1292 pe_walk_relocs (struct bfd_link_info
*info
,
1294 const char *symname
,
1295 struct bfd_hash_table
*import_hash
,
1296 void (*cb
) (arelent
*, asection
*, char *, const char *))
1301 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1305 if (!bfd_generic_link_read_symbols (b
))
1307 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1311 symbols
= bfd_get_outsymbols (b
);
1313 for (s
= b
->sections
; s
; s
= s
->next
)
1316 int relsize
, nrelocs
, i
;
1317 int flags
= bfd_section_flags (s
);
1319 /* Skip discarded linkonce sections. */
1320 if (flags
& SEC_LINK_ONCE
1321 && s
->output_section
== bfd_abs_section_ptr
)
1326 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1327 relocs
= xmalloc (relsize
);
1328 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1330 for (i
= 0; i
< nrelocs
; i
++)
1332 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1334 /* Warning: the callback needs to be passed NAME directly. */
1337 if (bfd_hash_lookup (import_hash
, sym
->name
, FALSE
, FALSE
))
1339 strcpy (name
, sym
->name
);
1340 cb (relocs
[i
], s
, name
, symname
);
1345 if (strcmp (name
, sym
->name
) == 0)
1346 cb (relocs
[i
], s
, name
, symname
);
1352 /* Warning: the allocated symbols are remembered in BFD and reused
1353 later, so don't free them! */
1354 /* free (symbols); */
1360 pe_find_data_imports (const char *symhead
,
1361 void (*cb
) (arelent
*, asection
*, char *, const char *))
1363 struct bfd_link_hash_entry
*undef
;
1364 const size_t headlen
= strlen (symhead
);
1367 struct bfd_hash_table
*import_hash
;
1369 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1370 if (undef
->type
== bfd_link_hash_undefined
)
1372 size_t len
= strlen (undef
->root
.string
);
1379 /* For the pseudo-relocation support version 2, we can collect the symbols
1380 that are subject to auto-import and adjust the relocations en masse. */
1381 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1384 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1385 if (!bfd_hash_table_init (import_hash
,
1387 sizeof (struct bfd_hash_entry
)))
1388 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1393 /* We are being a bit cunning here. The buffer will have space for
1394 prefixes at the beginning. The prefix is modified here and in a
1395 number of functions called from this function. */
1396 #define PREFIX_LEN 32
1397 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1398 name
= buf
+ PREFIX_LEN
;
1400 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1401 if (undef
->type
== bfd_link_hash_undefined
)
1403 struct bfd_link_hash_entry
*sym
;
1406 if (pe_dll_extra_pe_debug
)
1407 printf ("%s:%s\n", __FUNCTION__
, undef
->root
.string
);
1409 strcpy (name
, undef
->root
.string
);
1410 impname
= name
- (sizeof "__imp_" - 1);
1411 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1413 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1415 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1418 bfd_hash_lookup (import_hash
, undef
->root
.string
, TRUE
, FALSE
);
1421 bfd
*b
= sym
->u
.def
.section
->owner
;
1422 const char *symname
= NULL
;
1426 if (!bfd_generic_link_read_symbols (b
))
1428 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1432 symbols
= bfd_get_outsymbols (b
);
1433 nsyms
= bfd_get_symcount (b
);
1435 for (i
= 0; i
< nsyms
; i
++)
1436 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1438 if (pe_dll_extra_pe_debug
)
1439 printf ("->%s\n", symbols
[i
]->name
);
1441 symname
= symbols
[i
]->name
+ headlen
;
1445 /* If the symobl isn't part of an import table, there is no
1446 point in building a fixup, this would give rise to link
1447 errors for mangled symbols instead of the original one. */
1449 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1454 /* Let's differentiate it somehow from defined. */
1455 undef
->type
= bfd_link_hash_defweak
;
1456 undef
->u
.def
.value
= sym
->u
.def
.value
;
1457 undef
->u
.def
.section
= sym
->u
.def
.section
;
1459 /* We replace the original name with the __imp_ prefixed one, this
1460 1) may trash memory 2) leads to duplicate symbols. But this is
1461 better than having a misleading name that can confuse GDB. */
1462 undef
->root
.string
= sym
->root
.string
;
1464 if (link_info
.pei386_auto_import
== -1)
1466 static bfd_boolean warned
= FALSE
;
1468 info_msg (_("Info: resolving %s by linking to %s "
1469 "(auto-import)\n"), name
, impname
);
1471 /* PR linker/4844. */
1474 einfo (_("%P: warning: auto-importing has been activated "
1475 "without --enable-auto-import specified on the "
1476 "command line; this should work unless it "
1477 "involves constant data structures referencing "
1478 "symbols from auto-imported DLLs\n"));
1485 /* If we have the import hash table, walk the relocations only once. */
1488 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1489 bfd_hash_table_free (import_hash
);
1496 /* Gather all the relocations and build the .reloc section. */
1499 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1502 /* For .reloc stuff. */
1503 reloc_data_type
*reloc_data
;
1504 int total_relocs
= 0;
1506 bfd_vma sec_page
= (bfd_vma
) -1;
1507 bfd_vma page_ptr
, page_count
;
1510 struct bfd_section
*s
;
1513 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1514 for (s
= b
->sections
; s
; s
= s
->next
)
1515 total_relocs
+= s
->reloc_count
;
1517 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1521 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1524 int relsize
, nrelocs
;
1526 for (s
= b
->sections
; s
; s
= s
->next
)
1528 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1531 /* If it's not loaded, we don't need to relocate it this way. */
1532 if (!(s
->output_section
->flags
& SEC_LOAD
))
1535 /* I don't know why there would be a reloc for these, but I've
1536 seen it happen - DJ */
1537 if (s
->output_section
== bfd_abs_section_ptr
)
1540 if (s
->output_section
->vma
== 0)
1542 /* Huh? Shouldn't happen, but punt if it does. */
1543 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1544 s
->output_section
->name
, s
->output_section
->index
,
1545 s
->output_section
->flags
);
1549 if (!bfd_generic_link_read_symbols (b
))
1551 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1555 symbols
= bfd_get_outsymbols (b
);
1556 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1557 relocs
= xmalloc (relsize
);
1558 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1560 for (i
= 0; i
< nrelocs
; i
++)
1562 if (pe_dll_extra_pe_debug
)
1564 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1565 printf ("rel: %s\n", sym
->name
);
1567 if (!relocs
[i
]->howto
->pc_relative
1568 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1570 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1572 /* Don't create relocs for undefined weak symbols. */
1573 if (sym
->flags
== BSF_WEAK
)
1575 struct bfd_link_hash_entry
*blhe
1576 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1577 FALSE
, FALSE
, FALSE
);
1578 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1580 /* Check aux sym and see if it is defined or not. */
1581 struct coff_link_hash_entry
*h
, *h2
;
1582 h
= (struct coff_link_hash_entry
*)blhe
;
1583 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1585 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1586 [h
->aux
->x_sym
.x_tagndx
.l
];
1587 /* We don't want a base reloc if the aux sym is not
1588 found, undefined, or if it is the constant ABS
1589 zero default value. (We broaden that slightly by
1590 not testing the value, just the section; there's
1591 no reason we'd want a reference to any absolute
1592 address to get relocated during rebasing). */
1593 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1594 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1597 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1600 /* Nor for Dwarf FDE references to discarded sections. */
1601 else if (bfd_is_abs_section (sym
->section
->output_section
))
1603 /* We only ignore relocs from .eh_frame sections, as
1604 they are discarded by the final link rather than
1605 resolved against the kept section. */
1606 if (!strcmp (s
->name
, ".eh_frame"))
1610 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1611 reloc_data
[total_relocs
].idx
= total_relocs
;
1613 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1615 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1616 relocs
[i
]->howto
->rightshift
)
1618 #ifdef pe_use_x86_64
1619 case BITS_AND_SHIFT (64, 0):
1620 reloc_data
[total_relocs
].type
= 10;
1624 case BITS_AND_SHIFT (32, 0):
1625 reloc_data
[total_relocs
].type
= 3;
1628 case BITS_AND_SHIFT (16, 0):
1629 reloc_data
[total_relocs
].type
= 2;
1632 case BITS_AND_SHIFT (16, 16):
1633 reloc_data
[total_relocs
].type
= 4;
1634 /* FIXME: we can't know the symbol's right value
1635 yet, but we probably can safely assume that
1636 CE will relocate us in 64k blocks, so leaving
1638 reloc_data
[total_relocs
].extra
= 0;
1641 case BITS_AND_SHIFT (26, 2):
1642 reloc_data
[total_relocs
].type
= 5;
1645 case BITS_AND_SHIFT (24, 2):
1646 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1647 Those ARM_xxx definitions should go in proper
1649 if (relocs
[i
]->howto
->type
== 0
1650 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1651 || relocs
[i
]->howto
->type
== 5)
1652 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1653 that has already been fully processed during a
1654 previous link stage, so ignore it here. */
1658 /* xgettext:c-format */
1659 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1660 relocs
[i
]->howto
->bitsize
);
1666 /* Warning: the allocated symbols are remembered in BFD and
1667 reused later, so don't free them! */
1671 /* At this point, we have total_relocs relocation addresses in
1672 reloc_addresses, which are all suitable for the .reloc section.
1673 We must now create the new sections. */
1674 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1676 for (i
= 0; i
< total_relocs
; i
++)
1678 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1680 if (this_page
!= sec_page
)
1682 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1684 sec_page
= this_page
;
1689 if (reloc_data
[i
].type
== 4)
1693 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1694 reloc_d
= xmalloc (reloc_sz
);
1695 sec_page
= (bfd_vma
) -1;
1697 page_ptr
= (bfd_vma
) -1;
1700 for (i
= 0; i
< total_relocs
; i
++)
1702 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1703 bfd_vma this_page
= (rva
& ~0xfff);
1705 if (this_page
!= sec_page
)
1707 while (reloc_sz
& 3)
1708 reloc_d
[reloc_sz
++] = 0;
1710 if (page_ptr
!= (bfd_vma
) -1)
1711 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1713 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1714 page_ptr
= reloc_sz
;
1716 sec_page
= this_page
;
1720 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1721 reloc_d
+ reloc_sz
);
1724 if (reloc_data
[i
].type
== 4)
1726 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1733 while (reloc_sz
& 3)
1734 reloc_d
[reloc_sz
++] = 0;
1736 if (page_ptr
!= (bfd_vma
) -1)
1737 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1739 while (reloc_sz
< reloc_s
->size
)
1740 reloc_d
[reloc_sz
++] = 0;
1743 /* Given the exiting def_file structure, print out a .DEF file that
1744 corresponds to it. */
1747 quoteput (char *s
, FILE *f
, int needs_quotes
)
1751 for (cp
= s
; *cp
; cp
++)
1766 if (*s
== '"' || *s
== '\\')
1780 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1783 FILE *out
= fopen (pe_out_def_filename
, "w");
1786 /* xgettext:c-format */
1787 einfo (_("%P: can't open output def file %s\n"),
1788 pe_out_def_filename
);
1792 if (pe_def_file
->name
)
1794 if (pe_def_file
->is_dll
)
1795 fprintf (out
, "LIBRARY ");
1797 fprintf (out
, "NAME ");
1799 quoteput (pe_def_file
->name
, out
, 1);
1801 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1803 fprintf (out
, " BASE=0x");
1804 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1806 fprintf (out
, "\n");
1809 if (pe_def_file
->description
)
1811 fprintf (out
, "DESCRIPTION ");
1812 quoteput (pe_def_file
->description
, out
, 1);
1813 fprintf (out
, "\n");
1816 if (pe_def_file
->version_minor
!= -1)
1817 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1818 pe_def_file
->version_minor
);
1819 else if (pe_def_file
->version_major
!= -1)
1820 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1822 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1823 fprintf (out
, "\n");
1825 if (pe_def_file
->stack_commit
!= -1)
1826 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1827 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1828 else if (pe_def_file
->stack_reserve
!= -1)
1829 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1831 if (pe_def_file
->heap_commit
!= -1)
1832 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1833 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1834 else if (pe_def_file
->heap_reserve
!= -1)
1835 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1837 if (pe_def_file
->num_section_defs
> 0)
1839 fprintf (out
, "\nSECTIONS\n\n");
1841 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1844 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1846 if (pe_def_file
->section_defs
[i
].class)
1848 fprintf (out
, " CLASS ");
1849 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1852 if (pe_def_file
->section_defs
[i
].flag_read
)
1853 fprintf (out
, " READ");
1855 if (pe_def_file
->section_defs
[i
].flag_write
)
1856 fprintf (out
, " WRITE");
1858 if (pe_def_file
->section_defs
[i
].flag_execute
)
1859 fprintf (out
, " EXECUTE");
1861 if (pe_def_file
->section_defs
[i
].flag_shared
)
1862 fprintf (out
, " SHARED");
1864 fprintf (out
, "\n");
1868 if (pe_def_file
->num_exports
> 0)
1870 fprintf (out
, "EXPORTS\n");
1872 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1874 def_file_export
*e
= pe_def_file
->exports
+ i
;
1876 quoteput (e
->name
, out
, 0);
1878 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1880 fprintf (out
, " = ");
1881 quoteput (e
->internal_name
, out
, 0);
1884 if (e
->ordinal
!= -1)
1885 fprintf (out
, " @%d", e
->ordinal
);
1887 if (e
->flag_private
)
1888 fprintf (out
, " PRIVATE");
1890 if (e
->flag_constant
)
1891 fprintf (out
, " CONSTANT");
1894 fprintf (out
, " NONAME");
1897 fprintf (out
, " DATA");
1899 fprintf (out
, "\n");
1903 if (pe_def_file
->num_imports
> 0)
1905 fprintf (out
, "\nIMPORTS\n\n");
1907 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1909 def_file_import
*im
= pe_def_file
->imports
+ i
;
1912 if (im
->internal_name
1913 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1915 quoteput (im
->internal_name
, out
, 0);
1916 fprintf (out
, " = ");
1919 quoteput (im
->module
->name
, out
, 0);
1923 quoteput (im
->name
, out
, 0);
1925 fprintf (out
, "%d", im
->ordinal
);
1929 fprintf (out
, " == ");
1930 quoteput (im
->its_name
, out
, 0);
1933 fprintf (out
, "\n");
1938 fprintf (out
, _("; no contents available\n"));
1940 if (fclose (out
) == EOF
)
1941 /* xgettext:c-format */
1942 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1945 /* Generate the import library. */
1947 static asymbol
**symtab
;
1950 static const char *dll_filename
;
1951 static char *dll_symname
;
1953 #define UNDSEC bfd_und_section_ptr
1956 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1961 sec
= bfd_make_section_old_way (abfd
, name
);
1962 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1963 bfd_set_section_alignment (sec
, align
);
1964 /* Remember to undo this before trying to link internally! */
1965 sec
->output_section
= sec
;
1967 sym
= bfd_make_empty_symbol (abfd
);
1968 symtab
[symptr
++] = sym
;
1969 sym
->name
= sec
->name
;
1971 sym
->flags
= BSF_LOCAL
;
1978 quick_symbol (bfd
*abfd
,
1987 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1992 sym
= bfd_make_empty_symbol (abfd
);
1997 symtab
[symptr
++] = sym
;
2000 static arelent
*reltab
= 0;
2001 static int relcount
= 0, relsize
= 0;
2004 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2006 if (relcount
>= relsize
- 1)
2010 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2012 reltab
= xmalloc (relsize
* sizeof (arelent
));
2014 reltab
[relcount
].address
= address
;
2015 reltab
[relcount
].addend
= 0;
2016 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2017 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2022 save_relocs (asection
*sec
)
2026 sec
->relocation
= reltab
;
2027 sec
->reloc_count
= relcount
;
2028 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2029 for (i
= 0; i
< relcount
; i
++)
2030 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2031 sec
->orelocation
[relcount
] = 0;
2032 sec
->flags
|= SEC_RELOC
;
2034 relcount
= relsize
= 0;
2037 /* .section .idata$2
2038 .global __head_my_dll
2055 make_head (bfd
*parent
)
2057 asection
*id2
, *id5
, *id4
;
2058 unsigned char *d2
, *d5
, *d4
;
2062 oname
= xmalloc (20);
2063 sprintf (oname
, "d%06d.o", tmp_seq
);
2066 abfd
= bfd_create (oname
, parent
);
2067 bfd_find_target (pe_details
->object_target
, abfd
);
2068 bfd_make_writable (abfd
);
2070 bfd_set_format (abfd
, bfd_object
);
2071 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2074 symtab
= xmalloc (6 * sizeof (asymbol
*));
2075 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2076 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2077 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2078 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2079 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2081 /* OK, pay attention here. I got confused myself looking back at
2082 it. We create a four-byte section to mark the beginning of the
2083 list, and we include an offset of 4 in the section, so that the
2084 pointer to the list points to the *end* of this section, which is
2085 the start of the list of sections from other objects. */
2087 bfd_set_section_size (id2
, 20);
2091 if (pe_use_nul_prefixed_import_tables
)
2092 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2093 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2094 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2095 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2098 if (pe_use_nul_prefixed_import_tables
)
2099 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2101 bfd_set_section_size (id5
, 0);
2102 d5
= xmalloc (PE_IDATA5_SIZE
);
2104 memset (d5
, 0, PE_IDATA5_SIZE
);
2105 if (pe_use_nul_prefixed_import_tables
)
2106 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2108 bfd_set_section_size (id4
, 0);
2109 d4
= xmalloc (PE_IDATA4_SIZE
);
2111 memset (d4
, 0, PE_IDATA4_SIZE
);
2113 bfd_set_symtab (abfd
, symtab
, symptr
);
2115 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2116 if (pe_use_nul_prefixed_import_tables
)
2118 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2119 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2123 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2124 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2127 bfd_make_readable (abfd
);
2131 /* .section .idata$4
2138 .global __my_dll_iname
2143 make_tail (bfd
*parent
)
2145 asection
*id4
, *id5
, *id7
;
2146 unsigned char *d4
, *d5
, *d7
;
2151 oname
= xmalloc (20);
2152 sprintf (oname
, "d%06d.o", tmp_seq
);
2155 abfd
= bfd_create (oname
, parent
);
2156 bfd_find_target (pe_details
->object_target
, abfd
);
2157 bfd_make_writable (abfd
);
2159 bfd_set_format (abfd
, bfd_object
);
2160 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2163 symtab
= xmalloc (5 * sizeof (asymbol
*));
2164 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2165 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2166 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2167 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2169 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2170 d4
= xmalloc (PE_IDATA4_SIZE
);
2172 memset (d4
, 0, PE_IDATA4_SIZE
);
2174 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2175 d5
= xmalloc (PE_IDATA5_SIZE
);
2177 memset (d5
, 0, PE_IDATA5_SIZE
);
2179 len
= strlen (dll_filename
) + 1;
2182 bfd_set_section_size (id7
, len
);
2185 strcpy ((char *) d7
, dll_filename
);
2186 /* If len was odd, the above
2187 strcpy leaves behind an undefined byte. That is harmless,
2188 but we set it to 0 just so the binary dumps are pretty. */
2191 bfd_set_symtab (abfd
, symtab
, symptr
);
2193 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2194 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2195 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2197 bfd_make_readable (abfd
);
2203 .global ___imp_function
2204 .global __imp__function
2206 jmp *__imp__function:
2220 .asciz "function" xlate? (add underscore, kill at) */
2222 static const unsigned char jmp_ix86_bytes
[] =
2224 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2232 .dw __imp_function */
2234 static const unsigned char jmp_sh_bytes
[] =
2236 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2240 lui $t0,<high:__imp_function>
2241 lw $t0,<low:__imp_function>
2245 static const unsigned char jmp_mips_bytes
[] =
2247 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2248 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2251 static const unsigned char jmp_arm_bytes
[] =
2253 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2254 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2260 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2262 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2263 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2267 const unsigned char *jmp_bytes
= NULL
;
2268 int jmp_byte_count
= 0;
2270 /* Include the jump stub section only if it is needed. A jump
2271 stub is needed if the symbol being imported <sym> is a function
2272 symbol and there is at least one undefined reference to that
2273 symbol. In other words, if all the import references to <sym> are
2274 explicitly through _declspec(dllimport) then the jump stub is not
2276 if (include_jmp_stub
)
2278 switch (pe_details
->pe_arch
)
2281 jmp_bytes
= jmp_ix86_bytes
;
2282 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2285 jmp_bytes
= jmp_sh_bytes
;
2286 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2289 jmp_bytes
= jmp_mips_bytes
;
2290 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2293 case PE_ARCH_arm_wince
:
2294 jmp_bytes
= jmp_arm_bytes
;
2295 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2302 oname
= xmalloc (20);
2303 sprintf (oname
, "d%06d.o", tmp_seq
);
2306 abfd
= bfd_create (oname
, parent
);
2307 bfd_find_target (pe_details
->object_target
, abfd
);
2308 bfd_make_writable (abfd
);
2310 bfd_set_format (abfd
, bfd_object
);
2311 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2314 symtab
= xmalloc (12 * sizeof (asymbol
*));
2316 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2317 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2318 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2319 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2320 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2322 if (*exp
->internal_name
== '@')
2324 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2326 if (include_jmp_stub
)
2327 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2328 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2330 /* Fastcall applies only to functions,
2331 so no need for auto-import symbol. */
2335 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2337 if (include_jmp_stub
)
2338 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2340 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2342 /* Symbol to reference ord/name of imported
2343 data symbol, used to implement auto-import. */
2345 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2348 if (pe_dll_compat_implib
)
2349 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2352 if (include_jmp_stub
)
2354 bfd_set_section_size (tx
, jmp_byte_count
);
2355 td
= xmalloc (jmp_byte_count
);
2357 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2359 switch (pe_details
->pe_arch
)
2362 #ifdef pe_use_x86_64
2363 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2365 /* Mark this object as SAFESEH compatible. */
2366 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2368 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2372 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2375 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2376 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2377 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2380 case PE_ARCH_arm_wince
:
2381 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2389 bfd_set_section_size (tx
, 0);
2391 bfd_set_section_size (id7
, 4);
2395 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2398 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2399 d5
= xmalloc (PE_IDATA5_SIZE
);
2401 memset (d5
, 0, PE_IDATA5_SIZE
);
2403 if (exp
->flag_noname
)
2405 d5
[0] = exp
->ordinal
;
2406 d5
[1] = exp
->ordinal
>> 8;
2407 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2411 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2415 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2416 d4
= xmalloc (PE_IDATA4_SIZE
);
2418 memset (d4
, 0, PE_IDATA4_SIZE
);
2420 if (exp
->flag_noname
)
2422 d4
[0] = exp
->ordinal
;
2423 d4
[1] = exp
->ordinal
>> 8;
2424 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2428 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2432 if (exp
->flag_noname
)
2435 bfd_set_section_size (id6
, 0);
2441 /* { short, asciz } */
2443 len
= 2 + strlen (exp
->its_name
) + 1;
2445 len
= 2 + strlen (exp
->name
) + 1;
2448 bfd_set_section_size (id6
, len
);
2451 memset (d6
, 0, len
);
2453 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2454 contains an invalid value (-1). */
2455 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2460 strcpy ((char*) d6
+ 2, exp
->its_name
);
2462 strcpy ((char *) d6
+ 2, exp
->name
);
2465 bfd_set_symtab (abfd
, symtab
, symptr
);
2467 if (include_jmp_stub
)
2468 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2469 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2470 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2471 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2472 if (!exp
->flag_noname
)
2473 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2475 bfd_make_readable (abfd
);
2480 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2482 /* Name thunks go to idata$4. */
2488 oname
= xmalloc (20);
2489 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2492 abfd
= bfd_create (oname
, parent
);
2493 bfd_find_target (pe_details
->object_target
, abfd
);
2494 bfd_make_writable (abfd
);
2496 bfd_set_format (abfd
, bfd_object
);
2497 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2500 symtab
= xmalloc (3 * sizeof (asymbol
*));
2501 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2502 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2503 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2505 /* We need space for the real thunk and for the null terminator. */
2506 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2507 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2509 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2510 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2513 bfd_set_symtab (abfd
, symtab
, symptr
);
2515 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2517 bfd_make_readable (abfd
);
2522 make_import_fixup_mark (arelent
*rel
, char *name
)
2524 /* We convert reloc to symbol, for later reference. */
2525 static unsigned int counter
;
2526 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2527 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2528 struct bfd_link_hash_entry
*bh
;
2529 char *fixup_name
, buf
[26];
2532 /* "name" buffer has space before the symbol name for prefixes. */
2533 sprintf (buf
, "__fu%d_", counter
++);
2534 prefix_len
= strlen (buf
);
2535 fixup_name
= name
- prefix_len
;
2536 memcpy (fixup_name
, buf
, prefix_len
);
2539 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2540 current_sec
, /* sym->section, */
2541 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2543 return bh
->root
.string
;
2546 /* .section .idata$2
2547 .rva __nm_thnk_SYM (singleton thunk with name of func)
2550 .rva __my_dll_iname (name of dll)
2551 .rva __fuNN_SYM (pointer to reference (address) in text) */
2554 make_import_fixup_entry (const char *name
,
2555 const char *fixup_name
,
2556 const char *symname
,
2564 oname
= xmalloc (20);
2565 sprintf (oname
, "fu%06d.o", tmp_seq
);
2568 abfd
= bfd_create (oname
, parent
);
2569 bfd_find_target (pe_details
->object_target
, abfd
);
2570 bfd_make_writable (abfd
);
2572 bfd_set_format (abfd
, bfd_object
);
2573 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2576 symtab
= xmalloc (6 * sizeof (asymbol
*));
2577 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2579 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2580 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2581 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2583 bfd_set_section_size (id2
, 20);
2588 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2589 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2590 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2593 bfd_set_symtab (abfd
, symtab
, symptr
);
2595 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2597 bfd_make_readable (abfd
);
2601 /* .section .rdata_runtime_pseudo_reloc
2603 .rva __fuNN_SYM (pointer to reference (address) in text) */
2606 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2607 const char *fixup_name
,
2608 bfd_vma addend ATTRIBUTE_UNUSED
,
2613 unsigned char *rt_rel_d
;
2618 oname
= xmalloc (20);
2619 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2622 abfd
= bfd_create (oname
, parent
);
2623 bfd_find_target (pe_details
->object_target
, abfd
);
2624 bfd_make_writable (abfd
);
2626 bfd_set_format (abfd
, bfd_object
);
2627 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2629 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2631 if (runtime_pseudp_reloc_v2_init
)
2632 size
= 3 * sizeof (asymbol
*);
2634 size
= 6 * sizeof (asymbol
*);
2637 size
= 2 * sizeof (asymbol
*);
2640 symtab
= xmalloc (size
);
2643 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2645 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2647 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2650 if (!runtime_pseudp_reloc_v2_init
)
2653 runtime_pseudp_reloc_v2_init
= TRUE
;
2656 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2658 bfd_set_section_size (rt_rel
, size
);
2659 rt_rel_d
= xmalloc (size
);
2660 rt_rel
->contents
= rt_rel_d
;
2661 memset (rt_rel_d
, 0, size
);
2662 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2663 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2664 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2666 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2667 save_relocs (rt_rel
);
2669 bfd_set_symtab (abfd
, symtab
, symptr
);
2671 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2675 bfd_set_section_size (rt_rel
, 8);
2676 rt_rel_d
= xmalloc (8);
2677 rt_rel
->contents
= rt_rel_d
;
2678 memset (rt_rel_d
, 0, 8);
2680 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2681 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2683 save_relocs (rt_rel
);
2685 bfd_set_symtab (abfd
, symtab
, symptr
);
2687 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2690 bfd_make_readable (abfd
);
2695 .rva __pei386_runtime_relocator */
2698 pe_create_runtime_relocator_reference (bfd
*parent
)
2700 asection
*extern_rt_rel
;
2701 unsigned char *extern_rt_rel_d
;
2705 oname
= xmalloc (20);
2706 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2709 abfd
= bfd_create (oname
, parent
);
2710 bfd_find_target (pe_details
->object_target
, abfd
);
2711 bfd_make_writable (abfd
);
2713 bfd_set_format (abfd
, bfd_object
);
2714 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2717 symtab
= xmalloc (2 * sizeof (asymbol
*));
2718 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2720 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2723 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2724 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2725 extern_rt_rel
->contents
= extern_rt_rel_d
;
2727 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2728 save_relocs (extern_rt_rel
);
2730 bfd_set_symtab (abfd
, symtab
, symptr
);
2732 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2734 bfd_make_readable (abfd
);
2739 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2740 const char *symname
)
2742 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2745 /* This is the original implementation of the auto-import feature, which
2746 primarily relied on the OS loader to patch things up with some help
2747 from the pseudo-relocator to overcome the main limitation. See the
2748 comment at the beginning of the file for an overview of the feature. */
2749 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2751 struct bfd_link_hash_entry
*name_thunk_sym
;
2752 /* name buffer is allocated with space at beginning for prefixes. */
2753 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2754 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2755 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2757 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2759 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2760 add_bfd_to_link (b
, b
->filename
, &link_info
);
2762 /* If we ever use autoimport, we have to cast text section writable. */
2763 config
.text_read_only
= FALSE
;
2764 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2767 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2769 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2770 link_info
.output_bfd
);
2771 add_bfd_to_link (b
, b
->filename
, &link_info
);
2775 /* In the original implementation, the pseudo-relocator was only used when
2776 the addend was not null. In the new implementation, the OS loader is
2777 completely bypassed and the pseudo-relocator does the entire work. */
2778 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2779 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2781 if (pe_dll_extra_pe_debug
)
2782 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2783 fixup_name
, (int) addend
);
2785 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2786 link_info
.output_bfd
);
2787 add_bfd_to_link (b
, b
->filename
, &link_info
);
2789 if (runtime_pseudo_relocs_created
++ == 0)
2791 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2792 add_bfd_to_link (b
, b
->filename
, &link_info
);
2796 else if (addend
!= 0)
2797 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2798 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2802 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2811 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2812 dll_symname
= xstrdup (dll_filename
);
2813 for (i
= 0; dll_symname
[i
]; i
++)
2814 if (!ISALNUM (dll_symname
[i
]))
2815 dll_symname
[i
] = '_';
2817 unlink_if_ordinary (impfilename
);
2819 outarch
= bfd_openw (impfilename
, 0);
2823 /* xgettext:c-format */
2824 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2829 /* xgettext:c-format */
2830 info_msg (_("Creating library file: %s\n"), impfilename
);
2832 bfd_set_format (outarch
, bfd_archive
);
2833 outarch
->has_armap
= 1;
2835 /* Work out a reasonable size of things to put onto one line. */
2836 ar_head
= make_head (outarch
);
2838 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2839 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2841 /* Iterate the exclude list. */
2842 struct exclude_list_struct
*ex
;
2844 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2846 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2848 found
= (filename_cmp (ex
->string
, ibfd
->filename
) == 0);
2850 /* If it matched, we must open a fresh BFD for it (the original
2851 input BFD is still needed for the DLL's final link) and add
2852 it into the archive member chain. */
2855 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2856 ? ibfd
->my_archive
->filename
: ibfd
->filename
, NULL
);
2859 einfo (_("%X%P: bfd_openr %s: %E\n"), ibfd
->filename
);
2862 if (ibfd
->my_archive
)
2864 /* Must now iterate through archive until we find the
2865 required member. A minor shame that we'll open the
2866 archive once per member that we require from it, and
2867 leak those archive bfds rather than reuse them. */
2868 bfd
*arbfd
= newbfd
;
2869 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2871 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2872 ibfd
->my_archive
->filename
, ibfd
->filename
);
2876 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2878 if (filename_cmp (newbfd
->filename
, ibfd
->filename
) == 0)
2883 einfo (_("%X%P: %s(%s): can't find member in archive"),
2884 ibfd
->my_archive
->filename
, ibfd
->filename
);
2888 newbfd
->archive_next
= head
;
2893 for (i
= 0; i
< def
->num_exports
; i
++)
2895 /* The import library doesn't know about the internal name. */
2896 char *internal
= def
->exports
[i
].internal_name
;
2899 /* Don't add PRIVATE entries to import lib. */
2900 if (pe_def_file
->exports
[i
].flag_private
)
2903 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2905 /* PR 19803: If a symbol has been discard due to garbage
2906 collection then do not create any exports for it. */
2908 struct coff_link_hash_entry
*h
;
2910 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2911 FALSE
, FALSE
, FALSE
);
2913 /* If the symbol is hidden and undefined then it
2914 has been swept up by garbage collection. */
2915 && h
->symbol_class
== C_HIDDEN
2916 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2919 /* If necessary, check with an underscore prefix as well. */
2920 if (pe_details
->underscored
&& internal
[0] != '@')
2924 name
= xmalloc (strlen (internal
) + 2);
2925 sprintf (name
, "_%s", internal
);
2927 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2928 FALSE
, FALSE
, FALSE
);
2932 /* If the symbol is hidden and undefined then it
2933 has been swept up by garbage collection. */
2934 && h
->symbol_class
== C_HIDDEN
2935 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2940 n
= make_one (def
->exports
+ i
, outarch
,
2941 ! (def
->exports
+ i
)->flag_data
);
2942 n
->archive_next
= head
;
2944 def
->exports
[i
].internal_name
= internal
;
2947 ar_tail
= make_tail (outarch
);
2949 if (ar_head
== NULL
|| ar_tail
== NULL
)
2952 /* Now stick them all into the archive. */
2953 ar_head
->archive_next
= head
;
2954 ar_tail
->archive_next
= ar_head
;
2957 if (! bfd_set_archive_head (outarch
, head
))
2958 einfo ("%X%P: bfd_set_archive_head: %E\n");
2960 if (! bfd_close (outarch
))
2961 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
2963 while (head
!= NULL
)
2965 bfd
*n
= head
->archive_next
;
2971 static int undef_count
= 0;
2979 static struct key_value
*udef_table
;
2981 static int undef_sort_cmp (const void *l1
, const void *r1
)
2983 const struct key_value
*l
= l1
;
2984 const struct key_value
*r
= r1
;
2986 return strcmp (l
->key
, r
->key
);
2989 static struct bfd_link_hash_entry
*
2990 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
2992 struct bfd_link_hash_entry
*h
= NULL
;
2993 struct key_value
*kv
;
2994 struct key_value key
;
2995 char *at
, *lname
= xmalloc (strlen (name
) + 3);
2997 strcpy (lname
, name
);
2999 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3004 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3009 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3010 if (h
->type
== bfd_link_hash_undefined
)
3014 if (lname
[0] == '?')
3017 if (at
|| lname
[0] == '@')
3019 if (lname
[0] == '@')
3021 if (pe_details
->underscored
)
3024 strcpy (lname
, lname
+ 1);
3026 kv
= bsearch (&key
, udef_table
, undef_count
,
3027 sizeof (struct key_value
), undef_sort_cmp
);
3030 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3031 if (h
->type
== bfd_link_hash_undefined
)
3036 *strchr (lname
, '@') = 0;
3038 kv
= bsearch (&key
, udef_table
, undef_count
,
3039 sizeof (struct key_value
), undef_sort_cmp
);
3042 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3043 if (h
->type
== bfd_link_hash_undefined
)
3049 strcat (lname
, "@");
3051 kv
= bsearch (&key
, udef_table
, undef_count
,
3052 sizeof (struct key_value
), undef_sort_cmp
);
3056 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3057 if (h
->type
== bfd_link_hash_undefined
)
3061 if (lname
[0] == '_' && pe_details
->underscored
)
3065 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3070 kv
= bsearch (&key
, udef_table
, undef_count
,
3071 sizeof (struct key_value
), undef_sort_cmp
);
3075 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3076 if (h
->type
== bfd_link_hash_undefined
)
3088 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3089 void *inf ATTRIBUTE_UNUSED
)
3091 if (h
->type
== bfd_link_hash_undefined
)
3097 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3099 if (h
->type
== bfd_link_hash_undefined
)
3103 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3104 at
= strchr (udef_table
[undef_count
].key
3105 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3108 udef_table
[undef_count
].oname
= h
->root
.string
;
3115 pe_create_undef_table (void)
3119 /* count undefined symbols */
3121 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3123 /* create and fill the corresponding table */
3124 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3127 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3130 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3134 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3136 lang_input_statement_type
*fake_file
;
3138 fake_file
= lang_add_input_file (name
,
3139 lang_input_file_is_fake_enum
,
3141 fake_file
->the_bfd
= abfd
;
3142 ldlang_add_file (fake_file
);
3144 if (!bfd_link_add_symbols (abfd
, linfo
))
3145 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3149 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3152 def_file_module
*module
;
3153 def_file_import
*imp
;
3155 pe_dll_id_target (bfd_get_target (output_bfd
));
3160 imp
= pe_def_file
->imports
;
3162 pe_create_undef_table ();
3164 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3166 int do_this_dll
= 0;
3168 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3170 if (i
>= pe_def_file
->num_imports
)
3173 dll_filename
= module
->name
;
3174 dll_symname
= xstrdup (module
->name
);
3175 for (j
= 0; dll_symname
[j
]; j
++)
3176 if (!ISALNUM (dll_symname
[j
]))
3177 dll_symname
[j
] = '_';
3179 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3181 def_file_export exp
;
3182 struct bfd_link_hash_entry
*blhe
;
3183 int lead_at
= (*imp
[i
].internal_name
== '@');
3184 /* See if we need this import. */
3185 size_t len
= strlen (imp
[i
].internal_name
);
3186 char *name
= xmalloc (len
+ 2 + 6);
3187 bfd_boolean include_jmp_stub
= FALSE
;
3188 bfd_boolean is_cdecl
= FALSE
;
3189 bfd_boolean is_undef
= FALSE
;
3191 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3195 sprintf (name
, "%s", imp
[i
].internal_name
);
3197 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3199 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3200 FALSE
, FALSE
, FALSE
);
3202 /* Include the jump stub for <sym> only if the <sym>
3204 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3207 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3209 sprintf (name
, "%s%s%s", "__imp_", U (""),
3210 imp
[i
].internal_name
);
3212 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3213 FALSE
, FALSE
, FALSE
);
3215 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3219 include_jmp_stub
= TRUE
;
3220 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3223 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3225 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3226 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3227 include_jmp_stub
= TRUE
;
3229 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3240 bfd
*ar_head
= make_head (output_bfd
);
3241 add_bfd_to_link (ar_head
, ar_head
->filename
, linfo
);
3244 exp
.internal_name
= imp
[i
].internal_name
;
3245 exp
.name
= imp
[i
].name
;
3246 exp
.its_name
= imp
[i
].its_name
;
3247 exp
.ordinal
= imp
[i
].ordinal
;
3248 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3249 exp
.flag_private
= 0;
3250 exp
.flag_constant
= 0;
3251 exp
.flag_data
= imp
[i
].data
;
3252 exp
.flag_noname
= exp
.name
? 0 : 1;
3253 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3254 add_bfd_to_link (one
, one
->filename
, linfo
);
3259 bfd
*ar_tail
= make_tail (output_bfd
);
3260 add_bfd_to_link (ar_tail
, ar_tail
->filename
, linfo
);
3269 free (udef_table
[undef_count
].key
);
3274 /* We were handed a *.DLL file. Parse it and turn it into a set of
3275 IMPORTS directives in the def file. Return TRUE if the file was
3276 handled, FALSE if not. */
3279 pe_get16 (bfd
*abfd
, int where
)
3283 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3284 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3285 return b
[0] + (b
[1] << 8);
3289 pe_get32 (bfd
*abfd
, int where
)
3293 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3294 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3295 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3301 unsigned char *b
= ptr
;
3303 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3307 pe_implied_import_dll (const char *filename
)
3310 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3311 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3312 bfd_vma exp_funcbase
;
3313 unsigned char *expdata
;
3315 bfd_vma name_rvas
, nexp
;
3316 const char *dllname
;
3317 /* Initialization with start > end guarantees that is_data
3318 will not be set by mistake, and avoids compiler warning. */
3319 bfd_vma data_start
= 1;
3320 bfd_vma data_end
= 0;
3321 bfd_vma rdata_start
= 1;
3322 bfd_vma rdata_end
= 0;
3323 bfd_vma bss_start
= 1;
3324 bfd_vma bss_end
= 0;
3327 /* No, I can't use bfd here. kernel32.dll puts its export table in
3328 the middle of the .rdata section. */
3329 dll
= bfd_openr (filename
, pe_details
->target_name
);
3332 einfo (_("%X%P: open %s: %E\n"), filename
);
3336 /* PEI dlls seem to be bfd_objects. */
3337 if (!bfd_check_format (dll
, bfd_object
))
3339 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3343 /* Get pe_header, optional header and numbers of directory entries. */
3344 pe_header_offset
= pe_get32 (dll
, 0x3c);
3345 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3346 #ifdef pe_use_x86_64
3347 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3349 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3352 /* No import or export directory entry. */
3353 if (num_entries
< 1)
3356 #ifdef pe_use_x86_64
3357 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3358 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3360 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3361 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3364 /* No export table - nothing to export. */
3365 if (export_size
== 0)
3368 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3369 secptr
= (pe_header_offset
+ 4 + 20 +
3370 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3373 /* Get the rva and size of the export section. */
3374 for (i
= 0; i
< nsections
; i
++)
3377 bfd_vma secptr1
= secptr
+ 40 * i
;
3378 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3379 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3380 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3382 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3383 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3385 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3387 expptr
= fptr
+ (export_rva
- vaddr
);
3388 if (export_rva
+ export_size
> vaddr
+ vsize
)
3389 export_size
= vsize
- (export_rva
- vaddr
);
3394 /* Scan sections and store the base and size of the
3395 data and bss segments in data/base_start/end. */
3396 for (i
= 0; i
< nsections
; i
++)
3398 bfd_vma secptr1
= secptr
+ 40 * i
;
3399 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3400 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3401 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3405 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3406 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3408 if (strcmp(sec_name
,".data") == 0)
3411 data_end
= vaddr
+ vsize
;
3413 if (pe_dll_extra_pe_debug
)
3414 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3415 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3416 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3418 else if (strcmp(sec_name
,".rdata") == 0)
3420 rdata_start
= vaddr
;
3421 rdata_end
= vaddr
+ vsize
;
3423 if (pe_dll_extra_pe_debug
)
3424 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3425 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3426 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3428 else if (strcmp (sec_name
,".bss") == 0)
3431 bss_end
= vaddr
+ vsize
;
3433 if (pe_dll_extra_pe_debug
)
3434 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3435 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3436 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3440 expdata
= xmalloc (export_size
);
3441 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3442 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3443 erva
= (char *) expdata
- export_rva
;
3445 if (pe_def_file
== 0)
3446 pe_def_file
= def_file_empty ();
3448 nexp
= pe_as32 (expdata
+ 24);
3449 name_rvas
= pe_as32 (expdata
+ 32);
3450 exp_funcbase
= pe_as32 (expdata
+ 28);
3452 /* Use internal dll name instead of filename
3453 to enable symbolic dll linking. */
3454 dllname
= erva
+ pe_as32 (expdata
+ 12);
3456 /* Check to see if the dll has already been added to
3457 the definition list and if so return without error.
3458 This avoids multiple symbol definitions. */
3459 if (def_get_module (pe_def_file
, dllname
))
3461 if (pe_dll_extra_pe_debug
)
3462 printf ("%s is already loaded\n", dllname
);
3466 /* This is an optimized version of the insertion loop, which avoids lots of
3467 calls to realloc and memmove from def_file_add_import. */
3468 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3469 erva
+ pe_as32 (erva
+ name_rvas
),
3470 dllname
, 0, NULL
, NULL
)) >= 0)
3472 for (i
= 0; i
< nexp
; i
++)
3474 /* Pointer to the names vector. */
3475 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3476 def_file_import
*imp
;
3477 /* Pointer to the function address vector. */
3478 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3479 /* is_data is true if the address is in the data, rdata or bss
3482 (func_rva
>= data_start
&& func_rva
< data_end
)
3483 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3484 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3486 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3487 dllname
, i
, NULL
, NULL
);
3488 /* Mark symbol type. */
3489 imp
->data
= is_data
;
3491 if (pe_dll_extra_pe_debug
)
3492 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3493 __FUNCTION__
, dllname
, erva
+ name_rva
,
3494 (unsigned long) func_rva
, is_data
? "(data)" : "");
3500 /* Iterate through the list of symbols. */
3501 for (i
= 0; i
< nexp
; i
++)
3503 /* Pointer to the names vector. */
3504 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3505 def_file_import
*imp
;
3506 /* Pointer to the function address vector. */
3507 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3510 /* Skip unwanted symbols, which are
3511 exported in buggy auto-import releases. */
3512 if (! CONST_STRNEQ (erva
+ name_rva
, "__nm_"))
3515 /* is_data is true if the address is in the data, rdata or bss
3518 (func_rva
>= data_start
&& func_rva
< data_end
)
3519 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3520 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3522 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3523 dllname
, i
, NULL
, NULL
, &is_dup
);
3524 /* Mark symbol type. */
3526 imp
->data
= is_data
;
3528 if (pe_dll_extra_pe_debug
)
3529 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3530 __FUNCTION__
, dllname
, erva
+ name_rva
,
3531 (unsigned long) func_rva
, is_data
? "(data)" : "");
3539 pe_output_file_set_long_section_names (bfd
*abfd
)
3541 if (pe_use_coff_long_section_names
< 0)
3543 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3544 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3547 /* These are the main functions, called from the emulation. The first
3548 is called after the bfds are read, so we can guess at how much space
3549 we need. The second is called after everything is placed, so we
3550 can put the right values in place. */
3553 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3555 pe_dll_id_target (bfd_get_target (abfd
));
3556 pe_output_file_set_long_section_names (abfd
);
3557 process_def_file_and_drectve (abfd
, info
);
3559 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3561 if (pe_dll_enable_reloc_section
)
3563 build_filler_bfd (0);
3564 pe_output_file_set_long_section_names (filler_bfd
);
3569 generate_edata (abfd
, info
);
3570 build_filler_bfd (1);
3571 pe_output_file_set_long_section_names (filler_bfd
);
3575 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3577 pe_dll_id_target (bfd_get_target (abfd
));
3578 pe_output_file_set_long_section_names (abfd
);
3579 build_filler_bfd (0);
3580 pe_output_file_set_long_section_names (filler_bfd
);
3584 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3586 pe_exe_fill_sections (abfd
, info
);
3590 fill_edata (abfd
, info
);
3591 edata_s
->contents
= edata_d
;
3594 if (bfd_link_dll (info
))
3595 pe_data (abfd
)->dll
= 1;
3599 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3601 pe_dll_id_target (bfd_get_target (abfd
));
3602 pe_output_file_set_long_section_names (abfd
);
3603 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3605 generate_reloc (abfd
, info
);
3608 bfd_set_section_size (reloc_s
, reloc_sz
);
3610 /* Resize the sections. */
3611 lang_reset_memory_regions ();
3612 lang_size_sections (NULL
, TRUE
);
3614 /* Redo special stuff. */
3615 ldemul_after_allocation ();
3617 /* Do the assignments again. */
3618 lang_do_assignments (lang_final_phase_enum
);
3620 reloc_s
->contents
= reloc_d
;
3624 pe_bfd_is_dll (bfd
*abfd
)
3626 return (bfd_get_format (abfd
) == bfd_object
3628 && pe_data (abfd
)->dll
);