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 (filler_bfd
, edata_s
,
1024 einfo (_("%X%P: can not create .edata section: %E\n"));
1027 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
1030 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1032 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
1039 einfo (_("%X%P: can not create .reloc section: %E\n"));
1043 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
1045 ldlang_add_file (filler_file
);
1048 /* Gather all the exported symbols and build the .edata section. */
1051 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1053 int i
, next_ordinal
;
1054 int name_table_size
= 0;
1057 /* First, we need to know how many exported symbols there are,
1058 and what the range of ordinals is. */
1059 if (pe_def_file
->name
)
1060 dll_name
= pe_def_file
->name
;
1063 dll_name
= abfd
->filename
;
1065 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1066 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1067 dll_name
= dlnp
+ 1;
1070 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1072 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1073 min_ordinal
= max_ordinal
- count_exported
+ 1;
1078 max_ordinal
= count_exported
;
1081 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1082 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1083 for (i
= 0; i
< export_table_size
; i
++)
1084 exported_symbols
[i
] = -1;
1086 /* Now we need to assign ordinals to those that don't have them. */
1087 for (i
= 0; i
< NE
; i
++)
1089 if (exported_symbol_sections
[i
]
1090 || pe_def_file
->exports
[i
].flag_forward
)
1092 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1094 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1095 int pi
= exported_symbols
[ei
];
1099 /* xgettext:c-format */
1100 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1101 pe_def_file
->exports
[i
].ordinal
,
1102 pe_def_file
->exports
[i
].name
,
1103 pe_def_file
->exports
[pi
].name
);
1105 exported_symbols
[ei
] = i
;
1107 if (pe_def_file
->exports
[i
].its_name
)
1108 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1110 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1113 /* Reserve space for the forward name. */
1114 if (pe_def_file
->exports
[i
].flag_forward
)
1116 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1120 next_ordinal
= min_ordinal
;
1121 for (i
= 0; i
< NE
; i
++)
1122 if ((exported_symbol_sections
[i
]
1123 || pe_def_file
->exports
[i
].flag_forward
)
1124 && pe_def_file
->exports
[i
].ordinal
== -1)
1126 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1129 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1130 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1133 /* PR 12969: Check for more than 1^16 ordinals. */
1134 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1135 /* xgettext:c-format */
1136 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1137 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1139 /* OK, now we can allocate some memory. */
1140 edata_sz
= (40 /* directory */
1141 + 4 * export_table_size
/* addresses */
1142 + 4 * count_exported_byname
/* name ptrs */
1143 + 2 * count_exported_byname
/* ordinals */
1144 + name_table_size
+ strlen (dll_name
) + 1);
1147 /* Fill the exported symbol offsets. The preliminary work has already
1148 been done in process_def_file_and_drectve(). */
1151 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1154 struct bfd_link_hash_entry
*blhe
;
1156 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1160 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1161 if (pe_details
->underscored
1162 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1165 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1168 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1170 blhe
= bfd_link_hash_lookup (info
->hash
,
1172 FALSE
, FALSE
, TRUE
);
1174 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1175 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1182 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1185 unsigned char *edirectory
;
1186 unsigned char *eaddresses
;
1187 unsigned char *enameptrs
;
1188 unsigned char *eordinals
;
1191 edata_d
= xmalloc (edata_sz
);
1193 /* Note use of array pointer math here. */
1194 edirectory
= edata_d
;
1195 eaddresses
= edirectory
+ 40;
1196 enameptrs
= eaddresses
+ 4 * export_table_size
;
1197 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1198 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1200 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1201 + edata_s->output_section->vma - image_base)
1203 memset (edata_d
, 0, edata_sz
);
1205 if (pe_data (abfd
)->insert_timestamp
)
1206 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1208 if (pe_def_file
->version_major
!= -1)
1210 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1211 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1214 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1215 strcpy (enamestr
, dll_name
);
1216 enamestr
+= strlen (enamestr
) + 1;
1217 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1218 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1219 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1220 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1221 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1222 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1224 fill_exported_offsets (abfd
, info
);
1226 /* Ok, now for the filling in part.
1227 Scan alphabetically - ie the ordering in the exports[] table,
1228 rather than by ordinal - the ordering in the exported_symbol[]
1229 table. See dlltool.c and:
1230 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1231 for more information. */
1233 for (s
= 0; s
< NE
; s
++)
1235 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1236 if (pe_def_file
->exports
[s
].ordinal
!= -1
1237 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1239 int ord
= pe_def_file
->exports
[s
].ordinal
;
1241 if (pe_def_file
->exports
[s
].flag_forward
)
1243 bfd_put_32 (abfd
, ERVA (enamestr
),
1244 eaddresses
+ 4 * (ord
- min_ordinal
));
1246 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1247 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1251 bfd_vma srva
= (exported_symbol_offsets
[s
]
1252 + ssec
->output_section
->vma
1253 + ssec
->output_offset
);
1255 bfd_put_32 (abfd
, srva
- image_base
,
1256 eaddresses
+ 4 * (ord
- min_ordinal
));
1259 if (!pe_def_file
->exports
[s
].flag_noname
)
1261 char *ename
= pe_def_file
->exports
[s
].name
;
1262 if (pe_def_file
->exports
[s
].its_name
)
1263 ename
= pe_def_file
->exports
[s
].its_name
;
1265 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1267 strcpy (enamestr
, ename
);
1268 enamestr
+= strlen (enamestr
) + 1;
1269 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1271 pe_def_file
->exports
[s
].hint
= hint
++;
1278 static struct bfd_section
*current_sec
;
1281 pe_walk_relocs (struct bfd_link_info
*info
,
1283 const char *symname
,
1284 struct bfd_hash_table
*import_hash
,
1285 void (*cb
) (arelent
*, asection
*, char *, const char *))
1290 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1294 if (!bfd_generic_link_read_symbols (b
))
1296 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1300 symbols
= bfd_get_outsymbols (b
);
1302 for (s
= b
->sections
; s
; s
= s
->next
)
1305 int relsize
, nrelocs
, i
;
1306 int flags
= bfd_get_section_flags (b
, s
);
1308 /* Skip discarded linkonce sections. */
1309 if (flags
& SEC_LINK_ONCE
1310 && s
->output_section
== bfd_abs_section_ptr
)
1315 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1316 relocs
= xmalloc (relsize
);
1317 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1319 for (i
= 0; i
< nrelocs
; i
++)
1321 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1323 /* Warning: the callback needs to be passed NAME directly. */
1326 if (bfd_hash_lookup (import_hash
, sym
->name
, FALSE
, FALSE
))
1328 strcpy (name
, sym
->name
);
1329 cb (relocs
[i
], s
, name
, symname
);
1334 if (strcmp (name
, sym
->name
) == 0)
1335 cb (relocs
[i
], s
, name
, symname
);
1341 /* Warning: the allocated symbols are remembered in BFD and reused
1342 later, so don't free them! */
1343 /* free (symbols); */
1349 pe_find_data_imports (const char *symhead
,
1350 void (*cb
) (arelent
*, asection
*, char *, const char *))
1352 struct bfd_link_hash_entry
*undef
;
1353 const size_t headlen
= strlen (symhead
);
1356 struct bfd_hash_table
*import_hash
;
1358 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1359 if (undef
->type
== bfd_link_hash_undefined
)
1361 size_t len
= strlen (undef
->root
.string
);
1368 /* For the pseudo-relocation support version 2, we can collect the symbols
1369 that are subject to auto-import and adjust the relocations en masse. */
1370 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1373 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1374 if (!bfd_hash_table_init (import_hash
,
1376 sizeof (struct bfd_hash_entry
)))
1377 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1382 /* We are being a bit cunning here. The buffer will have space for
1383 prefixes at the beginning. The prefix is modified here and in a
1384 number of functions called from this function. */
1385 #define PREFIX_LEN 32
1386 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1387 name
= buf
+ PREFIX_LEN
;
1389 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1390 if (undef
->type
== bfd_link_hash_undefined
)
1392 struct bfd_link_hash_entry
*sym
;
1395 if (pe_dll_extra_pe_debug
)
1396 printf ("%s:%s\n", __FUNCTION__
, undef
->root
.string
);
1398 strcpy (name
, undef
->root
.string
);
1399 impname
= name
- (sizeof "__imp_" - 1);
1400 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1402 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1404 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1407 bfd_hash_lookup (import_hash
, undef
->root
.string
, TRUE
, FALSE
);
1410 bfd
*b
= sym
->u
.def
.section
->owner
;
1411 const char *symname
= NULL
;
1415 if (!bfd_generic_link_read_symbols (b
))
1417 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1421 symbols
= bfd_get_outsymbols (b
);
1422 nsyms
= bfd_get_symcount (b
);
1424 for (i
= 0; i
< nsyms
; i
++)
1425 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1427 if (pe_dll_extra_pe_debug
)
1428 printf ("->%s\n", symbols
[i
]->name
);
1430 symname
= symbols
[i
]->name
+ headlen
;
1434 /* If the symobl isn't part of an import table, there is no
1435 point in building a fixup, this would give rise to link
1436 errors for mangled symbols instead of the original one. */
1438 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1443 /* Let's differentiate it somehow from defined. */
1444 undef
->type
= bfd_link_hash_defweak
;
1445 undef
->u
.def
.value
= sym
->u
.def
.value
;
1446 undef
->u
.def
.section
= sym
->u
.def
.section
;
1448 /* We replace the original name with the __imp_ prefixed one, this
1449 1) may trash memory 2) leads to duplicate symbols. But this is
1450 better than having a misleading name that can confuse GDB. */
1451 undef
->root
.string
= sym
->root
.string
;
1453 if (link_info
.pei386_auto_import
== -1)
1455 static bfd_boolean warned
= FALSE
;
1457 info_msg (_("Info: resolving %s by linking to %s "
1458 "(auto-import)\n"), name
, impname
);
1460 /* PR linker/4844. */
1463 einfo (_("%P: warning: auto-importing has been activated "
1464 "without --enable-auto-import specified on the "
1465 "command line; this should work unless it "
1466 "involves constant data structures referencing "
1467 "symbols from auto-imported DLLs\n"));
1474 /* If we have the import hash table, walk the relocations only once. */
1477 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1478 bfd_hash_table_free (import_hash
);
1485 /* Gather all the relocations and build the .reloc section. */
1488 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1491 /* For .reloc stuff. */
1492 reloc_data_type
*reloc_data
;
1493 int total_relocs
= 0;
1495 bfd_vma sec_page
= (bfd_vma
) -1;
1496 bfd_vma page_ptr
, page_count
;
1499 struct bfd_section
*s
;
1502 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1503 for (s
= b
->sections
; s
; s
= s
->next
)
1504 total_relocs
+= s
->reloc_count
;
1506 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1510 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1513 int relsize
, nrelocs
;
1515 for (s
= b
->sections
; s
; s
= s
->next
)
1517 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1520 /* If it's not loaded, we don't need to relocate it this way. */
1521 if (!(s
->output_section
->flags
& SEC_LOAD
))
1524 /* I don't know why there would be a reloc for these, but I've
1525 seen it happen - DJ */
1526 if (s
->output_section
== bfd_abs_section_ptr
)
1529 if (s
->output_section
->vma
== 0)
1531 /* Huh? Shouldn't happen, but punt if it does. */
1532 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1533 s
->output_section
->name
, s
->output_section
->index
,
1534 s
->output_section
->flags
);
1538 if (!bfd_generic_link_read_symbols (b
))
1540 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1544 symbols
= bfd_get_outsymbols (b
);
1545 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1546 relocs
= xmalloc (relsize
);
1547 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1549 for (i
= 0; i
< nrelocs
; i
++)
1551 if (pe_dll_extra_pe_debug
)
1553 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1554 printf ("rel: %s\n", sym
->name
);
1556 if (!relocs
[i
]->howto
->pc_relative
1557 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1559 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1561 /* Don't create relocs for undefined weak symbols. */
1562 if (sym
->flags
== BSF_WEAK
)
1564 struct bfd_link_hash_entry
*blhe
1565 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1566 FALSE
, FALSE
, FALSE
);
1567 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1569 /* Check aux sym and see if it is defined or not. */
1570 struct coff_link_hash_entry
*h
, *h2
;
1571 h
= (struct coff_link_hash_entry
*)blhe
;
1572 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1574 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1575 [h
->aux
->x_sym
.x_tagndx
.l
];
1576 /* We don't want a base reloc if the aux sym is not
1577 found, undefined, or if it is the constant ABS
1578 zero default value. (We broaden that slightly by
1579 not testing the value, just the section; there's
1580 no reason we'd want a reference to any absolute
1581 address to get relocated during rebasing). */
1582 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1583 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1586 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1589 /* Nor for Dwarf FDE references to discarded sections. */
1590 else if (bfd_is_abs_section (sym
->section
->output_section
))
1592 /* We only ignore relocs from .eh_frame sections, as
1593 they are discarded by the final link rather than
1594 resolved against the kept section. */
1595 if (!strcmp (s
->name
, ".eh_frame"))
1599 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1601 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1603 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1604 relocs
[i
]->howto
->rightshift
)
1606 #ifdef pe_use_x86_64
1607 case BITS_AND_SHIFT (64, 0):
1608 reloc_data
[total_relocs
].type
= 10;
1612 case BITS_AND_SHIFT (32, 0):
1613 reloc_data
[total_relocs
].type
= 3;
1616 case BITS_AND_SHIFT (16, 0):
1617 reloc_data
[total_relocs
].type
= 2;
1620 case BITS_AND_SHIFT (16, 16):
1621 reloc_data
[total_relocs
].type
= 4;
1622 /* FIXME: we can't know the symbol's right value
1623 yet, but we probably can safely assume that
1624 CE will relocate us in 64k blocks, so leaving
1626 reloc_data
[total_relocs
].extra
= 0;
1629 case BITS_AND_SHIFT (26, 2):
1630 reloc_data
[total_relocs
].type
= 5;
1633 case BITS_AND_SHIFT (24, 2):
1634 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1635 Those ARM_xxx definitions should go in proper
1637 if (relocs
[i
]->howto
->type
== 0
1638 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1639 || relocs
[i
]->howto
->type
== 5)
1640 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1641 that has already been fully processed during a
1642 previous link stage, so ignore it here. */
1646 /* xgettext:c-format */
1647 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1648 relocs
[i
]->howto
->bitsize
);
1654 /* Warning: the allocated symbols are remembered in BFD and
1655 reused later, so don't free them! */
1659 /* At this point, we have total_relocs relocation addresses in
1660 reloc_addresses, which are all suitable for the .reloc section.
1661 We must now create the new sections. */
1662 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1664 for (i
= 0; i
< total_relocs
; i
++)
1666 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1668 if (this_page
!= sec_page
)
1670 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1672 sec_page
= this_page
;
1677 if (reloc_data
[i
].type
== 4)
1681 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1682 reloc_d
= xmalloc (reloc_sz
);
1683 sec_page
= (bfd_vma
) -1;
1685 page_ptr
= (bfd_vma
) -1;
1688 for (i
= 0; i
< total_relocs
; i
++)
1690 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1691 bfd_vma this_page
= (rva
& ~0xfff);
1693 if (this_page
!= sec_page
)
1695 while (reloc_sz
& 3)
1696 reloc_d
[reloc_sz
++] = 0;
1698 if (page_ptr
!= (bfd_vma
) -1)
1699 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1701 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1702 page_ptr
= reloc_sz
;
1704 sec_page
= this_page
;
1708 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1709 reloc_d
+ reloc_sz
);
1712 if (reloc_data
[i
].type
== 4)
1714 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1721 while (reloc_sz
& 3)
1722 reloc_d
[reloc_sz
++] = 0;
1724 if (page_ptr
!= (bfd_vma
) -1)
1725 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1727 while (reloc_sz
< reloc_s
->size
)
1728 reloc_d
[reloc_sz
++] = 0;
1731 /* Given the exiting def_file structure, print out a .DEF file that
1732 corresponds to it. */
1735 quoteput (char *s
, FILE *f
, int needs_quotes
)
1739 for (cp
= s
; *cp
; cp
++)
1754 if (*s
== '"' || *s
== '\\')
1768 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1771 FILE *out
= fopen (pe_out_def_filename
, "w");
1774 /* xgettext:c-format */
1775 einfo (_("%P: can't open output def file %s\n"),
1776 pe_out_def_filename
);
1780 if (pe_def_file
->name
)
1782 if (pe_def_file
->is_dll
)
1783 fprintf (out
, "LIBRARY ");
1785 fprintf (out
, "NAME ");
1787 quoteput (pe_def_file
->name
, out
, 1);
1789 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1791 fprintf (out
, " BASE=0x");
1792 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1794 fprintf (out
, "\n");
1797 if (pe_def_file
->description
)
1799 fprintf (out
, "DESCRIPTION ");
1800 quoteput (pe_def_file
->description
, out
, 1);
1801 fprintf (out
, "\n");
1804 if (pe_def_file
->version_minor
!= -1)
1805 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1806 pe_def_file
->version_minor
);
1807 else if (pe_def_file
->version_major
!= -1)
1808 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1810 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1811 fprintf (out
, "\n");
1813 if (pe_def_file
->stack_commit
!= -1)
1814 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1815 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1816 else if (pe_def_file
->stack_reserve
!= -1)
1817 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1819 if (pe_def_file
->heap_commit
!= -1)
1820 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1821 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1822 else if (pe_def_file
->heap_reserve
!= -1)
1823 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1825 if (pe_def_file
->num_section_defs
> 0)
1827 fprintf (out
, "\nSECTIONS\n\n");
1829 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1832 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1834 if (pe_def_file
->section_defs
[i
].class)
1836 fprintf (out
, " CLASS ");
1837 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1840 if (pe_def_file
->section_defs
[i
].flag_read
)
1841 fprintf (out
, " READ");
1843 if (pe_def_file
->section_defs
[i
].flag_write
)
1844 fprintf (out
, " WRITE");
1846 if (pe_def_file
->section_defs
[i
].flag_execute
)
1847 fprintf (out
, " EXECUTE");
1849 if (pe_def_file
->section_defs
[i
].flag_shared
)
1850 fprintf (out
, " SHARED");
1852 fprintf (out
, "\n");
1856 if (pe_def_file
->num_exports
> 0)
1858 fprintf (out
, "EXPORTS\n");
1860 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1862 def_file_export
*e
= pe_def_file
->exports
+ i
;
1864 quoteput (e
->name
, out
, 0);
1866 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1868 fprintf (out
, " = ");
1869 quoteput (e
->internal_name
, out
, 0);
1872 if (e
->ordinal
!= -1)
1873 fprintf (out
, " @%d", e
->ordinal
);
1875 if (e
->flag_private
)
1876 fprintf (out
, " PRIVATE");
1878 if (e
->flag_constant
)
1879 fprintf (out
, " CONSTANT");
1882 fprintf (out
, " NONAME");
1885 fprintf (out
, " DATA");
1887 fprintf (out
, "\n");
1891 if (pe_def_file
->num_imports
> 0)
1893 fprintf (out
, "\nIMPORTS\n\n");
1895 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1897 def_file_import
*im
= pe_def_file
->imports
+ i
;
1900 if (im
->internal_name
1901 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1903 quoteput (im
->internal_name
, out
, 0);
1904 fprintf (out
, " = ");
1907 quoteput (im
->module
->name
, out
, 0);
1911 quoteput (im
->name
, out
, 0);
1913 fprintf (out
, "%d", im
->ordinal
);
1917 fprintf (out
, " == ");
1918 quoteput (im
->its_name
, out
, 0);
1921 fprintf (out
, "\n");
1926 fprintf (out
, _("; no contents available\n"));
1928 if (fclose (out
) == EOF
)
1929 /* xgettext:c-format */
1930 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1933 /* Generate the import library. */
1935 static asymbol
**symtab
;
1938 static const char *dll_filename
;
1939 static char *dll_symname
;
1941 #define UNDSEC bfd_und_section_ptr
1944 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1949 sec
= bfd_make_section_old_way (abfd
, name
);
1950 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1951 bfd_set_section_alignment (abfd
, sec
, align
);
1952 /* Remember to undo this before trying to link internally! */
1953 sec
->output_section
= sec
;
1955 sym
= bfd_make_empty_symbol (abfd
);
1956 symtab
[symptr
++] = sym
;
1957 sym
->name
= sec
->name
;
1959 sym
->flags
= BSF_LOCAL
;
1966 quick_symbol (bfd
*abfd
,
1975 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1980 sym
= bfd_make_empty_symbol (abfd
);
1985 symtab
[symptr
++] = sym
;
1988 static arelent
*reltab
= 0;
1989 static int relcount
= 0, relsize
= 0;
1992 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1994 if (relcount
>= relsize
- 1)
1998 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2000 reltab
= xmalloc (relsize
* sizeof (arelent
));
2002 reltab
[relcount
].address
= address
;
2003 reltab
[relcount
].addend
= 0;
2004 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2005 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2010 save_relocs (asection
*sec
)
2014 sec
->relocation
= reltab
;
2015 sec
->reloc_count
= relcount
;
2016 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2017 for (i
= 0; i
< relcount
; i
++)
2018 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2019 sec
->orelocation
[relcount
] = 0;
2020 sec
->flags
|= SEC_RELOC
;
2022 relcount
= relsize
= 0;
2025 /* .section .idata$2
2026 .global __head_my_dll
2043 make_head (bfd
*parent
)
2045 asection
*id2
, *id5
, *id4
;
2046 unsigned char *d2
, *d5
, *d4
;
2050 oname
= xmalloc (20);
2051 sprintf (oname
, "d%06d.o", tmp_seq
);
2054 abfd
= bfd_create (oname
, parent
);
2055 bfd_find_target (pe_details
->object_target
, abfd
);
2056 bfd_make_writable (abfd
);
2058 bfd_set_format (abfd
, bfd_object
);
2059 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2062 symtab
= xmalloc (6 * sizeof (asymbol
*));
2063 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2064 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2065 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2066 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2067 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2069 /* OK, pay attention here. I got confused myself looking back at
2070 it. We create a four-byte section to mark the beginning of the
2071 list, and we include an offset of 4 in the section, so that the
2072 pointer to the list points to the *end* of this section, which is
2073 the start of the list of sections from other objects. */
2075 bfd_set_section_size (abfd
, id2
, 20);
2079 if (pe_use_nul_prefixed_import_tables
)
2080 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2081 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2082 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2083 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2086 if (pe_use_nul_prefixed_import_tables
)
2087 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2089 bfd_set_section_size (abfd
, id5
, 0);
2090 d5
= xmalloc (PE_IDATA5_SIZE
);
2092 memset (d5
, 0, PE_IDATA5_SIZE
);
2093 if (pe_use_nul_prefixed_import_tables
)
2094 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2096 bfd_set_section_size (abfd
, id4
, 0);
2097 d4
= xmalloc (PE_IDATA4_SIZE
);
2099 memset (d4
, 0, PE_IDATA4_SIZE
);
2101 bfd_set_symtab (abfd
, symtab
, symptr
);
2103 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2104 if (pe_use_nul_prefixed_import_tables
)
2106 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2107 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2111 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2112 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2115 bfd_make_readable (abfd
);
2119 /* .section .idata$4
2126 .global __my_dll_iname
2131 make_tail (bfd
*parent
)
2133 asection
*id4
, *id5
, *id7
;
2134 unsigned char *d4
, *d5
, *d7
;
2139 oname
= xmalloc (20);
2140 sprintf (oname
, "d%06d.o", tmp_seq
);
2143 abfd
= bfd_create (oname
, parent
);
2144 bfd_find_target (pe_details
->object_target
, abfd
);
2145 bfd_make_writable (abfd
);
2147 bfd_set_format (abfd
, bfd_object
);
2148 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2151 symtab
= xmalloc (5 * sizeof (asymbol
*));
2152 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2153 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2154 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2155 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2157 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2158 d4
= xmalloc (PE_IDATA4_SIZE
);
2160 memset (d4
, 0, PE_IDATA4_SIZE
);
2162 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2163 d5
= xmalloc (PE_IDATA5_SIZE
);
2165 memset (d5
, 0, PE_IDATA5_SIZE
);
2167 len
= strlen (dll_filename
) + 1;
2170 bfd_set_section_size (abfd
, id7
, len
);
2173 strcpy ((char *) d7
, dll_filename
);
2174 /* If len was odd, the above
2175 strcpy leaves behind an undefined byte. That is harmless,
2176 but we set it to 0 just so the binary dumps are pretty. */
2179 bfd_set_symtab (abfd
, symtab
, symptr
);
2181 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2182 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2183 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2185 bfd_make_readable (abfd
);
2191 .global ___imp_function
2192 .global __imp__function
2194 jmp *__imp__function:
2208 .asciz "function" xlate? (add underscore, kill at) */
2210 static const unsigned char jmp_ix86_bytes
[] =
2212 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2220 .dw __imp_function */
2222 static const unsigned char jmp_sh_bytes
[] =
2224 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2228 lui $t0,<high:__imp_function>
2229 lw $t0,<low:__imp_function>
2233 static const unsigned char jmp_mips_bytes
[] =
2235 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2236 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2239 static const unsigned char jmp_arm_bytes
[] =
2241 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2242 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2248 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2250 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2251 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2255 const unsigned char *jmp_bytes
= NULL
;
2256 int jmp_byte_count
= 0;
2258 /* Include the jump stub section only if it is needed. A jump
2259 stub is needed if the symbol being imported <sym> is a function
2260 symbol and there is at least one undefined reference to that
2261 symbol. In other words, if all the import references to <sym> are
2262 explicitly through _declspec(dllimport) then the jump stub is not
2264 if (include_jmp_stub
)
2266 switch (pe_details
->pe_arch
)
2269 jmp_bytes
= jmp_ix86_bytes
;
2270 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2273 jmp_bytes
= jmp_sh_bytes
;
2274 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2277 jmp_bytes
= jmp_mips_bytes
;
2278 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2281 case PE_ARCH_arm_wince
:
2282 jmp_bytes
= jmp_arm_bytes
;
2283 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2290 oname
= xmalloc (20);
2291 sprintf (oname
, "d%06d.o", tmp_seq
);
2294 abfd
= bfd_create (oname
, parent
);
2295 bfd_find_target (pe_details
->object_target
, abfd
);
2296 bfd_make_writable (abfd
);
2298 bfd_set_format (abfd
, bfd_object
);
2299 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2302 symtab
= xmalloc (12 * sizeof (asymbol
*));
2304 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2305 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2306 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2307 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2308 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2310 if (*exp
->internal_name
== '@')
2312 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2314 if (include_jmp_stub
)
2315 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2316 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2318 /* Fastcall applies only to functions,
2319 so no need for auto-import symbol. */
2323 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2325 if (include_jmp_stub
)
2326 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2328 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2330 /* Symbol to reference ord/name of imported
2331 data symbol, used to implement auto-import. */
2333 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2336 if (pe_dll_compat_implib
)
2337 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2340 if (include_jmp_stub
)
2342 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
2343 td
= xmalloc (jmp_byte_count
);
2345 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2347 switch (pe_details
->pe_arch
)
2350 #ifdef pe_use_x86_64
2351 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2353 /* Mark this object as SAFESEH compatible. */
2354 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2356 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2360 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2363 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2364 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2365 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2368 case PE_ARCH_arm_wince
:
2369 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2377 bfd_set_section_size (abfd
, tx
, 0);
2379 bfd_set_section_size (abfd
, id7
, 4);
2383 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2386 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2387 d5
= xmalloc (PE_IDATA5_SIZE
);
2389 memset (d5
, 0, PE_IDATA5_SIZE
);
2391 if (exp
->flag_noname
)
2393 d5
[0] = exp
->ordinal
;
2394 d5
[1] = exp
->ordinal
>> 8;
2395 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2399 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2403 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2404 d4
= xmalloc (PE_IDATA4_SIZE
);
2406 memset (d4
, 0, PE_IDATA4_SIZE
);
2408 if (exp
->flag_noname
)
2410 d4
[0] = exp
->ordinal
;
2411 d4
[1] = exp
->ordinal
>> 8;
2412 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2416 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2420 if (exp
->flag_noname
)
2423 bfd_set_section_size (abfd
, id6
, 0);
2429 /* { short, asciz } */
2431 len
= 2 + strlen (exp
->its_name
) + 1;
2433 len
= 2 + strlen (exp
->name
) + 1;
2436 bfd_set_section_size (abfd
, id6
, len
);
2439 memset (d6
, 0, len
);
2441 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2442 contains an invalid value (-1). */
2443 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2448 strcpy ((char*) d6
+ 2, exp
->its_name
);
2450 strcpy ((char *) d6
+ 2, exp
->name
);
2453 bfd_set_symtab (abfd
, symtab
, symptr
);
2455 if (include_jmp_stub
)
2456 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2457 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2458 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2459 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2460 if (!exp
->flag_noname
)
2461 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2463 bfd_make_readable (abfd
);
2468 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2470 /* Name thunks go to idata$4. */
2476 oname
= xmalloc (20);
2477 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2480 abfd
= bfd_create (oname
, parent
);
2481 bfd_find_target (pe_details
->object_target
, abfd
);
2482 bfd_make_writable (abfd
);
2484 bfd_set_format (abfd
, bfd_object
);
2485 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2488 symtab
= xmalloc (3 * sizeof (asymbol
*));
2489 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2490 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2491 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2493 /* We need space for the real thunk and for the null terminator. */
2494 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2495 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2497 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2498 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2501 bfd_set_symtab (abfd
, symtab
, symptr
);
2503 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2505 bfd_make_readable (abfd
);
2510 make_import_fixup_mark (arelent
*rel
, char *name
)
2512 /* We convert reloc to symbol, for later reference. */
2513 static unsigned int counter
;
2514 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2515 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2516 struct bfd_link_hash_entry
*bh
;
2517 char *fixup_name
, buf
[26];
2520 /* "name" buffer has space before the symbol name for prefixes. */
2521 sprintf (buf
, "__fu%d_", counter
++);
2522 prefix_len
= strlen (buf
);
2523 fixup_name
= name
- prefix_len
;
2524 memcpy (fixup_name
, buf
, prefix_len
);
2527 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2528 current_sec
, /* sym->section, */
2529 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2531 return bh
->root
.string
;
2534 /* .section .idata$2
2535 .rva __nm_thnk_SYM (singleton thunk with name of func)
2538 .rva __my_dll_iname (name of dll)
2539 .rva __fuNN_SYM (pointer to reference (address) in text) */
2542 make_import_fixup_entry (const char *name
,
2543 const char *fixup_name
,
2544 const char *symname
,
2552 oname
= xmalloc (20);
2553 sprintf (oname
, "fu%06d.o", tmp_seq
);
2556 abfd
= bfd_create (oname
, parent
);
2557 bfd_find_target (pe_details
->object_target
, abfd
);
2558 bfd_make_writable (abfd
);
2560 bfd_set_format (abfd
, bfd_object
);
2561 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2564 symtab
= xmalloc (6 * sizeof (asymbol
*));
2565 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2567 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2568 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2569 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2571 bfd_set_section_size (abfd
, id2
, 20);
2576 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2577 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2578 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2581 bfd_set_symtab (abfd
, symtab
, symptr
);
2583 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2585 bfd_make_readable (abfd
);
2589 /* .section .rdata_runtime_pseudo_reloc
2591 .rva __fuNN_SYM (pointer to reference (address) in text) */
2594 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2595 const char *fixup_name
,
2596 bfd_vma addend ATTRIBUTE_UNUSED
,
2601 unsigned char *rt_rel_d
;
2606 oname
= xmalloc (20);
2607 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2610 abfd
= bfd_create (oname
, parent
);
2611 bfd_find_target (pe_details
->object_target
, abfd
);
2612 bfd_make_writable (abfd
);
2614 bfd_set_format (abfd
, bfd_object
);
2615 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2617 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2619 if (runtime_pseudp_reloc_v2_init
)
2620 size
= 3 * sizeof (asymbol
*);
2622 size
= 6 * sizeof (asymbol
*);
2625 size
= 2 * sizeof (asymbol
*);
2628 symtab
= xmalloc (size
);
2631 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2633 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2635 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2638 if (!runtime_pseudp_reloc_v2_init
)
2641 runtime_pseudp_reloc_v2_init
= TRUE
;
2644 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2646 bfd_set_section_size (abfd
, rt_rel
, size
);
2647 rt_rel_d
= xmalloc (size
);
2648 rt_rel
->contents
= rt_rel_d
;
2649 memset (rt_rel_d
, 0, size
);
2650 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2651 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2652 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2654 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2655 save_relocs (rt_rel
);
2657 bfd_set_symtab (abfd
, symtab
, symptr
);
2659 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2663 bfd_set_section_size (abfd
, rt_rel
, 8);
2664 rt_rel_d
= xmalloc (8);
2665 rt_rel
->contents
= rt_rel_d
;
2666 memset (rt_rel_d
, 0, 8);
2668 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2669 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2671 save_relocs (rt_rel
);
2673 bfd_set_symtab (abfd
, symtab
, symptr
);
2675 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2678 bfd_make_readable (abfd
);
2683 .rva __pei386_runtime_relocator */
2686 pe_create_runtime_relocator_reference (bfd
*parent
)
2688 asection
*extern_rt_rel
;
2689 unsigned char *extern_rt_rel_d
;
2693 oname
= xmalloc (20);
2694 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2697 abfd
= bfd_create (oname
, parent
);
2698 bfd_find_target (pe_details
->object_target
, abfd
);
2699 bfd_make_writable (abfd
);
2701 bfd_set_format (abfd
, bfd_object
);
2702 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2705 symtab
= xmalloc (2 * sizeof (asymbol
*));
2706 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2708 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2711 bfd_set_section_size (abfd
, extern_rt_rel
, PE_IDATA5_SIZE
);
2712 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2713 extern_rt_rel
->contents
= extern_rt_rel_d
;
2715 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2716 save_relocs (extern_rt_rel
);
2718 bfd_set_symtab (abfd
, symtab
, symptr
);
2720 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2722 bfd_make_readable (abfd
);
2727 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2728 const char *symname
)
2730 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2733 /* This is the original implementation of the auto-import feature, which
2734 primarily relied on the OS loader to patch things up with some help
2735 from the pseudo-relocator to overcome the main limitation. See the
2736 comment at the beginning of the file for an overview of the feature. */
2737 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2739 struct bfd_link_hash_entry
*name_thunk_sym
;
2740 /* name buffer is allocated with space at beginning for prefixes. */
2741 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2742 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2743 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2745 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2747 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2748 add_bfd_to_link (b
, b
->filename
, &link_info
);
2750 /* If we ever use autoimport, we have to cast text section writable. */
2751 config
.text_read_only
= FALSE
;
2752 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2755 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2757 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2758 link_info
.output_bfd
);
2759 add_bfd_to_link (b
, b
->filename
, &link_info
);
2763 /* In the original implementation, the pseudo-relocator was only used when
2764 the addend was not null. In the new implementation, the OS loader is
2765 completely bypassed and the pseudo-relocator does the entire work. */
2766 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2767 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2769 if (pe_dll_extra_pe_debug
)
2770 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2771 fixup_name
, (int) addend
);
2773 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2774 link_info
.output_bfd
);
2775 add_bfd_to_link (b
, b
->filename
, &link_info
);
2777 if (runtime_pseudo_relocs_created
++ == 0)
2779 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2780 add_bfd_to_link (b
, b
->filename
, &link_info
);
2784 else if (addend
!= 0)
2785 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2786 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2790 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2799 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2800 dll_symname
= xstrdup (dll_filename
);
2801 for (i
= 0; dll_symname
[i
]; i
++)
2802 if (!ISALNUM (dll_symname
[i
]))
2803 dll_symname
[i
] = '_';
2805 unlink_if_ordinary (impfilename
);
2807 outarch
= bfd_openw (impfilename
, 0);
2811 /* xgettext:c-format */
2812 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2817 /* xgettext:c-format */
2818 info_msg (_("Creating library file: %s\n"), impfilename
);
2820 bfd_set_format (outarch
, bfd_archive
);
2821 outarch
->has_armap
= 1;
2823 /* Work out a reasonable size of things to put onto one line. */
2824 ar_head
= make_head (outarch
);
2826 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2827 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2829 /* Iterate the exclude list. */
2830 struct exclude_list_struct
*ex
;
2832 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2834 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2836 found
= (filename_cmp (ex
->string
, ibfd
->filename
) == 0);
2838 /* If it matched, we must open a fresh BFD for it (the original
2839 input BFD is still needed for the DLL's final link) and add
2840 it into the archive member chain. */
2843 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2844 ? ibfd
->my_archive
->filename
: ibfd
->filename
, NULL
);
2847 einfo (_("%X%P: bfd_openr %s: %E\n"), ibfd
->filename
);
2850 if (ibfd
->my_archive
)
2852 /* Must now iterate through archive until we find the
2853 required member. A minor shame that we'll open the
2854 archive once per member that we require from it, and
2855 leak those archive bfds rather than reuse them. */
2856 bfd
*arbfd
= newbfd
;
2857 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2859 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2860 ibfd
->my_archive
->filename
, ibfd
->filename
);
2864 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2866 if (filename_cmp (newbfd
->filename
, ibfd
->filename
) == 0)
2871 einfo (_("%X%P: %s(%s): can't find member in archive"),
2872 ibfd
->my_archive
->filename
, ibfd
->filename
);
2876 newbfd
->archive_next
= head
;
2881 for (i
= 0; i
< def
->num_exports
; i
++)
2883 /* The import library doesn't know about the internal name. */
2884 char *internal
= def
->exports
[i
].internal_name
;
2887 /* Don't add PRIVATE entries to import lib. */
2888 if (pe_def_file
->exports
[i
].flag_private
)
2891 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2893 /* PR 19803: If a symbol has been discard due to garbage
2894 collection then do not create any exports for it. */
2896 struct coff_link_hash_entry
*h
;
2898 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2899 FALSE
, FALSE
, FALSE
);
2901 /* If the symbol is hidden and undefined then it
2902 has been swept up by garbage collection. */
2903 && h
->symbol_class
== C_HIDDEN
2904 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2907 /* If necessary, check with an underscore prefix as well. */
2908 if (pe_details
->underscored
&& internal
[0] != '@')
2912 name
= xmalloc (strlen (internal
) + 2);
2913 sprintf (name
, "_%s", internal
);
2915 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2916 FALSE
, FALSE
, FALSE
);
2920 /* If the symbol is hidden and undefined then it
2921 has been swept up by garbage collection. */
2922 && h
->symbol_class
== C_HIDDEN
2923 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2928 n
= make_one (def
->exports
+ i
, outarch
,
2929 ! (def
->exports
+ i
)->flag_data
);
2930 n
->archive_next
= head
;
2932 def
->exports
[i
].internal_name
= internal
;
2935 ar_tail
= make_tail (outarch
);
2937 if (ar_head
== NULL
|| ar_tail
== NULL
)
2940 /* Now stick them all into the archive. */
2941 ar_head
->archive_next
= head
;
2942 ar_tail
->archive_next
= ar_head
;
2945 if (! bfd_set_archive_head (outarch
, head
))
2946 einfo ("%X%P: bfd_set_archive_head: %E\n");
2948 if (! bfd_close (outarch
))
2949 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
2951 while (head
!= NULL
)
2953 bfd
*n
= head
->archive_next
;
2959 static int undef_count
= 0;
2967 static struct key_value
*udef_table
;
2969 static int undef_sort_cmp (const void *l1
, const void *r1
)
2971 const struct key_value
*l
= l1
;
2972 const struct key_value
*r
= r1
;
2974 return strcmp (l
->key
, r
->key
);
2977 static struct bfd_link_hash_entry
*
2978 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
2980 struct bfd_link_hash_entry
*h
= NULL
;
2981 struct key_value
*kv
;
2982 struct key_value key
;
2983 char *at
, *lname
= xmalloc (strlen (name
) + 3);
2985 strcpy (lname
, name
);
2987 at
= strchr (lname
+ (lname
[0] == '@'), '@');
2992 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
2997 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
2998 if (h
->type
== bfd_link_hash_undefined
)
3002 if (lname
[0] == '?')
3005 if (at
|| lname
[0] == '@')
3007 if (lname
[0] == '@')
3009 if (pe_details
->underscored
)
3012 strcpy (lname
, lname
+ 1);
3014 kv
= bsearch (&key
, udef_table
, undef_count
,
3015 sizeof (struct key_value
), undef_sort_cmp
);
3018 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3019 if (h
->type
== bfd_link_hash_undefined
)
3024 *strchr (lname
, '@') = 0;
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
)
3037 strcat (lname
, "@");
3039 kv
= bsearch (&key
, udef_table
, undef_count
,
3040 sizeof (struct key_value
), undef_sort_cmp
);
3044 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3045 if (h
->type
== bfd_link_hash_undefined
)
3049 if (lname
[0] == '_' && pe_details
->underscored
)
3053 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3058 kv
= bsearch (&key
, udef_table
, undef_count
,
3059 sizeof (struct key_value
), undef_sort_cmp
);
3063 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3064 if (h
->type
== bfd_link_hash_undefined
)
3076 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3077 void *inf ATTRIBUTE_UNUSED
)
3079 if (h
->type
== bfd_link_hash_undefined
)
3085 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3087 if (h
->type
== bfd_link_hash_undefined
)
3091 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3092 at
= strchr (udef_table
[undef_count
].key
3093 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3096 udef_table
[undef_count
].oname
= h
->root
.string
;
3103 pe_create_undef_table (void)
3107 /* count undefined symbols */
3109 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3111 /* create and fill the corresponding table */
3112 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3115 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3118 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3122 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3124 lang_input_statement_type
*fake_file
;
3126 fake_file
= lang_add_input_file (name
,
3127 lang_input_file_is_fake_enum
,
3129 fake_file
->the_bfd
= abfd
;
3130 ldlang_add_file (fake_file
);
3132 if (!bfd_link_add_symbols (abfd
, linfo
))
3133 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3137 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3140 def_file_module
*module
;
3141 def_file_import
*imp
;
3143 pe_dll_id_target (bfd_get_target (output_bfd
));
3148 imp
= pe_def_file
->imports
;
3150 pe_create_undef_table ();
3152 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3154 int do_this_dll
= 0;
3156 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3158 if (i
>= pe_def_file
->num_imports
)
3161 dll_filename
= module
->name
;
3162 dll_symname
= xstrdup (module
->name
);
3163 for (j
= 0; dll_symname
[j
]; j
++)
3164 if (!ISALNUM (dll_symname
[j
]))
3165 dll_symname
[j
] = '_';
3167 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3169 def_file_export exp
;
3170 struct bfd_link_hash_entry
*blhe
;
3171 int lead_at
= (*imp
[i
].internal_name
== '@');
3172 /* See if we need this import. */
3173 size_t len
= strlen (imp
[i
].internal_name
);
3174 char *name
= xmalloc (len
+ 2 + 6);
3175 bfd_boolean include_jmp_stub
= FALSE
;
3176 bfd_boolean is_cdecl
= FALSE
;
3177 bfd_boolean is_undef
= FALSE
;
3179 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3183 sprintf (name
, "%s", imp
[i
].internal_name
);
3185 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3187 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3188 FALSE
, FALSE
, FALSE
);
3190 /* Include the jump stub for <sym> only if the <sym>
3192 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3195 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3197 sprintf (name
, "%s%s%s", "__imp_", U (""),
3198 imp
[i
].internal_name
);
3200 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3201 FALSE
, FALSE
, FALSE
);
3203 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3207 include_jmp_stub
= TRUE
;
3208 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3211 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3213 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3214 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3215 include_jmp_stub
= TRUE
;
3217 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3228 bfd
*ar_head
= make_head (output_bfd
);
3229 add_bfd_to_link (ar_head
, ar_head
->filename
, linfo
);
3232 exp
.internal_name
= imp
[i
].internal_name
;
3233 exp
.name
= imp
[i
].name
;
3234 exp
.its_name
= imp
[i
].its_name
;
3235 exp
.ordinal
= imp
[i
].ordinal
;
3236 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3237 exp
.flag_private
= 0;
3238 exp
.flag_constant
= 0;
3239 exp
.flag_data
= imp
[i
].data
;
3240 exp
.flag_noname
= exp
.name
? 0 : 1;
3241 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3242 add_bfd_to_link (one
, one
->filename
, linfo
);
3247 bfd
*ar_tail
= make_tail (output_bfd
);
3248 add_bfd_to_link (ar_tail
, ar_tail
->filename
, linfo
);
3257 free (udef_table
[undef_count
].key
);
3262 /* We were handed a *.DLL file. Parse it and turn it into a set of
3263 IMPORTS directives in the def file. Return TRUE if the file was
3264 handled, FALSE if not. */
3267 pe_get16 (bfd
*abfd
, int where
)
3271 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3272 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3273 return b
[0] + (b
[1] << 8);
3277 pe_get32 (bfd
*abfd
, int where
)
3281 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3282 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3283 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
3289 unsigned char *b
= ptr
;
3291 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
3295 pe_implied_import_dll (const char *filename
)
3298 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3299 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3300 bfd_vma exp_funcbase
;
3301 unsigned char *expdata
;
3303 bfd_vma name_rvas
, nexp
;
3304 const char *dllname
;
3305 /* Initialization with start > end guarantees that is_data
3306 will not be set by mistake, and avoids compiler warning. */
3307 bfd_vma data_start
= 1;
3308 bfd_vma data_end
= 0;
3309 bfd_vma rdata_start
= 1;
3310 bfd_vma rdata_end
= 0;
3311 bfd_vma bss_start
= 1;
3312 bfd_vma bss_end
= 0;
3315 /* No, I can't use bfd here. kernel32.dll puts its export table in
3316 the middle of the .rdata section. */
3317 dll
= bfd_openr (filename
, pe_details
->target_name
);
3320 einfo (_("%X%P: open %s: %E\n"), filename
);
3324 /* PEI dlls seem to be bfd_objects. */
3325 if (!bfd_check_format (dll
, bfd_object
))
3327 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3331 /* Get pe_header, optional header and numbers of directory entries. */
3332 pe_header_offset
= pe_get32 (dll
, 0x3c);
3333 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3334 #ifdef pe_use_x86_64
3335 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3337 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3340 /* No import or export directory entry. */
3341 if (num_entries
< 1)
3344 #ifdef pe_use_x86_64
3345 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3346 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3348 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3349 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3352 /* No export table - nothing to export. */
3353 if (export_size
== 0)
3356 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3357 secptr
= (pe_header_offset
+ 4 + 20 +
3358 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3361 /* Get the rva and size of the export section. */
3362 for (i
= 0; i
< nsections
; i
++)
3365 bfd_vma secptr1
= secptr
+ 40 * i
;
3366 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3367 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3368 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3370 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3371 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3373 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3375 expptr
= fptr
+ (export_rva
- vaddr
);
3376 if (export_rva
+ export_size
> vaddr
+ vsize
)
3377 export_size
= vsize
- (export_rva
- vaddr
);
3382 /* Scan sections and store the base and size of the
3383 data and bss segments in data/base_start/end. */
3384 for (i
= 0; i
< nsections
; i
++)
3386 bfd_vma secptr1
= secptr
+ 40 * i
;
3387 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3388 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3389 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3393 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3394 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3396 if (strcmp(sec_name
,".data") == 0)
3399 data_end
= vaddr
+ vsize
;
3401 if (pe_dll_extra_pe_debug
)
3402 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3403 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3404 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3406 else if (strcmp(sec_name
,".rdata") == 0)
3408 rdata_start
= vaddr
;
3409 rdata_end
= vaddr
+ vsize
;
3411 if (pe_dll_extra_pe_debug
)
3412 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3413 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3414 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3416 else if (strcmp (sec_name
,".bss") == 0)
3419 bss_end
= vaddr
+ vsize
;
3421 if (pe_dll_extra_pe_debug
)
3422 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3423 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3424 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3428 expdata
= xmalloc (export_size
);
3429 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3430 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3431 erva
= (char *) expdata
- export_rva
;
3433 if (pe_def_file
== 0)
3434 pe_def_file
= def_file_empty ();
3436 nexp
= pe_as32 (expdata
+ 24);
3437 name_rvas
= pe_as32 (expdata
+ 32);
3438 exp_funcbase
= pe_as32 (expdata
+ 28);
3440 /* Use internal dll name instead of filename
3441 to enable symbolic dll linking. */
3442 dllname
= erva
+ pe_as32 (expdata
+ 12);
3444 /* Check to see if the dll has already been added to
3445 the definition list and if so return without error.
3446 This avoids multiple symbol definitions. */
3447 if (def_get_module (pe_def_file
, dllname
))
3449 if (pe_dll_extra_pe_debug
)
3450 printf ("%s is already loaded\n", dllname
);
3454 /* This is an optimized version of the insertion loop, which avoids lots of
3455 calls to realloc and memmove from def_file_add_import. */
3456 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3457 erva
+ pe_as32 (erva
+ name_rvas
),
3458 dllname
, 0, NULL
, NULL
)) >= 0)
3460 for (i
= 0; i
< nexp
; i
++)
3462 /* Pointer to the names vector. */
3463 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3464 def_file_import
*imp
;
3465 /* Pointer to the function address vector. */
3466 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3467 /* is_data is true if the address is in the data, rdata or bss
3470 (func_rva
>= data_start
&& func_rva
< data_end
)
3471 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3472 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3474 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3475 dllname
, i
, NULL
, NULL
);
3476 /* Mark symbol type. */
3477 imp
->data
= is_data
;
3479 if (pe_dll_extra_pe_debug
)
3480 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3481 __FUNCTION__
, dllname
, erva
+ name_rva
,
3482 (unsigned long) func_rva
, is_data
? "(data)" : "");
3488 /* Iterate through the list of symbols. */
3489 for (i
= 0; i
< nexp
; i
++)
3491 /* Pointer to the names vector. */
3492 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3493 def_file_import
*imp
;
3494 /* Pointer to the function address vector. */
3495 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3498 /* Skip unwanted symbols, which are
3499 exported in buggy auto-import releases. */
3500 if (! CONST_STRNEQ (erva
+ name_rva
, "__nm_"))
3503 /* is_data is true if the address is in the data, rdata or bss
3506 (func_rva
>= data_start
&& func_rva
< data_end
)
3507 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3508 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3510 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3511 dllname
, i
, NULL
, NULL
, &is_dup
);
3512 /* Mark symbol type. */
3514 imp
->data
= is_data
;
3516 if (pe_dll_extra_pe_debug
)
3517 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3518 __FUNCTION__
, dllname
, erva
+ name_rva
,
3519 (unsigned long) func_rva
, is_data
? "(data)" : "");
3527 pe_output_file_set_long_section_names (bfd
*abfd
)
3529 if (pe_use_coff_long_section_names
< 0)
3531 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3532 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3535 /* These are the main functions, called from the emulation. The first
3536 is called after the bfds are read, so we can guess at how much space
3537 we need. The second is called after everything is placed, so we
3538 can put the right values in place. */
3541 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3543 pe_dll_id_target (bfd_get_target (abfd
));
3544 pe_output_file_set_long_section_names (abfd
);
3545 process_def_file_and_drectve (abfd
, info
);
3547 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3550 generate_edata (abfd
, info
);
3551 build_filler_bfd (1);
3552 pe_output_file_set_long_section_names (filler_bfd
);
3556 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3558 pe_dll_id_target (bfd_get_target (abfd
));
3559 pe_output_file_set_long_section_names (abfd
);
3560 build_filler_bfd (0);
3561 pe_output_file_set_long_section_names (filler_bfd
);
3565 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3567 pe_dll_id_target (bfd_get_target (abfd
));
3568 pe_output_file_set_long_section_names (abfd
);
3569 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3571 generate_reloc (abfd
, info
);
3574 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3576 /* Resize the sections. */
3577 lang_reset_memory_regions ();
3578 lang_size_sections (NULL
, TRUE
);
3580 /* Redo special stuff. */
3581 ldemul_after_allocation ();
3583 /* Do the assignments again. */
3584 lang_do_assignments (lang_final_phase_enum
);
3587 fill_edata (abfd
, info
);
3589 if (bfd_link_dll (info
))
3590 pe_data (abfd
)->dll
= 1;
3592 edata_s
->contents
= edata_d
;
3593 reloc_s
->contents
= reloc_d
;
3597 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3599 pe_dll_id_target (bfd_get_target (abfd
));
3600 pe_output_file_set_long_section_names (abfd
);
3601 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3603 generate_reloc (abfd
, info
);
3606 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3608 /* Resize the sections. */
3609 lang_reset_memory_regions ();
3610 lang_size_sections (NULL
, TRUE
);
3612 /* Redo special stuff. */
3613 ldemul_after_allocation ();
3615 /* Do the assignments again. */
3616 lang_do_assignments (lang_final_phase_enum
);
3618 reloc_s
->contents
= reloc_d
;
3622 pe_bfd_is_dll (bfd
*abfd
)
3624 return (bfd_get_format (abfd
) == bfd_object
3626 && pe_data (abfd
)->dll
);