1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2019 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"
40 #include "coff/internal.h"
41 #include "../bfd/libcoff.h"
46 #define PE_IDATA4_SIZE 8
47 #define PE_IDATA5_SIZE 8
50 #define AOUTSZ PEPAOUTSZ
51 #define PEAOUTHDR PEPAOUTHDR
59 #ifndef PE_IDATA4_SIZE
60 #define PE_IDATA4_SIZE 4
63 #ifndef PE_IDATA5_SIZE
64 #define PE_IDATA5_SIZE 4
67 /* This file turns a regular Windows PE image into a DLL. Because of
68 the complexity of this operation, it has been broken down into a
69 number of separate modules which are all called by the main function
70 at the end of this file. This function is not re-entrant and is
71 normally only called once, so static variables are used to reduce
72 the number of parameters and return values required.
74 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
76 /* Auto-import feature by Paul Sokolovsky
80 1. With this feature on, DLL clients can import variables from DLL
81 without any concern from their side (for example, without any source
84 2. This is done completely in bounds of the PE specification (to be fair,
85 there's a place where it pokes nose out of, but in practice it works).
86 So, resulting module can be used with any other PE compiler/linker.
88 3. Auto-import is fully compatible with standard import method and they
89 can be mixed together.
91 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
92 reference to it; load time: negligible; virtual/physical memory: should be
93 less than effect of DLL relocation, and I sincerely hope it doesn't affect
94 DLL sharability (too much).
98 The obvious and only way to get rid of dllimport insanity is to make client
99 access variable directly in the DLL, bypassing extra dereference. I.e.,
100 whenever client contains something like
104 address of dll_var in the command should be relocated to point into loaded
105 DLL. The aim is to make OS loader do so, and than make ld help with that.
106 Import section of PE made following way: there's a vector of structures
107 each describing imports from particular DLL. Each such structure points
108 to two other parallel vectors: one holding imported names, and one which
109 will hold address of corresponding imported name. So, the solution is
110 de-vectorize these structures, making import locations be sparse and
111 pointing directly into code. Before continuing, it is worth a note that,
112 while authors strives to make PE act ELF-like, there're some other people
113 make ELF act PE-like: elfvector, ;-) .
117 For each reference of data symbol to be imported from DLL (to set of which
118 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
119 import fixup entry is generated. That entry is of type
120 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
121 fixup entry contains pointer to symbol's address within .text section
122 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
123 (so, DLL name is referenced by multiple entries), and pointer to symbol
124 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
125 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
126 containing imported name. Here comes that "on the edge" problem mentioned
127 above: PE specification rambles that name vector (OriginalFirstThunk)
128 should run in parallel with addresses vector (FirstThunk), i.e. that they
129 should have same number of elements and terminated with zero. We violate
130 this, since FirstThunk points directly into machine code. But in practice,
131 OS loader implemented the sane way: it goes through OriginalFirstThunk and
132 puts addresses to FirstThunk, not something else. It once again should be
133 noted that dll and symbol name structures are reused across fixup entries
134 and should be there anyway to support standard import stuff, so sustained
135 overhead is 20 bytes per reference. Other question is whether having several
136 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
137 done even by native compiler/linker (libth32's functions are in fact reside
138 in windows9x kernel32.dll, so if you use it, you have two
139 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
140 referencing the same PE structures several times is valid. The answer is why
141 not, prohibiting that (detecting violation) would require more work on
142 behalf of loader than not doing it.
144 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
146 static void add_bfd_to_link (bfd
*, const char *, struct bfd_link_info
*);
148 /* For emultempl/pe.em. */
150 def_file
* pe_def_file
= 0;
151 int pe_dll_export_everything
= 0;
152 int pe_dll_exclude_all_symbols
= 0;
153 int pe_dll_do_default_excludes
= 1;
154 int pe_dll_kill_ats
= 0;
155 int pe_dll_stdcall_aliases
= 0;
156 int pe_dll_warn_dup_exports
= 0;
157 int pe_dll_compat_implib
= 0;
158 int pe_dll_extra_pe_debug
= 0;
159 int pe_use_nul_prefixed_import_tables
= 0;
160 int pe_use_coff_long_section_names
= -1;
161 int pe_leading_underscore
= -1;
163 /* Static variables and types. */
165 static bfd_vma image_base
;
166 static bfd
*filler_bfd
;
167 static struct bfd_section
*edata_s
, *reloc_s
;
168 static unsigned char *edata_d
, *reloc_d
;
169 static size_t edata_sz
, reloc_sz
;
170 static int runtime_pseudo_relocs_created
= 0;
171 static bfd_boolean runtime_pseudp_reloc_v2_init
= FALSE
;
178 autofilter_entry_type
;
182 const char *target_name
;
183 const char *object_target
;
184 unsigned int imagebase_reloc
;
187 bfd_boolean underscored
;
188 const autofilter_entry_type
* autofilter_symbollist
;
192 static const autofilter_entry_type autofilter_symbollist_generic
[] =
194 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
195 /* Entry point symbols. */
196 { STRING_COMMA_LEN ("DllMain") },
197 { STRING_COMMA_LEN ("DllMainCRTStartup") },
198 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
199 /* Runtime pseudo-reloc. */
200 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
201 { STRING_COMMA_LEN ("do_pseudo_reloc") },
205 static const autofilter_entry_type autofilter_symbollist_i386
[] =
207 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
208 /* Entry point symbols, and entry hooks. */
209 { STRING_COMMA_LEN ("cygwin_crt0") },
211 { STRING_COMMA_LEN ("DllMain") },
212 { STRING_COMMA_LEN ("DllEntryPoint") },
213 { STRING_COMMA_LEN ("DllMainCRTStartup") },
214 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
215 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
216 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
218 { STRING_COMMA_LEN ("DllMain@12") },
219 { STRING_COMMA_LEN ("DllEntryPoint@0") },
220 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
221 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
222 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
223 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
224 { STRING_COMMA_LEN ("cygwin_attach_dll") },
226 { STRING_COMMA_LEN ("cygwin_premain0") },
227 { STRING_COMMA_LEN ("cygwin_premain1") },
228 { STRING_COMMA_LEN ("cygwin_premain2") },
229 { STRING_COMMA_LEN ("cygwin_premain3") },
230 /* Runtime pseudo-reloc. */
231 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
232 { STRING_COMMA_LEN ("do_pseudo_reloc") },
233 /* Global vars that should not be exported. */
234 { STRING_COMMA_LEN ("impure_ptr") },
235 { STRING_COMMA_LEN ("_impure_ptr") },
236 { STRING_COMMA_LEN ("_fmode") },
237 { STRING_COMMA_LEN ("environ") },
238 { STRING_COMMA_LEN ("__dso_handle") },
242 #define PE_ARCH_i386 1
244 #define PE_ARCH_mips 3
245 #define PE_ARCH_arm 4
246 #define PE_ARCH_arm_wince 5
248 /* Don't make it constant as underscore mode gets possibly overriden
249 by target or -(no-)leading-underscore option. */
250 static pe_details_type pe_detail_list
[] =
269 autofilter_symbollist_i386
279 autofilter_symbollist_i386
285 16 /* R_SH_IMAGEBASE */,
289 autofilter_symbollist_generic
298 autofilter_symbollist_generic
307 autofilter_symbollist_generic
310 "pei-arm-wince-little",
311 "pe-arm-wince-little",
312 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
316 autofilter_symbollist_generic
318 { NULL
, NULL
, 0, 0, 0, FALSE
, NULL
}
321 static const pe_details_type
*pe_details
;
323 /* Do not specify library suffix explicitly, to allow for dllized versions. */
324 static const autofilter_entry_type autofilter_liblist
[] =
326 { STRING_COMMA_LEN ("libcegcc") },
327 { STRING_COMMA_LEN ("libcygwin") },
328 { STRING_COMMA_LEN ("libgcc") },
329 { STRING_COMMA_LEN ("libgcc_s") },
330 { STRING_COMMA_LEN ("libstdc++") },
331 { STRING_COMMA_LEN ("libmingw32") },
332 { STRING_COMMA_LEN ("libmingwex") },
333 { STRING_COMMA_LEN ("libg2c") },
334 { STRING_COMMA_LEN ("libsupc++") },
335 { STRING_COMMA_LEN ("libobjc") },
336 { STRING_COMMA_LEN ("libgcj") },
337 { STRING_COMMA_LEN ("libmsvcrt") },
338 { STRING_COMMA_LEN ("libmsvcrt-os") },
339 { STRING_COMMA_LEN ("libucrtbase") },
343 /* Regardless of the suffix issue mentioned above, we must ensure that
344 we do not falsely match on a leading substring, such as when libtool
345 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
346 This routine ensures that the leading part of the name matches and that
347 it is followed by only an optional version suffix and a file extension,
348 returning zero if so or -1 if not. */
349 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
351 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
354 libname
+= afptr
->len
;
356 /* Be liberal in interpreting what counts as a version suffix; we
357 accept anything that has a dash to separate it from the name and
358 begins with a digit. */
359 if (libname
[0] == '-')
361 if (!ISDIGIT (*++libname
))
363 /* Ensure the filename has an extension. */
364 while (*++libname
!= '.')
368 else if (libname
[0] != '.')
374 static const autofilter_entry_type autofilter_objlist
[] =
376 { STRING_COMMA_LEN ("crt0.o") },
377 { STRING_COMMA_LEN ("crt1.o") },
378 { STRING_COMMA_LEN ("crt2.o") },
379 { STRING_COMMA_LEN ("dllcrt1.o") },
380 { STRING_COMMA_LEN ("dllcrt2.o") },
381 { STRING_COMMA_LEN ("gcrt0.o") },
382 { STRING_COMMA_LEN ("gcrt1.o") },
383 { STRING_COMMA_LEN ("gcrt2.o") },
384 { STRING_COMMA_LEN ("crtbegin.o") },
385 { STRING_COMMA_LEN ("crtend.o") },
389 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
391 /* _imp_ is treated specially, as it is always underscored. */
392 /* { STRING_COMMA_LEN ("_imp_") }, */
393 /* Don't export some c++ symbols. */
394 { STRING_COMMA_LEN ("__rtti_") },
395 { STRING_COMMA_LEN ("__builtin_") },
396 /* Don't re-export auto-imported symbols. */
397 { STRING_COMMA_LEN ("__nm_") },
398 /* Don't export symbols specifying internal DLL layout. */
399 { STRING_COMMA_LEN ("_head_") },
400 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
401 /* Don't export section labels or artificial symbols
403 { STRING_COMMA_LEN (".") },
407 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
409 { STRING_COMMA_LEN ("_iname") },
410 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
414 #define U(str) (pe_details->underscored ? "_" str : str)
417 pe_dll_id_target (const char *target
)
421 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
422 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
423 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
425 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
427 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
430 pe_detail_list
[i
].underscored
= (u
!= 0 ? TRUE
: FALSE
);
431 pe_details
= pe_detail_list
+ i
;
432 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
435 einfo (_("%X%P: unsupported PEI architecture: %s\n"), target
);
439 /* Helper functions for qsort. Relocs must be sorted so that we can write
440 them out by pages. */
451 reloc_sort (const void *va
, const void *vb
)
453 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
454 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
456 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
460 pe_export_sort (const void *va
, const void *vb
)
462 const def_file_export
*a
= va
;
463 const def_file_export
*b
= vb
;
471 return strcmp (an
, bn
);
474 /* Read and process the .DEF file. */
476 /* These correspond to the entries in pe_def_file->exports[]. I use
477 exported_symbol_sections[i] to tag whether or not the symbol was
478 defined, since we can't export symbols we don't have. */
480 static bfd_vma
*exported_symbol_offsets
;
481 static struct bfd_section
**exported_symbol_sections
;
482 static int export_table_size
;
483 static int count_exported
;
484 static int count_exported_byname
;
485 static int count_with_ordinals
;
486 static const char *dll_name
;
487 static int min_ordinal
, max_ordinal
;
488 static int *exported_symbols
;
490 typedef struct exclude_list_struct
493 struct exclude_list_struct
*next
;
498 static struct exclude_list_struct
*excludes
= 0;
501 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
504 char *exclude_string
;
506 local_copy
= xstrdup (new_excludes
);
508 exclude_string
= strtok (local_copy
, ",:");
509 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
511 struct exclude_list_struct
*new_exclude
;
513 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
514 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
515 strcpy (new_exclude
->string
, exclude_string
);
516 new_exclude
->type
= type
;
517 new_exclude
->next
= excludes
;
518 excludes
= new_exclude
;
525 is_import (const char* n
)
527 return (CONST_STRNEQ (n
, "__imp_"));
530 /* abfd is a bfd containing n (or NULL)
531 It can be used for contextual checks. */
534 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
537 struct exclude_list_struct
*ex
;
538 const autofilter_entry_type
*afptr
;
539 const char * libname
= NULL
;
541 if (abfd
&& abfd
->my_archive
)
542 libname
= lbasename (abfd
->my_archive
->filename
);
544 key
.name
= key
.its_name
= (char *) n
;
546 /* Return false if n is in the d->exports table. */
547 if (bsearch (&key
, d
->exports
, d
->num_exports
,
548 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
551 if (pe_dll_do_default_excludes
)
556 if (pe_dll_extra_pe_debug
)
557 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
558 n
, abfd
, abfd
->my_archive
);
560 /* First of all, make context checks:
561 Don't export anything from standard libs. */
564 afptr
= autofilter_liblist
;
568 if (libnamencmp (libname
, afptr
) == 0 )
574 /* Next, exclude symbols from certain startup objects. */
576 if (abfd
&& (p
= lbasename (abfd
->filename
)))
578 afptr
= autofilter_objlist
;
581 if (strcmp (p
, afptr
->name
) == 0)
587 /* Don't try to blindly exclude all symbols
588 that begin with '__'; this was tried and
589 it is too restrictive. Instead we have
590 a target specific list to use: */
591 afptr
= pe_details
->autofilter_symbollist
;
595 if (strcmp (n
, afptr
->name
) == 0)
601 /* Next, exclude symbols starting with ... */
602 afptr
= autofilter_symbolprefixlist
;
605 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
611 /* Finally, exclude symbols ending with ... */
613 afptr
= autofilter_symbolsuffixlist
;
616 if ((len
>= afptr
->len
)
617 /* Add 1 to insure match with trailing '\0'. */
618 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
619 afptr
->len
+ 1) == 0)
626 for (ex
= excludes
; ex
; ex
= ex
->next
)
628 if (ex
->type
== EXCLUDELIBS
)
631 && ((filename_cmp (libname
, ex
->string
) == 0)
632 || (strcasecmp ("ALL", ex
->string
) == 0)))
635 else if (ex
->type
== EXCLUDEFORIMPLIB
)
637 if (filename_cmp (abfd
->filename
, ex
->string
) == 0)
640 else if (strcmp (n
, ex
->string
) == 0)
648 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
651 struct bfd_link_hash_entry
*blhe
;
653 struct bfd_section
*s
;
654 def_file_export
*e
= 0;
655 bfd_boolean resort_needed
;
658 pe_def_file
= def_file_empty ();
660 /* First, run around to all the objects looking for the .drectve
661 sections, and push those into the def file too. */
662 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
664 s
= bfd_get_section_by_name (b
, ".drectve");
668 char *buf
= xmalloc (size
);
670 bfd_get_section_contents (b
, s
, buf
, 0, size
);
671 def_file_add_directive (pe_def_file
, buf
, size
);
676 /* Process aligned common symbol information from the
677 .drectve sections now; common symbol allocation is
678 done before final link, so it will be too late to
679 process them in process_embedded_commands() called
680 from _bfd_coff_link_input_bfd(). */
681 if (pe_def_file
->aligncomms
)
683 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
686 struct coff_link_hash_entry
*sym_hash
;
687 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
688 ac
->symbol_name
, FALSE
, FALSE
, FALSE
);
689 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
690 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
692 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
698 /* If we are building an executable and there is nothing
699 to export, we do not build an export table at all. */
700 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
701 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
704 /* Now, maybe export everything else the default way. */
705 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
706 && !pe_dll_exclude_all_symbols
)
708 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
713 if (!bfd_generic_link_read_symbols (b
))
715 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
719 symbols
= bfd_get_outsymbols (b
);
720 nsyms
= bfd_get_symcount (b
);
722 for (j
= 0; j
< nsyms
; j
++)
724 /* We should export symbols which are either global or not
725 anything at all. (.bss data is the latter)
726 We should not export undefined symbols. */
727 bfd_boolean would_export
728 = (symbols
[j
]->section
!= bfd_und_section_ptr
729 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
730 || (symbols
[j
]->flags
== 0)));
731 if (link_info
.version_info
&& would_export
)
733 = !bfd_hide_sym_by_version (link_info
.version_info
,
737 const char *sn
= symbols
[j
]->name
;
739 /* We should not re-export imported stuff. */
745 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
746 sprintf (name
, "%s%s", "__imp_", sn
);
748 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
749 FALSE
, FALSE
, FALSE
);
752 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
756 if (pe_details
->underscored
&& *sn
== '_')
759 if (auto_export (b
, pe_def_file
, sn
))
764 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
766 /* Fill data flag properly, from dlltool.c. */
768 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
776 #define NE pe_def_file->num_exports
778 /* Don't create an empty export table. */
782 resort_needed
= FALSE
;
784 /* Canonicalize the export list. */
787 for (i
= 0; i
< NE
; i
++)
789 /* Check for fastcall/stdcall-decoration, but ignore
790 C++ mangled names. */
791 if (pe_def_file
->exports
[i
].name
[0] != '?'
792 && strchr (pe_def_file
->exports
[i
].name
, '@'))
794 /* This will preserve internal_name, which may have been
795 pointing to the same memory as name, or might not
797 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
798 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
799 char *tmp_at
= strrchr (tmp
, '@');
804 einfo (_("%X%P: cannot export %s: invalid export name\n"),
805 pe_def_file
->exports
[i
].name
);
806 pe_def_file
->exports
[i
].name
= tmp
;
807 resort_needed
= TRUE
;
812 /* Re-sort the exports table as we have possibly changed the order
813 by removing leading @. */
815 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
818 if (pe_dll_stdcall_aliases
)
820 for (i
= 0; i
< NE
; i
++)
822 if (is_import (pe_def_file
->exports
[i
].name
))
825 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
828 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
829 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
831 *(strchr (tmp
, '@')) = 0;
832 if (auto_export (NULL
, pe_def_file
, tmp
))
833 def_file_add_export (pe_def_file
, tmp
,
834 pe_def_file
->exports
[i
].internal_name
,
842 /* Convenience, but watch out for it changing. */
843 e
= pe_def_file
->exports
;
845 for (i
= 0, j
= 0; i
< NE
; i
++)
847 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
849 /* This is a duplicate. */
850 if (e
[j
- 1].ordinal
!= -1
851 && e
[i
].ordinal
!= -1
852 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
854 if (pe_dll_warn_dup_exports
)
855 /* xgettext:c-format */
856 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
857 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
861 if (pe_dll_warn_dup_exports
)
862 /* xgettext:c-format */
863 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
867 if (e
[i
].ordinal
!= -1)
868 e
[j
- 1].ordinal
= e
[i
].ordinal
;
869 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
870 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
871 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
872 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
875 if (e
[i
].internal_name
)
876 free (e
[i
].internal_name
);
878 free (e
[i
].its_name
);
887 pe_def_file
->num_exports
= j
; /* == NE */
889 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
890 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
892 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
896 count_exported_byname
= 0;
897 count_with_ordinals
= 0;
899 for (i
= 0; i
< NE
; i
++)
901 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
904 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
905 lang_add_gc_name (int_name
);
907 name
= xmalloc (strlen (int_name
) + 2);
908 if (pe_details
->underscored
&& int_name
[0] != '@')
911 strcpy (name
+ 1, int_name
);
913 /* PR 19803: The alias must be preserved as well. */
914 lang_add_gc_name (xstrdup (name
));
917 strcpy (name
, int_name
);
919 blhe
= bfd_link_hash_lookup (info
->hash
,
924 && (blhe
->type
== bfd_link_hash_defined
925 || (blhe
->type
== bfd_link_hash_common
)))
928 if (!pe_def_file
->exports
[i
].flag_noname
)
929 count_exported_byname
++;
931 /* Only fill in the sections. The actual offsets are computed
932 in fill_exported_offsets() after common symbols are laid
934 if (blhe
->type
== bfd_link_hash_defined
)
935 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
937 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
939 if (pe_def_file
->exports
[i
].ordinal
!= -1)
941 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
942 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
943 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
944 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
945 count_with_ordinals
++;
948 /* Check for forward exports. These are indicated in DEF files by an
949 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
950 but we must take care not to be fooled when the user wants to export
951 a symbol that actually really has a dot in it, so we only check
952 for them here, after real defined symbols have already been matched. */
953 else if (strchr (int_name
, '.'))
956 if (!pe_def_file
->exports
[i
].flag_noname
)
957 count_exported_byname
++;
959 pe_def_file
->exports
[i
].flag_forward
= 1;
961 if (pe_def_file
->exports
[i
].ordinal
!= -1)
963 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
964 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
965 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
966 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
967 count_with_ordinals
++;
970 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
972 /* xgettext:c-format */
973 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
978 /* xgettext:c-format */
979 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
981 blhe
->type
, bfd_link_hash_defined
);
985 /* xgettext:c-format */
986 einfo (_("%X%P: cannot export %s: symbol not found\n"),
993 /* Build the bfd that will contain .edata and .reloc sections. */
996 build_filler_bfd (int include_edata
)
998 lang_input_statement_type
*filler_file
;
999 filler_file
= lang_add_input_file ("dll stuff",
1000 lang_input_file_is_fake_enum
,
1002 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1003 link_info
.output_bfd
);
1004 if (filler_bfd
== NULL
1005 || !bfd_set_arch_mach (filler_bfd
,
1006 bfd_get_arch (link_info
.output_bfd
),
1007 bfd_get_mach (link_info
.output_bfd
)))
1009 einfo (_("%F%P: can not create BFD: %E\n"));
1015 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1017 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1023 einfo (_("%X%P: can not create .edata section: %E\n"));
1026 bfd_set_section_size (edata_s
, edata_sz
);
1029 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1031 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1037 einfo (_("%X%P: can not create .reloc section: %E\n"));
1041 bfd_set_section_size (reloc_s
, 0);
1043 ldlang_add_file (filler_file
);
1046 /* Gather all the exported symbols and build the .edata section. */
1049 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1051 int i
, next_ordinal
;
1052 int name_table_size
= 0;
1055 /* First, we need to know how many exported symbols there are,
1056 and what the range of ordinals is. */
1057 if (pe_def_file
->name
)
1058 dll_name
= pe_def_file
->name
;
1061 dll_name
= abfd
->filename
;
1063 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1064 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1065 dll_name
= dlnp
+ 1;
1068 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1070 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1071 min_ordinal
= max_ordinal
- count_exported
+ 1;
1076 max_ordinal
= count_exported
;
1079 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1080 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1081 for (i
= 0; i
< export_table_size
; i
++)
1082 exported_symbols
[i
] = -1;
1084 /* Now we need to assign ordinals to those that don't have them. */
1085 for (i
= 0; i
< NE
; i
++)
1087 if (exported_symbol_sections
[i
]
1088 || pe_def_file
->exports
[i
].flag_forward
)
1090 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1092 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1093 int pi
= exported_symbols
[ei
];
1097 /* xgettext:c-format */
1098 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1099 pe_def_file
->exports
[i
].ordinal
,
1100 pe_def_file
->exports
[i
].name
,
1101 pe_def_file
->exports
[pi
].name
);
1103 exported_symbols
[ei
] = i
;
1105 if (pe_def_file
->exports
[i
].its_name
)
1106 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1108 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1111 /* Reserve space for the forward name. */
1112 if (pe_def_file
->exports
[i
].flag_forward
)
1114 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1118 next_ordinal
= min_ordinal
;
1119 for (i
= 0; i
< NE
; i
++)
1120 if ((exported_symbol_sections
[i
]
1121 || pe_def_file
->exports
[i
].flag_forward
)
1122 && pe_def_file
->exports
[i
].ordinal
== -1)
1124 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1127 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1128 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1131 /* PR 12969: Check for more than 1^16 ordinals. */
1132 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1133 /* xgettext:c-format */
1134 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1135 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1137 /* OK, now we can allocate some memory. */
1138 edata_sz
= (40 /* directory */
1139 + 4 * export_table_size
/* addresses */
1140 + 4 * count_exported_byname
/* name ptrs */
1141 + 2 * count_exported_byname
/* ordinals */
1142 + name_table_size
+ strlen (dll_name
) + 1);
1145 /* Fill the exported symbol offsets. The preliminary work has already
1146 been done in process_def_file_and_drectve(). */
1149 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1152 struct bfd_link_hash_entry
*blhe
;
1154 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1158 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1159 if (pe_details
->underscored
1160 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1163 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1166 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1168 blhe
= bfd_link_hash_lookup (info
->hash
,
1170 FALSE
, FALSE
, TRUE
);
1172 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1173 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1180 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1183 unsigned char *edirectory
;
1184 unsigned char *eaddresses
;
1185 unsigned char *enameptrs
;
1186 unsigned char *eordinals
;
1189 edata_d
= xmalloc (edata_sz
);
1191 /* Note use of array pointer math here. */
1192 edirectory
= edata_d
;
1193 eaddresses
= edirectory
+ 40;
1194 enameptrs
= eaddresses
+ 4 * export_table_size
;
1195 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1196 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1198 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1199 + edata_s->output_section->vma - image_base)
1201 memset (edata_d
, 0, edata_sz
);
1203 if (pe_data (abfd
)->insert_timestamp
)
1204 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1206 if (pe_def_file
->version_major
!= -1)
1208 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1209 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1212 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1213 strcpy (enamestr
, dll_name
);
1214 enamestr
+= strlen (enamestr
) + 1;
1215 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1216 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1217 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1218 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1219 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1220 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1222 fill_exported_offsets (abfd
, info
);
1224 /* Ok, now for the filling in part.
1225 Scan alphabetically - ie the ordering in the exports[] table,
1226 rather than by ordinal - the ordering in the exported_symbol[]
1227 table. See dlltool.c and:
1228 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1229 for more information. */
1231 for (s
= 0; s
< NE
; s
++)
1233 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1234 if (pe_def_file
->exports
[s
].ordinal
!= -1
1235 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1237 int ord
= pe_def_file
->exports
[s
].ordinal
;
1239 if (pe_def_file
->exports
[s
].flag_forward
)
1241 bfd_put_32 (abfd
, ERVA (enamestr
),
1242 eaddresses
+ 4 * (ord
- min_ordinal
));
1244 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1245 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1249 bfd_vma srva
= (exported_symbol_offsets
[s
]
1250 + ssec
->output_section
->vma
1251 + ssec
->output_offset
);
1253 bfd_put_32 (abfd
, srva
- image_base
,
1254 eaddresses
+ 4 * (ord
- min_ordinal
));
1257 if (!pe_def_file
->exports
[s
].flag_noname
)
1259 char *ename
= pe_def_file
->exports
[s
].name
;
1260 if (pe_def_file
->exports
[s
].its_name
)
1261 ename
= pe_def_file
->exports
[s
].its_name
;
1263 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1265 strcpy (enamestr
, ename
);
1266 enamestr
+= strlen (enamestr
) + 1;
1267 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1269 pe_def_file
->exports
[s
].hint
= hint
++;
1276 static struct bfd_section
*current_sec
;
1279 pe_walk_relocs (struct bfd_link_info
*info
,
1281 const char *symname
,
1282 struct bfd_hash_table
*import_hash
,
1283 void (*cb
) (arelent
*, asection
*, char *, const char *))
1288 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1292 if (!bfd_generic_link_read_symbols (b
))
1294 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1298 symbols
= bfd_get_outsymbols (b
);
1300 for (s
= b
->sections
; s
; s
= s
->next
)
1303 int relsize
, nrelocs
, i
;
1304 int flags
= bfd_section_flags (s
);
1306 /* Skip discarded linkonce sections. */
1307 if (flags
& SEC_LINK_ONCE
1308 && s
->output_section
== bfd_abs_section_ptr
)
1313 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1314 relocs
= xmalloc (relsize
);
1315 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1317 for (i
= 0; i
< nrelocs
; i
++)
1319 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1321 /* Warning: the callback needs to be passed NAME directly. */
1324 if (bfd_hash_lookup (import_hash
, sym
->name
, FALSE
, FALSE
))
1326 strcpy (name
, sym
->name
);
1327 cb (relocs
[i
], s
, name
, symname
);
1332 if (strcmp (name
, sym
->name
) == 0)
1333 cb (relocs
[i
], s
, name
, symname
);
1339 /* Warning: the allocated symbols are remembered in BFD and reused
1340 later, so don't free them! */
1341 /* free (symbols); */
1347 pe_find_data_imports (const char *symhead
,
1348 void (*cb
) (arelent
*, asection
*, char *, const char *))
1350 struct bfd_link_hash_entry
*undef
;
1351 const size_t headlen
= strlen (symhead
);
1354 struct bfd_hash_table
*import_hash
;
1356 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1357 if (undef
->type
== bfd_link_hash_undefined
)
1359 size_t len
= strlen (undef
->root
.string
);
1366 /* For the pseudo-relocation support version 2, we can collect the symbols
1367 that are subject to auto-import and adjust the relocations en masse. */
1368 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1371 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1372 if (!bfd_hash_table_init (import_hash
,
1374 sizeof (struct bfd_hash_entry
)))
1375 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1380 /* We are being a bit cunning here. The buffer will have space for
1381 prefixes at the beginning. The prefix is modified here and in a
1382 number of functions called from this function. */
1383 #define PREFIX_LEN 32
1384 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1385 name
= buf
+ PREFIX_LEN
;
1387 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1388 if (undef
->type
== bfd_link_hash_undefined
)
1390 struct bfd_link_hash_entry
*sym
;
1393 if (pe_dll_extra_pe_debug
)
1394 printf ("%s:%s\n", __FUNCTION__
, undef
->root
.string
);
1396 strcpy (name
, undef
->root
.string
);
1397 impname
= name
- (sizeof "__imp_" - 1);
1398 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1400 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1402 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1405 bfd_hash_lookup (import_hash
, undef
->root
.string
, TRUE
, FALSE
);
1408 bfd
*b
= sym
->u
.def
.section
->owner
;
1409 const char *symname
= NULL
;
1413 if (!bfd_generic_link_read_symbols (b
))
1415 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1419 symbols
= bfd_get_outsymbols (b
);
1420 nsyms
= bfd_get_symcount (b
);
1422 for (i
= 0; i
< nsyms
; i
++)
1423 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1425 if (pe_dll_extra_pe_debug
)
1426 printf ("->%s\n", symbols
[i
]->name
);
1428 symname
= symbols
[i
]->name
+ headlen
;
1432 /* If the symobl isn't part of an import table, there is no
1433 point in building a fixup, this would give rise to link
1434 errors for mangled symbols instead of the original one. */
1436 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1441 /* Let's differentiate it somehow from defined. */
1442 undef
->type
= bfd_link_hash_defweak
;
1443 undef
->u
.def
.value
= sym
->u
.def
.value
;
1444 undef
->u
.def
.section
= sym
->u
.def
.section
;
1446 /* We replace the original name with the __imp_ prefixed one, this
1447 1) may trash memory 2) leads to duplicate symbols. But this is
1448 better than having a misleading name that can confuse GDB. */
1449 undef
->root
.string
= sym
->root
.string
;
1451 if (link_info
.pei386_auto_import
== -1)
1453 static bfd_boolean warned
= FALSE
;
1455 info_msg (_("Info: resolving %s by linking to %s "
1456 "(auto-import)\n"), name
, impname
);
1458 /* PR linker/4844. */
1461 einfo (_("%P: warning: auto-importing has been activated "
1462 "without --enable-auto-import specified on the "
1463 "command line; this should work unless it "
1464 "involves constant data structures referencing "
1465 "symbols from auto-imported DLLs\n"));
1472 /* If we have the import hash table, walk the relocations only once. */
1475 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1476 bfd_hash_table_free (import_hash
);
1483 /* Gather all the relocations and build the .reloc section. */
1486 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1489 /* For .reloc stuff. */
1490 reloc_data_type
*reloc_data
;
1491 int total_relocs
= 0;
1493 bfd_vma sec_page
= (bfd_vma
) -1;
1494 bfd_vma page_ptr
, page_count
;
1497 struct bfd_section
*s
;
1500 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1501 for (s
= b
->sections
; s
; s
= s
->next
)
1502 total_relocs
+= s
->reloc_count
;
1504 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1508 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1511 int relsize
, nrelocs
;
1513 for (s
= b
->sections
; s
; s
= s
->next
)
1515 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1518 /* If it's not loaded, we don't need to relocate it this way. */
1519 if (!(s
->output_section
->flags
& SEC_LOAD
))
1522 /* I don't know why there would be a reloc for these, but I've
1523 seen it happen - DJ */
1524 if (s
->output_section
== bfd_abs_section_ptr
)
1527 if (s
->output_section
->vma
== 0)
1529 /* Huh? Shouldn't happen, but punt if it does. */
1530 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1531 s
->output_section
->name
, s
->output_section
->index
,
1532 s
->output_section
->flags
);
1536 if (!bfd_generic_link_read_symbols (b
))
1538 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1542 symbols
= bfd_get_outsymbols (b
);
1543 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1544 relocs
= xmalloc (relsize
);
1545 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1547 for (i
= 0; i
< nrelocs
; i
++)
1549 if (pe_dll_extra_pe_debug
)
1551 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1552 printf ("rel: %s\n", sym
->name
);
1554 if (!relocs
[i
]->howto
->pc_relative
1555 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1557 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1559 /* Don't create relocs for undefined weak symbols. */
1560 if (sym
->flags
== BSF_WEAK
)
1562 struct bfd_link_hash_entry
*blhe
1563 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1564 FALSE
, FALSE
, FALSE
);
1565 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1567 /* Check aux sym and see if it is defined or not. */
1568 struct coff_link_hash_entry
*h
, *h2
;
1569 h
= (struct coff_link_hash_entry
*)blhe
;
1570 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1572 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1573 [h
->aux
->x_sym
.x_tagndx
.l
];
1574 /* We don't want a base reloc if the aux sym is not
1575 found, undefined, or if it is the constant ABS
1576 zero default value. (We broaden that slightly by
1577 not testing the value, just the section; there's
1578 no reason we'd want a reference to any absolute
1579 address to get relocated during rebasing). */
1580 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1581 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1584 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1587 /* Nor for Dwarf FDE references to discarded sections. */
1588 else if (bfd_is_abs_section (sym
->section
->output_section
))
1590 /* We only ignore relocs from .eh_frame sections, as
1591 they are discarded by the final link rather than
1592 resolved against the kept section. */
1593 if (!strcmp (s
->name
, ".eh_frame"))
1597 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1599 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1601 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1602 relocs
[i
]->howto
->rightshift
)
1604 #ifdef pe_use_x86_64
1605 case BITS_AND_SHIFT (64, 0):
1606 reloc_data
[total_relocs
].type
= 10;
1610 case BITS_AND_SHIFT (32, 0):
1611 reloc_data
[total_relocs
].type
= 3;
1614 case BITS_AND_SHIFT (16, 0):
1615 reloc_data
[total_relocs
].type
= 2;
1618 case BITS_AND_SHIFT (16, 16):
1619 reloc_data
[total_relocs
].type
= 4;
1620 /* FIXME: we can't know the symbol's right value
1621 yet, but we probably can safely assume that
1622 CE will relocate us in 64k blocks, so leaving
1624 reloc_data
[total_relocs
].extra
= 0;
1627 case BITS_AND_SHIFT (26, 2):
1628 reloc_data
[total_relocs
].type
= 5;
1631 case BITS_AND_SHIFT (24, 2):
1632 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1633 Those ARM_xxx definitions should go in proper
1635 if (relocs
[i
]->howto
->type
== 0
1636 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1637 || relocs
[i
]->howto
->type
== 5)
1638 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1639 that has already been fully processed during a
1640 previous link stage, so ignore it here. */
1644 /* xgettext:c-format */
1645 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1646 relocs
[i
]->howto
->bitsize
);
1652 /* Warning: the allocated symbols are remembered in BFD and
1653 reused later, so don't free them! */
1657 /* At this point, we have total_relocs relocation addresses in
1658 reloc_addresses, which are all suitable for the .reloc section.
1659 We must now create the new sections. */
1660 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1662 for (i
= 0; i
< total_relocs
; i
++)
1664 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1666 if (this_page
!= sec_page
)
1668 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1670 sec_page
= this_page
;
1675 if (reloc_data
[i
].type
== 4)
1679 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1680 reloc_d
= xmalloc (reloc_sz
);
1681 sec_page
= (bfd_vma
) -1;
1683 page_ptr
= (bfd_vma
) -1;
1686 for (i
= 0; i
< total_relocs
; i
++)
1688 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1689 bfd_vma this_page
= (rva
& ~0xfff);
1691 if (this_page
!= sec_page
)
1693 while (reloc_sz
& 3)
1694 reloc_d
[reloc_sz
++] = 0;
1696 if (page_ptr
!= (bfd_vma
) -1)
1697 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1699 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1700 page_ptr
= reloc_sz
;
1702 sec_page
= this_page
;
1706 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1707 reloc_d
+ reloc_sz
);
1710 if (reloc_data
[i
].type
== 4)
1712 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1719 while (reloc_sz
& 3)
1720 reloc_d
[reloc_sz
++] = 0;
1722 if (page_ptr
!= (bfd_vma
) -1)
1723 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1725 while (reloc_sz
< reloc_s
->size
)
1726 reloc_d
[reloc_sz
++] = 0;
1729 /* Given the exiting def_file structure, print out a .DEF file that
1730 corresponds to it. */
1733 quoteput (char *s
, FILE *f
, int needs_quotes
)
1737 for (cp
= s
; *cp
; cp
++)
1752 if (*s
== '"' || *s
== '\\')
1766 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1769 FILE *out
= fopen (pe_out_def_filename
, "w");
1772 /* xgettext:c-format */
1773 einfo (_("%P: can't open output def file %s\n"),
1774 pe_out_def_filename
);
1778 if (pe_def_file
->name
)
1780 if (pe_def_file
->is_dll
)
1781 fprintf (out
, "LIBRARY ");
1783 fprintf (out
, "NAME ");
1785 quoteput (pe_def_file
->name
, out
, 1);
1787 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1789 fprintf (out
, " BASE=0x");
1790 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1792 fprintf (out
, "\n");
1795 if (pe_def_file
->description
)
1797 fprintf (out
, "DESCRIPTION ");
1798 quoteput (pe_def_file
->description
, out
, 1);
1799 fprintf (out
, "\n");
1802 if (pe_def_file
->version_minor
!= -1)
1803 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1804 pe_def_file
->version_minor
);
1805 else if (pe_def_file
->version_major
!= -1)
1806 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1808 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1809 fprintf (out
, "\n");
1811 if (pe_def_file
->stack_commit
!= -1)
1812 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1813 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1814 else if (pe_def_file
->stack_reserve
!= -1)
1815 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1817 if (pe_def_file
->heap_commit
!= -1)
1818 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1819 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1820 else if (pe_def_file
->heap_reserve
!= -1)
1821 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1823 if (pe_def_file
->num_section_defs
> 0)
1825 fprintf (out
, "\nSECTIONS\n\n");
1827 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1830 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1832 if (pe_def_file
->section_defs
[i
].class)
1834 fprintf (out
, " CLASS ");
1835 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1838 if (pe_def_file
->section_defs
[i
].flag_read
)
1839 fprintf (out
, " READ");
1841 if (pe_def_file
->section_defs
[i
].flag_write
)
1842 fprintf (out
, " WRITE");
1844 if (pe_def_file
->section_defs
[i
].flag_execute
)
1845 fprintf (out
, " EXECUTE");
1847 if (pe_def_file
->section_defs
[i
].flag_shared
)
1848 fprintf (out
, " SHARED");
1850 fprintf (out
, "\n");
1854 if (pe_def_file
->num_exports
> 0)
1856 fprintf (out
, "EXPORTS\n");
1858 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1860 def_file_export
*e
= pe_def_file
->exports
+ i
;
1862 quoteput (e
->name
, out
, 0);
1864 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1866 fprintf (out
, " = ");
1867 quoteput (e
->internal_name
, out
, 0);
1870 if (e
->ordinal
!= -1)
1871 fprintf (out
, " @%d", e
->ordinal
);
1873 if (e
->flag_private
)
1874 fprintf (out
, " PRIVATE");
1876 if (e
->flag_constant
)
1877 fprintf (out
, " CONSTANT");
1880 fprintf (out
, " NONAME");
1883 fprintf (out
, " DATA");
1885 fprintf (out
, "\n");
1889 if (pe_def_file
->num_imports
> 0)
1891 fprintf (out
, "\nIMPORTS\n\n");
1893 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1895 def_file_import
*im
= pe_def_file
->imports
+ i
;
1898 if (im
->internal_name
1899 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1901 quoteput (im
->internal_name
, out
, 0);
1902 fprintf (out
, " = ");
1905 quoteput (im
->module
->name
, out
, 0);
1909 quoteput (im
->name
, out
, 0);
1911 fprintf (out
, "%d", im
->ordinal
);
1915 fprintf (out
, " == ");
1916 quoteput (im
->its_name
, out
, 0);
1919 fprintf (out
, "\n");
1924 fprintf (out
, _("; no contents available\n"));
1926 if (fclose (out
) == EOF
)
1927 /* xgettext:c-format */
1928 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1931 /* Generate the import library. */
1933 static asymbol
**symtab
;
1936 static const char *dll_filename
;
1937 static char *dll_symname
;
1939 #define UNDSEC bfd_und_section_ptr
1942 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1947 sec
= bfd_make_section_old_way (abfd
, name
);
1948 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1949 bfd_set_section_alignment (sec
, align
);
1950 /* Remember to undo this before trying to link internally! */
1951 sec
->output_section
= sec
;
1953 sym
= bfd_make_empty_symbol (abfd
);
1954 symtab
[symptr
++] = sym
;
1955 sym
->name
= sec
->name
;
1957 sym
->flags
= BSF_LOCAL
;
1964 quick_symbol (bfd
*abfd
,
1973 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1978 sym
= bfd_make_empty_symbol (abfd
);
1983 symtab
[symptr
++] = sym
;
1986 static arelent
*reltab
= 0;
1987 static int relcount
= 0, relsize
= 0;
1990 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1992 if (relcount
>= relsize
- 1)
1996 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1998 reltab
= xmalloc (relsize
* sizeof (arelent
));
2000 reltab
[relcount
].address
= address
;
2001 reltab
[relcount
].addend
= 0;
2002 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2003 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2008 save_relocs (asection
*sec
)
2012 sec
->relocation
= reltab
;
2013 sec
->reloc_count
= relcount
;
2014 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2015 for (i
= 0; i
< relcount
; i
++)
2016 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2017 sec
->orelocation
[relcount
] = 0;
2018 sec
->flags
|= SEC_RELOC
;
2020 relcount
= relsize
= 0;
2023 /* .section .idata$2
2024 .global __head_my_dll
2041 make_head (bfd
*parent
)
2043 asection
*id2
, *id5
, *id4
;
2044 unsigned char *d2
, *d5
, *d4
;
2048 oname
= xmalloc (20);
2049 sprintf (oname
, "d%06d.o", tmp_seq
);
2052 abfd
= bfd_create (oname
, parent
);
2053 bfd_find_target (pe_details
->object_target
, abfd
);
2054 bfd_make_writable (abfd
);
2056 bfd_set_format (abfd
, bfd_object
);
2057 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2060 symtab
= xmalloc (6 * sizeof (asymbol
*));
2061 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2062 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2063 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2064 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2065 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2067 /* OK, pay attention here. I got confused myself looking back at
2068 it. We create a four-byte section to mark the beginning of the
2069 list, and we include an offset of 4 in the section, so that the
2070 pointer to the list points to the *end* of this section, which is
2071 the start of the list of sections from other objects. */
2073 bfd_set_section_size (id2
, 20);
2077 if (pe_use_nul_prefixed_import_tables
)
2078 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2079 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2080 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2081 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2084 if (pe_use_nul_prefixed_import_tables
)
2085 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2087 bfd_set_section_size (id5
, 0);
2088 d5
= xmalloc (PE_IDATA5_SIZE
);
2090 memset (d5
, 0, PE_IDATA5_SIZE
);
2091 if (pe_use_nul_prefixed_import_tables
)
2092 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2094 bfd_set_section_size (id4
, 0);
2095 d4
= xmalloc (PE_IDATA4_SIZE
);
2097 memset (d4
, 0, PE_IDATA4_SIZE
);
2099 bfd_set_symtab (abfd
, symtab
, symptr
);
2101 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2102 if (pe_use_nul_prefixed_import_tables
)
2104 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2105 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2109 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2110 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2113 bfd_make_readable (abfd
);
2117 /* .section .idata$4
2124 .global __my_dll_iname
2129 make_tail (bfd
*parent
)
2131 asection
*id4
, *id5
, *id7
;
2132 unsigned char *d4
, *d5
, *d7
;
2137 oname
= xmalloc (20);
2138 sprintf (oname
, "d%06d.o", tmp_seq
);
2141 abfd
= bfd_create (oname
, parent
);
2142 bfd_find_target (pe_details
->object_target
, abfd
);
2143 bfd_make_writable (abfd
);
2145 bfd_set_format (abfd
, bfd_object
);
2146 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2149 symtab
= xmalloc (5 * sizeof (asymbol
*));
2150 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2151 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2152 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2153 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2155 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2156 d4
= xmalloc (PE_IDATA4_SIZE
);
2158 memset (d4
, 0, PE_IDATA4_SIZE
);
2160 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2161 d5
= xmalloc (PE_IDATA5_SIZE
);
2163 memset (d5
, 0, PE_IDATA5_SIZE
);
2165 len
= strlen (dll_filename
) + 1;
2168 bfd_set_section_size (id7
, len
);
2171 strcpy ((char *) d7
, dll_filename
);
2172 /* If len was odd, the above
2173 strcpy leaves behind an undefined byte. That is harmless,
2174 but we set it to 0 just so the binary dumps are pretty. */
2177 bfd_set_symtab (abfd
, symtab
, symptr
);
2179 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2180 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2181 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2183 bfd_make_readable (abfd
);
2189 .global ___imp_function
2190 .global __imp__function
2192 jmp *__imp__function:
2206 .asciz "function" xlate? (add underscore, kill at) */
2208 static const unsigned char jmp_ix86_bytes
[] =
2210 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2218 .dw __imp_function */
2220 static const unsigned char jmp_sh_bytes
[] =
2222 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2226 lui $t0,<high:__imp_function>
2227 lw $t0,<low:__imp_function>
2231 static const unsigned char jmp_mips_bytes
[] =
2233 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2234 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2237 static const unsigned char jmp_arm_bytes
[] =
2239 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2240 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2246 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2248 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2249 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2253 const unsigned char *jmp_bytes
= NULL
;
2254 int jmp_byte_count
= 0;
2256 /* Include the jump stub section only if it is needed. A jump
2257 stub is needed if the symbol being imported <sym> is a function
2258 symbol and there is at least one undefined reference to that
2259 symbol. In other words, if all the import references to <sym> are
2260 explicitly through _declspec(dllimport) then the jump stub is not
2262 if (include_jmp_stub
)
2264 switch (pe_details
->pe_arch
)
2267 jmp_bytes
= jmp_ix86_bytes
;
2268 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2271 jmp_bytes
= jmp_sh_bytes
;
2272 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2275 jmp_bytes
= jmp_mips_bytes
;
2276 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2279 case PE_ARCH_arm_wince
:
2280 jmp_bytes
= jmp_arm_bytes
;
2281 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2288 oname
= xmalloc (20);
2289 sprintf (oname
, "d%06d.o", tmp_seq
);
2292 abfd
= bfd_create (oname
, parent
);
2293 bfd_find_target (pe_details
->object_target
, abfd
);
2294 bfd_make_writable (abfd
);
2296 bfd_set_format (abfd
, bfd_object
);
2297 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2300 symtab
= xmalloc (12 * sizeof (asymbol
*));
2302 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2303 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2304 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2305 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2306 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2308 if (*exp
->internal_name
== '@')
2310 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2312 if (include_jmp_stub
)
2313 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2314 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2316 /* Fastcall applies only to functions,
2317 so no need for auto-import symbol. */
2321 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2323 if (include_jmp_stub
)
2324 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2326 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2328 /* Symbol to reference ord/name of imported
2329 data symbol, used to implement auto-import. */
2331 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2334 if (pe_dll_compat_implib
)
2335 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2338 if (include_jmp_stub
)
2340 bfd_set_section_size (tx
, jmp_byte_count
);
2341 td
= xmalloc (jmp_byte_count
);
2343 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2345 switch (pe_details
->pe_arch
)
2348 #ifdef pe_use_x86_64
2349 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2351 /* Mark this object as SAFESEH compatible. */
2352 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2354 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2358 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2361 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2362 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2363 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2366 case PE_ARCH_arm_wince
:
2367 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2375 bfd_set_section_size (tx
, 0);
2377 bfd_set_section_size (id7
, 4);
2381 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2384 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2385 d5
= xmalloc (PE_IDATA5_SIZE
);
2387 memset (d5
, 0, PE_IDATA5_SIZE
);
2389 if (exp
->flag_noname
)
2391 d5
[0] = exp
->ordinal
;
2392 d5
[1] = exp
->ordinal
>> 8;
2393 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2397 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2401 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2402 d4
= xmalloc (PE_IDATA4_SIZE
);
2404 memset (d4
, 0, PE_IDATA4_SIZE
);
2406 if (exp
->flag_noname
)
2408 d4
[0] = exp
->ordinal
;
2409 d4
[1] = exp
->ordinal
>> 8;
2410 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2414 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2418 if (exp
->flag_noname
)
2421 bfd_set_section_size (id6
, 0);
2427 /* { short, asciz } */
2429 len
= 2 + strlen (exp
->its_name
) + 1;
2431 len
= 2 + strlen (exp
->name
) + 1;
2434 bfd_set_section_size (id6
, len
);
2437 memset (d6
, 0, len
);
2439 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2440 contains an invalid value (-1). */
2441 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2446 strcpy ((char*) d6
+ 2, exp
->its_name
);
2448 strcpy ((char *) d6
+ 2, exp
->name
);
2451 bfd_set_symtab (abfd
, symtab
, symptr
);
2453 if (include_jmp_stub
)
2454 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2455 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2456 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2457 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2458 if (!exp
->flag_noname
)
2459 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2461 bfd_make_readable (abfd
);
2466 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2468 /* Name thunks go to idata$4. */
2474 oname
= xmalloc (20);
2475 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2478 abfd
= bfd_create (oname
, parent
);
2479 bfd_find_target (pe_details
->object_target
, abfd
);
2480 bfd_make_writable (abfd
);
2482 bfd_set_format (abfd
, bfd_object
);
2483 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2486 symtab
= xmalloc (3 * sizeof (asymbol
*));
2487 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2488 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2489 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2491 /* We need space for the real thunk and for the null terminator. */
2492 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2493 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2495 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2496 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2499 bfd_set_symtab (abfd
, symtab
, symptr
);
2501 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2503 bfd_make_readable (abfd
);
2508 make_import_fixup_mark (arelent
*rel
, char *name
)
2510 /* We convert reloc to symbol, for later reference. */
2511 static unsigned int counter
;
2512 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2513 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2514 struct bfd_link_hash_entry
*bh
;
2515 char *fixup_name
, buf
[26];
2518 /* "name" buffer has space before the symbol name for prefixes. */
2519 sprintf (buf
, "__fu%d_", counter
++);
2520 prefix_len
= strlen (buf
);
2521 fixup_name
= name
- prefix_len
;
2522 memcpy (fixup_name
, buf
, prefix_len
);
2525 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2526 current_sec
, /* sym->section, */
2527 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2529 return bh
->root
.string
;
2532 /* .section .idata$2
2533 .rva __nm_thnk_SYM (singleton thunk with name of func)
2536 .rva __my_dll_iname (name of dll)
2537 .rva __fuNN_SYM (pointer to reference (address) in text) */
2540 make_import_fixup_entry (const char *name
,
2541 const char *fixup_name
,
2542 const char *symname
,
2550 oname
= xmalloc (20);
2551 sprintf (oname
, "fu%06d.o", tmp_seq
);
2554 abfd
= bfd_create (oname
, parent
);
2555 bfd_find_target (pe_details
->object_target
, abfd
);
2556 bfd_make_writable (abfd
);
2558 bfd_set_format (abfd
, bfd_object
);
2559 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2562 symtab
= xmalloc (6 * sizeof (asymbol
*));
2563 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2565 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2566 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2567 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2569 bfd_set_section_size (id2
, 20);
2574 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2575 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2576 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2579 bfd_set_symtab (abfd
, symtab
, symptr
);
2581 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2583 bfd_make_readable (abfd
);
2587 /* .section .rdata_runtime_pseudo_reloc
2589 .rva __fuNN_SYM (pointer to reference (address) in text) */
2592 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2593 const char *fixup_name
,
2594 bfd_vma addend ATTRIBUTE_UNUSED
,
2599 unsigned char *rt_rel_d
;
2604 oname
= xmalloc (20);
2605 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2608 abfd
= bfd_create (oname
, parent
);
2609 bfd_find_target (pe_details
->object_target
, abfd
);
2610 bfd_make_writable (abfd
);
2612 bfd_set_format (abfd
, bfd_object
);
2613 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2615 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2617 if (runtime_pseudp_reloc_v2_init
)
2618 size
= 3 * sizeof (asymbol
*);
2620 size
= 6 * sizeof (asymbol
*);
2623 size
= 2 * sizeof (asymbol
*);
2626 symtab
= xmalloc (size
);
2629 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2631 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2633 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2636 if (!runtime_pseudp_reloc_v2_init
)
2639 runtime_pseudp_reloc_v2_init
= TRUE
;
2642 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2644 bfd_set_section_size (rt_rel
, size
);
2645 rt_rel_d
= xmalloc (size
);
2646 rt_rel
->contents
= rt_rel_d
;
2647 memset (rt_rel_d
, 0, size
);
2648 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2649 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2650 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2652 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2653 save_relocs (rt_rel
);
2655 bfd_set_symtab (abfd
, symtab
, symptr
);
2657 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2661 bfd_set_section_size (rt_rel
, 8);
2662 rt_rel_d
= xmalloc (8);
2663 rt_rel
->contents
= rt_rel_d
;
2664 memset (rt_rel_d
, 0, 8);
2666 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2667 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2669 save_relocs (rt_rel
);
2671 bfd_set_symtab (abfd
, symtab
, symptr
);
2673 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2676 bfd_make_readable (abfd
);
2681 .rva __pei386_runtime_relocator */
2684 pe_create_runtime_relocator_reference (bfd
*parent
)
2686 asection
*extern_rt_rel
;
2687 unsigned char *extern_rt_rel_d
;
2691 oname
= xmalloc (20);
2692 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2695 abfd
= bfd_create (oname
, parent
);
2696 bfd_find_target (pe_details
->object_target
, abfd
);
2697 bfd_make_writable (abfd
);
2699 bfd_set_format (abfd
, bfd_object
);
2700 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2703 symtab
= xmalloc (2 * sizeof (asymbol
*));
2704 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2706 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2709 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2710 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2711 extern_rt_rel
->contents
= extern_rt_rel_d
;
2713 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2714 save_relocs (extern_rt_rel
);
2716 bfd_set_symtab (abfd
, symtab
, symptr
);
2718 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2720 bfd_make_readable (abfd
);
2725 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2726 const char *symname
)
2728 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2731 /* This is the original implementation of the auto-import feature, which
2732 primarily relied on the OS loader to patch things up with some help
2733 from the pseudo-relocator to overcome the main limitation. See the
2734 comment at the beginning of the file for an overview of the feature. */
2735 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2737 struct bfd_link_hash_entry
*name_thunk_sym
;
2738 /* name buffer is allocated with space at beginning for prefixes. */
2739 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2740 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2741 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2743 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2745 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2746 add_bfd_to_link (b
, b
->filename
, &link_info
);
2748 /* If we ever use autoimport, we have to cast text section writable. */
2749 config
.text_read_only
= FALSE
;
2750 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2753 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2755 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2756 link_info
.output_bfd
);
2757 add_bfd_to_link (b
, b
->filename
, &link_info
);
2761 /* In the original implementation, the pseudo-relocator was only used when
2762 the addend was not null. In the new implementation, the OS loader is
2763 completely bypassed and the pseudo-relocator does the entire work. */
2764 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2765 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2767 if (pe_dll_extra_pe_debug
)
2768 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2769 fixup_name
, (int) addend
);
2771 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2772 link_info
.output_bfd
);
2773 add_bfd_to_link (b
, b
->filename
, &link_info
);
2775 if (runtime_pseudo_relocs_created
++ == 0)
2777 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2778 add_bfd_to_link (b
, b
->filename
, &link_info
);
2782 else if (addend
!= 0)
2783 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2784 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2788 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2797 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2798 dll_symname
= xstrdup (dll_filename
);
2799 for (i
= 0; dll_symname
[i
]; i
++)
2800 if (!ISALNUM (dll_symname
[i
]))
2801 dll_symname
[i
] = '_';
2803 unlink_if_ordinary (impfilename
);
2805 outarch
= bfd_openw (impfilename
, 0);
2809 /* xgettext:c-format */
2810 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2815 /* xgettext:c-format */
2816 info_msg (_("Creating library file: %s\n"), impfilename
);
2818 bfd_set_format (outarch
, bfd_archive
);
2819 outarch
->has_armap
= 1;
2821 /* Work out a reasonable size of things to put onto one line. */
2822 ar_head
= make_head (outarch
);
2824 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2825 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2827 /* Iterate the exclude list. */
2828 struct exclude_list_struct
*ex
;
2830 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2832 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2834 found
= (filename_cmp (ex
->string
, ibfd
->filename
) == 0);
2836 /* If it matched, we must open a fresh BFD for it (the original
2837 input BFD is still needed for the DLL's final link) and add
2838 it into the archive member chain. */
2841 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2842 ? ibfd
->my_archive
->filename
: ibfd
->filename
, NULL
);
2845 einfo (_("%X%P: bfd_openr %s: %E\n"), ibfd
->filename
);
2848 if (ibfd
->my_archive
)
2850 /* Must now iterate through archive until we find the
2851 required member. A minor shame that we'll open the
2852 archive once per member that we require from it, and
2853 leak those archive bfds rather than reuse them. */
2854 bfd
*arbfd
= newbfd
;
2855 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2857 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2858 ibfd
->my_archive
->filename
, ibfd
->filename
);
2862 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2864 if (filename_cmp (newbfd
->filename
, ibfd
->filename
) == 0)
2869 einfo (_("%X%P: %s(%s): can't find member in archive"),
2870 ibfd
->my_archive
->filename
, ibfd
->filename
);
2874 newbfd
->archive_next
= head
;
2879 for (i
= 0; i
< def
->num_exports
; i
++)
2881 /* The import library doesn't know about the internal name. */
2882 char *internal
= def
->exports
[i
].internal_name
;
2885 /* Don't add PRIVATE entries to import lib. */
2886 if (pe_def_file
->exports
[i
].flag_private
)
2889 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2891 /* PR 19803: If a symbol has been discard due to garbage
2892 collection then do not create any exports for it. */
2894 struct coff_link_hash_entry
*h
;
2896 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2897 FALSE
, FALSE
, FALSE
);
2899 /* If the symbol is hidden and undefined then it
2900 has been swept up by garbage collection. */
2901 && h
->symbol_class
== C_HIDDEN
2902 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2905 /* If necessary, check with an underscore prefix as well. */
2906 if (pe_details
->underscored
&& internal
[0] != '@')
2910 name
= xmalloc (strlen (internal
) + 2);
2911 sprintf (name
, "_%s", internal
);
2913 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2914 FALSE
, FALSE
, FALSE
);
2918 /* If the symbol is hidden and undefined then it
2919 has been swept up by garbage collection. */
2920 && h
->symbol_class
== C_HIDDEN
2921 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2926 n
= make_one (def
->exports
+ i
, outarch
,
2927 ! (def
->exports
+ i
)->flag_data
);
2928 n
->archive_next
= head
;
2930 def
->exports
[i
].internal_name
= internal
;
2933 ar_tail
= make_tail (outarch
);
2935 if (ar_head
== NULL
|| ar_tail
== NULL
)
2938 /* Now stick them all into the archive. */
2939 ar_head
->archive_next
= head
;
2940 ar_tail
->archive_next
= ar_head
;
2943 if (! bfd_set_archive_head (outarch
, head
))
2944 einfo ("%X%P: bfd_set_archive_head: %E\n");
2946 if (! bfd_close (outarch
))
2947 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
2949 while (head
!= NULL
)
2951 bfd
*n
= head
->archive_next
;
2957 static int undef_count
= 0;
2965 static struct key_value
*udef_table
;
2967 static int undef_sort_cmp (const void *l1
, const void *r1
)
2969 const struct key_value
*l
= l1
;
2970 const struct key_value
*r
= r1
;
2972 return strcmp (l
->key
, r
->key
);
2975 static struct bfd_link_hash_entry
*
2976 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
2978 struct bfd_link_hash_entry
*h
= NULL
;
2979 struct key_value
*kv
;
2980 struct key_value key
;
2981 char *at
, *lname
= xmalloc (strlen (name
) + 3);
2983 strcpy (lname
, name
);
2985 at
= strchr (lname
+ (lname
[0] == '@'), '@');
2990 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
2995 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
2996 if (h
->type
== bfd_link_hash_undefined
)
3000 if (lname
[0] == '?')
3003 if (at
|| lname
[0] == '@')
3005 if (lname
[0] == '@')
3007 if (pe_details
->underscored
)
3010 strcpy (lname
, lname
+ 1);
3012 kv
= bsearch (&key
, udef_table
, undef_count
,
3013 sizeof (struct key_value
), undef_sort_cmp
);
3016 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3017 if (h
->type
== bfd_link_hash_undefined
)
3022 *strchr (lname
, '@') = 0;
3024 kv
= bsearch (&key
, udef_table
, undef_count
,
3025 sizeof (struct key_value
), undef_sort_cmp
);
3028 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3029 if (h
->type
== bfd_link_hash_undefined
)
3035 strcat (lname
, "@");
3037 kv
= bsearch (&key
, udef_table
, undef_count
,
3038 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
)
3047 if (lname
[0] == '_' && pe_details
->underscored
)
3051 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3056 kv
= bsearch (&key
, udef_table
, undef_count
,
3057 sizeof (struct key_value
), undef_sort_cmp
);
3061 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3062 if (h
->type
== bfd_link_hash_undefined
)
3074 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3075 void *inf ATTRIBUTE_UNUSED
)
3077 if (h
->type
== bfd_link_hash_undefined
)
3083 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3085 if (h
->type
== bfd_link_hash_undefined
)
3089 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3090 at
= strchr (udef_table
[undef_count
].key
3091 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3094 udef_table
[undef_count
].oname
= h
->root
.string
;
3101 pe_create_undef_table (void)
3105 /* count undefined symbols */
3107 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3109 /* create and fill the corresponding table */
3110 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3113 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3116 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3120 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3122 lang_input_statement_type
*fake_file
;
3124 fake_file
= lang_add_input_file (name
,
3125 lang_input_file_is_fake_enum
,
3127 fake_file
->the_bfd
= abfd
;
3128 ldlang_add_file (fake_file
);
3130 if (!bfd_link_add_symbols (abfd
, linfo
))
3131 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3135 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3138 def_file_module
*module
;
3139 def_file_import
*imp
;
3141 pe_dll_id_target (bfd_get_target (output_bfd
));
3146 imp
= pe_def_file
->imports
;
3148 pe_create_undef_table ();
3150 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3152 int do_this_dll
= 0;
3154 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3156 if (i
>= pe_def_file
->num_imports
)
3159 dll_filename
= module
->name
;
3160 dll_symname
= xstrdup (module
->name
);
3161 for (j
= 0; dll_symname
[j
]; j
++)
3162 if (!ISALNUM (dll_symname
[j
]))
3163 dll_symname
[j
] = '_';
3165 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3167 def_file_export exp
;
3168 struct bfd_link_hash_entry
*blhe
;
3169 int lead_at
= (*imp
[i
].internal_name
== '@');
3170 /* See if we need this import. */
3171 size_t len
= strlen (imp
[i
].internal_name
);
3172 char *name
= xmalloc (len
+ 2 + 6);
3173 bfd_boolean include_jmp_stub
= FALSE
;
3174 bfd_boolean is_cdecl
= FALSE
;
3175 bfd_boolean is_undef
= FALSE
;
3177 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3181 sprintf (name
, "%s", imp
[i
].internal_name
);
3183 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3185 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3186 FALSE
, FALSE
, FALSE
);
3188 /* Include the jump stub for <sym> only if the <sym>
3190 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3193 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3195 sprintf (name
, "%s%s%s", "__imp_", U (""),
3196 imp
[i
].internal_name
);
3198 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3199 FALSE
, FALSE
, FALSE
);
3201 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3205 include_jmp_stub
= TRUE
;
3206 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3209 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3211 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3212 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3213 include_jmp_stub
= TRUE
;
3215 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3226 bfd
*ar_head
= make_head (output_bfd
);
3227 add_bfd_to_link (ar_head
, ar_head
->filename
, linfo
);
3230 exp
.internal_name
= imp
[i
].internal_name
;
3231 exp
.name
= imp
[i
].name
;
3232 exp
.its_name
= imp
[i
].its_name
;
3233 exp
.ordinal
= imp
[i
].ordinal
;
3234 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3235 exp
.flag_private
= 0;
3236 exp
.flag_constant
= 0;
3237 exp
.flag_data
= imp
[i
].data
;
3238 exp
.flag_noname
= exp
.name
? 0 : 1;
3239 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3240 add_bfd_to_link (one
, one
->filename
, linfo
);
3245 bfd
*ar_tail
= make_tail (output_bfd
);
3246 add_bfd_to_link (ar_tail
, ar_tail
->filename
, linfo
);
3255 free (udef_table
[undef_count
].key
);
3260 /* We were handed a *.DLL file. Parse it and turn it into a set of
3261 IMPORTS directives in the def file. Return TRUE if the file was
3262 handled, FALSE if not. */
3265 pe_get16 (bfd
*abfd
, int where
)
3269 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3270 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3271 return b
[0] + (b
[1] << 8);
3275 pe_get32 (bfd
*abfd
, int where
)
3279 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3280 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3281 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
3287 unsigned char *b
= ptr
;
3289 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
3293 pe_implied_import_dll (const char *filename
)
3296 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3297 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3298 bfd_vma exp_funcbase
;
3299 unsigned char *expdata
;
3301 bfd_vma name_rvas
, nexp
;
3302 const char *dllname
;
3303 /* Initialization with start > end guarantees that is_data
3304 will not be set by mistake, and avoids compiler warning. */
3305 bfd_vma data_start
= 1;
3306 bfd_vma data_end
= 0;
3307 bfd_vma rdata_start
= 1;
3308 bfd_vma rdata_end
= 0;
3309 bfd_vma bss_start
= 1;
3310 bfd_vma bss_end
= 0;
3313 /* No, I can't use bfd here. kernel32.dll puts its export table in
3314 the middle of the .rdata section. */
3315 dll
= bfd_openr (filename
, pe_details
->target_name
);
3318 einfo (_("%X%P: open %s: %E\n"), filename
);
3322 /* PEI dlls seem to be bfd_objects. */
3323 if (!bfd_check_format (dll
, bfd_object
))
3325 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3329 /* Get pe_header, optional header and numbers of directory entries. */
3330 pe_header_offset
= pe_get32 (dll
, 0x3c);
3331 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3332 #ifdef pe_use_x86_64
3333 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3335 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3338 /* No import or export directory entry. */
3339 if (num_entries
< 1)
3342 #ifdef pe_use_x86_64
3343 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3344 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3346 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3347 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3350 /* No export table - nothing to export. */
3351 if (export_size
== 0)
3354 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3355 secptr
= (pe_header_offset
+ 4 + 20 +
3356 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3359 /* Get the rva and size of the export section. */
3360 for (i
= 0; i
< nsections
; i
++)
3363 bfd_vma secptr1
= secptr
+ 40 * i
;
3364 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3365 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3366 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3368 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3369 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3371 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3373 expptr
= fptr
+ (export_rva
- vaddr
);
3374 if (export_rva
+ export_size
> vaddr
+ vsize
)
3375 export_size
= vsize
- (export_rva
- vaddr
);
3380 /* Scan sections and store the base and size of the
3381 data and bss segments in data/base_start/end. */
3382 for (i
= 0; i
< nsections
; i
++)
3384 bfd_vma secptr1
= secptr
+ 40 * i
;
3385 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3386 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3387 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3391 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3392 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3394 if (strcmp(sec_name
,".data") == 0)
3397 data_end
= vaddr
+ vsize
;
3399 if (pe_dll_extra_pe_debug
)
3400 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3401 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3402 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3404 else if (strcmp(sec_name
,".rdata") == 0)
3406 rdata_start
= vaddr
;
3407 rdata_end
= vaddr
+ vsize
;
3409 if (pe_dll_extra_pe_debug
)
3410 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3411 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3412 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3414 else if (strcmp (sec_name
,".bss") == 0)
3417 bss_end
= vaddr
+ vsize
;
3419 if (pe_dll_extra_pe_debug
)
3420 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3421 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3422 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3426 expdata
= xmalloc (export_size
);
3427 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3428 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3429 erva
= (char *) expdata
- export_rva
;
3431 if (pe_def_file
== 0)
3432 pe_def_file
= def_file_empty ();
3434 nexp
= pe_as32 (expdata
+ 24);
3435 name_rvas
= pe_as32 (expdata
+ 32);
3436 exp_funcbase
= pe_as32 (expdata
+ 28);
3438 /* Use internal dll name instead of filename
3439 to enable symbolic dll linking. */
3440 dllname
= erva
+ pe_as32 (expdata
+ 12);
3442 /* Check to see if the dll has already been added to
3443 the definition list and if so return without error.
3444 This avoids multiple symbol definitions. */
3445 if (def_get_module (pe_def_file
, dllname
))
3447 if (pe_dll_extra_pe_debug
)
3448 printf ("%s is already loaded\n", dllname
);
3452 /* This is an optimized version of the insertion loop, which avoids lots of
3453 calls to realloc and memmove from def_file_add_import. */
3454 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3455 erva
+ pe_as32 (erva
+ name_rvas
),
3456 dllname
, 0, NULL
, NULL
)) >= 0)
3458 for (i
= 0; i
< nexp
; i
++)
3460 /* Pointer to the names vector. */
3461 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3462 def_file_import
*imp
;
3463 /* Pointer to the function address vector. */
3464 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3465 /* is_data is true if the address is in the data, rdata or bss
3468 (func_rva
>= data_start
&& func_rva
< data_end
)
3469 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3470 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3472 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3473 dllname
, i
, NULL
, NULL
);
3474 /* Mark symbol type. */
3475 imp
->data
= is_data
;
3477 if (pe_dll_extra_pe_debug
)
3478 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3479 __FUNCTION__
, dllname
, erva
+ name_rva
,
3480 (unsigned long) func_rva
, is_data
? "(data)" : "");
3486 /* Iterate through the list of symbols. */
3487 for (i
= 0; i
< nexp
; i
++)
3489 /* Pointer to the names vector. */
3490 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3491 def_file_import
*imp
;
3492 /* Pointer to the function address vector. */
3493 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3496 /* Skip unwanted symbols, which are
3497 exported in buggy auto-import releases. */
3498 if (! CONST_STRNEQ (erva
+ name_rva
, "__nm_"))
3501 /* is_data is true if the address is in the data, rdata or bss
3504 (func_rva
>= data_start
&& func_rva
< data_end
)
3505 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3506 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3508 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3509 dllname
, i
, NULL
, NULL
, &is_dup
);
3510 /* Mark symbol type. */
3512 imp
->data
= is_data
;
3514 if (pe_dll_extra_pe_debug
)
3515 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3516 __FUNCTION__
, dllname
, erva
+ name_rva
,
3517 (unsigned long) func_rva
, is_data
? "(data)" : "");
3525 pe_output_file_set_long_section_names (bfd
*abfd
)
3527 if (pe_use_coff_long_section_names
< 0)
3529 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3530 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3533 /* These are the main functions, called from the emulation. The first
3534 is called after the bfds are read, so we can guess at how much space
3535 we need. The second is called after everything is placed, so we
3536 can put the right values in place. */
3539 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3541 pe_dll_id_target (bfd_get_target (abfd
));
3542 pe_output_file_set_long_section_names (abfd
);
3543 process_def_file_and_drectve (abfd
, info
);
3545 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3548 generate_edata (abfd
, info
);
3549 build_filler_bfd (1);
3550 pe_output_file_set_long_section_names (filler_bfd
);
3554 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3556 pe_dll_id_target (bfd_get_target (abfd
));
3557 pe_output_file_set_long_section_names (abfd
);
3558 build_filler_bfd (0);
3559 pe_output_file_set_long_section_names (filler_bfd
);
3563 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3565 pe_dll_id_target (bfd_get_target (abfd
));
3566 pe_output_file_set_long_section_names (abfd
);
3567 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3569 generate_reloc (abfd
, info
);
3572 bfd_set_section_size (reloc_s
, reloc_sz
);
3574 /* Resize the sections. */
3575 lang_reset_memory_regions ();
3576 lang_size_sections (NULL
, TRUE
);
3578 /* Redo special stuff. */
3579 ldemul_after_allocation ();
3581 /* Do the assignments again. */
3582 lang_do_assignments (lang_final_phase_enum
);
3585 fill_edata (abfd
, info
);
3587 if (bfd_link_dll (info
))
3588 pe_data (abfd
)->dll
= 1;
3590 edata_s
->contents
= edata_d
;
3591 reloc_s
->contents
= reloc_d
;
3595 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3597 pe_dll_id_target (bfd_get_target (abfd
));
3598 pe_output_file_set_long_section_names (abfd
);
3599 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3601 generate_reloc (abfd
, info
);
3604 bfd_set_section_size (reloc_s
, reloc_sz
);
3606 /* Resize the sections. */
3607 lang_reset_memory_regions ();
3608 lang_size_sections (NULL
, TRUE
);
3610 /* Redo special stuff. */
3611 ldemul_after_allocation ();
3613 /* Do the assignments again. */
3614 lang_do_assignments (lang_final_phase_enum
);
3616 reloc_s
->contents
= reloc_d
;
3620 pe_bfd_is_dll (bfd
*abfd
)
3622 return (bfd_get_format (abfd
) == bfd_object
3624 && pe_data (abfd
)->dll
);