1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2021 Free Software Foundation, Inc.
3 Written by DJ Delorie <dj@cygnus.com>
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
25 #include "libiberty.h"
26 #include "filenames.h"
27 #include "safe-ctype.h"
41 #include "coff/internal.h"
42 #include "../bfd/libcoff.h"
47 #define PE_IDATA4_SIZE 8
48 #define PE_IDATA5_SIZE 8
51 #define AOUTSZ PEPAOUTSZ
52 #define PEAOUTHDR PEPAOUTHDR
60 #ifndef PE_IDATA4_SIZE
61 #define PE_IDATA4_SIZE 4
64 #ifndef PE_IDATA5_SIZE
65 #define PE_IDATA5_SIZE 4
68 /* This file turns a regular Windows PE image into a DLL. Because of
69 the complexity of this operation, it has been broken down into a
70 number of separate modules which are all called by the main function
71 at the end of this file. This function is not re-entrant and is
72 normally only called once, so static variables are used to reduce
73 the number of parameters and return values required.
75 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
77 /* Auto-import feature by Paul Sokolovsky
81 1. With this feature on, DLL clients can import variables from DLL
82 without any concern from their side (for example, without any source
85 2. This is done completely in bounds of the PE specification (to be fair,
86 there's a place where it pokes nose out of, but in practice it works).
87 So, resulting module can be used with any other PE compiler/linker.
89 3. Auto-import is fully compatible with standard import method and they
90 can be mixed together.
92 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
93 reference to it; load time: negligible; virtual/physical memory: should be
94 less than effect of DLL relocation, and I sincerely hope it doesn't affect
95 DLL sharability (too much).
99 The obvious and only way to get rid of dllimport insanity is to make client
100 access variable directly in the DLL, bypassing extra dereference. I.e.,
101 whenever client contains something like
105 address of dll_var in the command should be relocated to point into loaded
106 DLL. The aim is to make OS loader do so, and than make ld help with that.
107 Import section of PE made following way: there's a vector of structures
108 each describing imports from particular DLL. Each such structure points
109 to two other parallel vectors: one holding imported names, and one which
110 will hold address of corresponding imported name. So, the solution is
111 de-vectorize these structures, making import locations be sparse and
112 pointing directly into code. Before continuing, it is worth a note that,
113 while authors strives to make PE act ELF-like, there're some other people
114 make ELF act PE-like: elfvector, ;-) .
118 For each reference of data symbol to be imported from DLL (to set of which
119 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
120 import fixup entry is generated. That entry is of type
121 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
122 fixup entry contains pointer to symbol's address within .text section
123 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
124 (so, DLL name is referenced by multiple entries), and pointer to symbol
125 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
126 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
127 containing imported name. Here comes that "on the edge" problem mentioned
128 above: PE specification rambles that name vector (OriginalFirstThunk)
129 should run in parallel with addresses vector (FirstThunk), i.e. that they
130 should have same number of elements and terminated with zero. We violate
131 this, since FirstThunk points directly into machine code. But in practice,
132 OS loader implemented the sane way: it goes through OriginalFirstThunk and
133 puts addresses to FirstThunk, not something else. It once again should be
134 noted that dll and symbol name structures are reused across fixup entries
135 and should be there anyway to support standard import stuff, so sustained
136 overhead is 20 bytes per reference. Other question is whether having several
137 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
138 done even by native compiler/linker (libth32's functions are in fact reside
139 in windows9x kernel32.dll, so if you use it, you have two
140 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
141 referencing the same PE structures several times is valid. The answer is why
142 not, prohibiting that (detecting violation) would require more work on
143 behalf of loader than not doing it.
145 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
147 static void add_bfd_to_link (bfd
*, const char *, struct bfd_link_info
*);
149 /* For emultempl/pe.em. */
151 def_file
* pe_def_file
= 0;
152 int pe_dll_export_everything
= 0;
153 int pe_dll_exclude_all_symbols
= 0;
154 int pe_dll_do_default_excludes
= 1;
155 int pe_dll_kill_ats
= 0;
156 int pe_dll_stdcall_aliases
= 0;
157 int pe_dll_warn_dup_exports
= 0;
158 int pe_dll_compat_implib
= 0;
159 int pe_dll_extra_pe_debug
= 0;
160 int pe_use_nul_prefixed_import_tables
= 0;
161 int pe_use_coff_long_section_names
= -1;
162 int pe_leading_underscore
= -1;
163 int pe_dll_enable_reloc_section
= 1;
165 /* Static variables and types. */
167 static bfd_vma image_base
;
168 static bfd
*filler_bfd
;
169 static struct bfd_section
*edata_s
, *reloc_s
;
170 static unsigned char *edata_d
, *reloc_d
;
171 static size_t edata_sz
, reloc_sz
;
172 static int runtime_pseudo_relocs_created
= 0;
173 static bool runtime_pseudp_reloc_v2_init
= false;
180 autofilter_entry_type
;
184 const char *target_name
;
185 const char *object_target
;
186 unsigned int imagebase_reloc
;
190 const autofilter_entry_type
* autofilter_symbollist
;
194 static const autofilter_entry_type autofilter_symbollist_generic
[] =
196 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
197 /* Entry point symbols. */
198 { STRING_COMMA_LEN ("DllMain") },
199 { STRING_COMMA_LEN ("DllMainCRTStartup") },
200 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
201 /* Runtime pseudo-reloc. */
202 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
203 { STRING_COMMA_LEN ("do_pseudo_reloc") },
207 static const autofilter_entry_type autofilter_symbollist_i386
[] =
209 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
210 /* Entry point symbols, and entry hooks. */
211 { STRING_COMMA_LEN ("cygwin_crt0") },
213 { STRING_COMMA_LEN ("DllMain") },
214 { STRING_COMMA_LEN ("DllEntryPoint") },
215 { STRING_COMMA_LEN ("DllMainCRTStartup") },
216 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
217 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
218 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
220 { STRING_COMMA_LEN ("DllMain@12") },
221 { STRING_COMMA_LEN ("DllEntryPoint@0") },
222 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
223 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
224 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
225 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
226 { STRING_COMMA_LEN ("cygwin_attach_dll") },
228 { STRING_COMMA_LEN ("cygwin_premain0") },
229 { STRING_COMMA_LEN ("cygwin_premain1") },
230 { STRING_COMMA_LEN ("cygwin_premain2") },
231 { STRING_COMMA_LEN ("cygwin_premain3") },
232 /* Runtime pseudo-reloc. */
233 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
234 { STRING_COMMA_LEN ("do_pseudo_reloc") },
235 /* Global vars that should not be exported. */
236 { STRING_COMMA_LEN ("impure_ptr") },
237 { STRING_COMMA_LEN ("_impure_ptr") },
238 { STRING_COMMA_LEN ("_fmode") },
239 { STRING_COMMA_LEN ("environ") },
240 { STRING_COMMA_LEN ("__dso_handle") },
244 #define PE_ARCH_i386 1
246 #define PE_ARCH_mips 3
247 #define PE_ARCH_arm 4
248 #define PE_ARCH_arm_wince 5
250 /* Don't make it constant as underscore mode gets possibly overriden
251 by target or -(no-)leading-underscore option. */
252 static pe_details_type pe_detail_list
[] =
271 autofilter_symbollist_i386
281 autofilter_symbollist_i386
291 autofilter_symbollist_i386
297 16 /* R_SH_IMAGEBASE */,
301 autofilter_symbollist_generic
310 autofilter_symbollist_generic
319 autofilter_symbollist_generic
322 "pei-arm-wince-little",
323 "pe-arm-wince-little",
324 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
328 autofilter_symbollist_generic
330 { NULL
, NULL
, 0, 0, 0, false, NULL
}
333 static const pe_details_type
*pe_details
;
335 /* Do not specify library suffix explicitly, to allow for dllized versions. */
336 static const autofilter_entry_type autofilter_liblist
[] =
338 { STRING_COMMA_LEN ("libcegcc") },
339 { STRING_COMMA_LEN ("libcygwin") },
340 { STRING_COMMA_LEN ("libgcc") },
341 { STRING_COMMA_LEN ("libgcc_s") },
342 { STRING_COMMA_LEN ("libstdc++") },
343 { STRING_COMMA_LEN ("libmingw32") },
344 { STRING_COMMA_LEN ("libmingwex") },
345 { STRING_COMMA_LEN ("libg2c") },
346 { STRING_COMMA_LEN ("libsupc++") },
347 { STRING_COMMA_LEN ("libobjc") },
348 { STRING_COMMA_LEN ("libgcj") },
349 { STRING_COMMA_LEN ("libmsvcrt") },
350 { STRING_COMMA_LEN ("libmsvcrt-os") },
351 { STRING_COMMA_LEN ("libucrtbase") },
355 /* Regardless of the suffix issue mentioned above, we must ensure that
356 we do not falsely match on a leading substring, such as when libtool
357 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
358 This routine ensures that the leading part of the name matches and that
359 it is followed by only an optional version suffix and a file extension,
360 returning zero if so or -1 if not. */
361 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
363 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
366 libname
+= afptr
->len
;
368 /* Be liberal in interpreting what counts as a version suffix; we
369 accept anything that has a dash to separate it from the name and
370 begins with a digit. */
371 if (libname
[0] == '-')
373 if (!ISDIGIT (*++libname
))
375 /* Ensure the filename has an extension. */
376 while (*++libname
!= '.')
380 else if (libname
[0] != '.')
386 static const autofilter_entry_type autofilter_objlist
[] =
388 { STRING_COMMA_LEN ("crt0.o") },
389 { STRING_COMMA_LEN ("crt1.o") },
390 { STRING_COMMA_LEN ("crt2.o") },
391 { STRING_COMMA_LEN ("dllcrt1.o") },
392 { STRING_COMMA_LEN ("dllcrt2.o") },
393 { STRING_COMMA_LEN ("gcrt0.o") },
394 { STRING_COMMA_LEN ("gcrt1.o") },
395 { STRING_COMMA_LEN ("gcrt2.o") },
396 { STRING_COMMA_LEN ("crtbegin.o") },
397 { STRING_COMMA_LEN ("crtend.o") },
401 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
403 /* _imp_ is treated specially, as it is always underscored. */
404 /* { STRING_COMMA_LEN ("_imp_") }, */
405 /* Don't export some c++ symbols. */
406 { STRING_COMMA_LEN ("__rtti_") },
407 { STRING_COMMA_LEN ("__builtin_") },
408 /* Don't re-export auto-imported symbols. */
409 { STRING_COMMA_LEN ("__nm_") },
410 /* Don't export symbols specifying internal DLL layout. */
411 { STRING_COMMA_LEN ("_head_") },
412 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
413 /* Don't export section labels or artificial symbols
415 { STRING_COMMA_LEN (".") },
419 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
421 { STRING_COMMA_LEN ("_iname") },
422 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
426 #define U(str) (pe_details->underscored ? "_" str : str)
429 pe_dll_id_target (const char *target
)
433 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
434 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
435 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
437 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
439 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
442 pe_detail_list
[i
].underscored
= u
!= 0;
443 pe_details
= pe_detail_list
+ i
;
444 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
447 einfo (_("%X%P: unsupported PEI architecture: %s\n"), target
);
451 /* Helper functions for qsort. Relocs must be sorted so that we can write
452 them out by pages. */
464 reloc_sort (const void *va
, const void *vb
)
466 const reloc_data_type
*a
= (const reloc_data_type
*) va
;
467 const reloc_data_type
*b
= (const reloc_data_type
*) vb
;
481 pe_export_sort (const void *va
, const void *vb
)
483 const def_file_export
*a
= va
;
484 const def_file_export
*b
= vb
;
492 return strcmp (an
, bn
);
495 /* Read and process the .DEF file. */
497 /* These correspond to the entries in pe_def_file->exports[]. I use
498 exported_symbol_sections[i] to tag whether or not the symbol was
499 defined, since we can't export symbols we don't have. */
501 static bfd_vma
*exported_symbol_offsets
;
502 static struct bfd_section
**exported_symbol_sections
;
503 static int export_table_size
;
504 static int count_exported
;
505 static int count_exported_byname
;
506 static int count_with_ordinals
;
507 static const char *dll_name
;
508 static int min_ordinal
, max_ordinal
;
509 static int *exported_symbols
;
511 typedef struct exclude_list_struct
514 struct exclude_list_struct
*next
;
519 static struct exclude_list_struct
*excludes
= 0;
522 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
525 char *exclude_string
;
527 local_copy
= xstrdup (new_excludes
);
529 exclude_string
= strtok (local_copy
, ",:");
530 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
532 struct exclude_list_struct
*new_exclude
;
534 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
535 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
536 strcpy (new_exclude
->string
, exclude_string
);
537 new_exclude
->type
= type
;
538 new_exclude
->next
= excludes
;
539 excludes
= new_exclude
;
546 is_import (const char* n
)
548 return (startswith (n
, "__imp_"));
551 /* abfd is a bfd containing n (or NULL)
552 It can be used for contextual checks. */
555 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
558 struct exclude_list_struct
*ex
;
559 const autofilter_entry_type
*afptr
;
560 const char * libname
= NULL
;
562 if (abfd
&& abfd
->my_archive
)
563 libname
= lbasename (bfd_get_filename (abfd
->my_archive
));
565 key
.name
= key
.its_name
= (char *) n
;
567 /* Return false if n is in the d->exports table. */
568 if (d
->num_exports
!= 0
569 && bsearch (&key
, d
->exports
, d
->num_exports
,
570 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
573 if (pe_dll_do_default_excludes
)
578 if (pe_dll_extra_pe_debug
)
579 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
580 n
, abfd
, abfd
->my_archive
);
582 /* First of all, make context checks:
583 Don't export anything from standard libs. */
586 afptr
= autofilter_liblist
;
590 if (libnamencmp (libname
, afptr
) == 0 )
596 /* Next, exclude symbols from certain startup objects. */
598 if (abfd
&& (p
= lbasename (bfd_get_filename (abfd
))))
600 afptr
= autofilter_objlist
;
603 if (strcmp (p
, afptr
->name
) == 0)
609 /* Don't try to blindly exclude all symbols
610 that begin with '__'; this was tried and
611 it is too restrictive. Instead we have
612 a target specific list to use: */
613 afptr
= pe_details
->autofilter_symbollist
;
617 if (strcmp (n
, afptr
->name
) == 0)
623 /* Next, exclude symbols starting with ... */
624 afptr
= autofilter_symbolprefixlist
;
627 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
633 /* Finally, exclude symbols ending with ... */
635 afptr
= autofilter_symbolsuffixlist
;
638 if ((len
>= afptr
->len
)
639 /* Add 1 to insure match with trailing '\0'. */
640 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
641 afptr
->len
+ 1) == 0)
648 for (ex
= excludes
; ex
; ex
= ex
->next
)
650 if (ex
->type
== EXCLUDELIBS
)
653 && ((filename_cmp (libname
, ex
->string
) == 0)
654 || (strcasecmp ("ALL", ex
->string
) == 0)))
657 else if (ex
->type
== EXCLUDEFORIMPLIB
)
659 if (filename_cmp (bfd_get_filename (abfd
), ex
->string
) == 0)
662 else if (strcmp (n
, ex
->string
) == 0)
670 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
673 struct bfd_link_hash_entry
*blhe
;
675 struct bfd_section
*s
;
676 def_file_export
*e
= 0;
680 pe_def_file
= def_file_empty ();
682 /* First, run around to all the objects looking for the .drectve
683 sections, and push those into the def file too. */
684 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
686 s
= bfd_get_section_by_name (b
, ".drectve");
690 char *buf
= xmalloc (size
);
692 bfd_get_section_contents (b
, s
, buf
, 0, size
);
693 def_file_add_directive (pe_def_file
, buf
, size
);
698 /* Process aligned common symbol information from the
699 .drectve sections now; common symbol allocation is
700 done before final link, so it will be too late to
701 process them in process_embedded_commands() called
702 from _bfd_coff_link_input_bfd(). */
703 if (pe_def_file
->aligncomms
)
705 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
708 struct coff_link_hash_entry
*sym_hash
;
709 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
710 ac
->symbol_name
, false, false, false);
711 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
712 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
714 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
720 /* If we are building an executable and there is nothing
721 to export, we do not build an export table at all. */
722 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
723 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
726 /* Now, maybe export everything else the default way. */
727 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
728 && !pe_dll_exclude_all_symbols
)
730 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
735 if (!bfd_generic_link_read_symbols (b
))
737 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
741 symbols
= bfd_get_outsymbols (b
);
742 nsyms
= bfd_get_symcount (b
);
744 for (j
= 0; j
< nsyms
; j
++)
746 /* We should export symbols which are either global or not
747 anything at all. (.bss data is the latter)
748 We should not export undefined symbols. */
750 = (symbols
[j
]->section
!= bfd_und_section_ptr
751 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
752 || (symbols
[j
]->flags
== 0)));
753 if (link_info
.version_info
&& would_export
)
755 = !bfd_hide_sym_by_version (link_info
.version_info
,
759 const char *sn
= symbols
[j
]->name
;
761 /* We should not re-export imported stuff. */
767 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
768 sprintf (name
, "%s%s", "__imp_", sn
);
770 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
771 false, false, false);
774 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
778 if (pe_details
->underscored
&& *sn
== '_')
781 if (auto_export (b
, pe_def_file
, sn
))
786 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
788 /* Fill data flag properly, from dlltool.c. */
790 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
798 #define NE pe_def_file->num_exports
800 /* Don't create an empty export table. */
804 resort_needed
= false;
806 /* Canonicalize the export list. */
809 for (i
= 0; i
< NE
; i
++)
811 /* Check for fastcall/stdcall-decoration, but ignore
812 C++ mangled names. */
813 if (pe_def_file
->exports
[i
].name
[0] != '?'
814 && strchr (pe_def_file
->exports
[i
].name
, '@'))
816 /* This will preserve internal_name, which may have been
817 pointing to the same memory as name, or might not
819 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
820 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
821 char *tmp_at
= strrchr (tmp
, '@');
826 einfo (_("%X%P: cannot export %s: invalid export name\n"),
827 pe_def_file
->exports
[i
].name
);
828 pe_def_file
->exports
[i
].name
= tmp
;
829 resort_needed
= true;
834 /* Re-sort the exports table as we have possibly changed the order
835 by removing leading @. */
837 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
840 if (pe_dll_stdcall_aliases
)
842 for (i
= 0; i
< NE
; i
++)
844 if (is_import (pe_def_file
->exports
[i
].name
))
847 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
850 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
851 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
853 *(strchr (tmp
, '@')) = 0;
854 if (auto_export (NULL
, pe_def_file
, tmp
))
855 def_file_add_export (pe_def_file
, tmp
,
856 pe_def_file
->exports
[i
].internal_name
,
864 /* Convenience, but watch out for it changing. */
865 e
= pe_def_file
->exports
;
867 for (i
= 0, j
= 0; i
< NE
; i
++)
869 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
871 /* This is a duplicate. */
872 if (e
[j
- 1].ordinal
!= -1
873 && e
[i
].ordinal
!= -1
874 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
876 if (pe_dll_warn_dup_exports
)
877 /* xgettext:c-format */
878 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
879 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
883 if (pe_dll_warn_dup_exports
)
884 /* xgettext:c-format */
885 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
889 if (e
[i
].ordinal
!= -1)
890 e
[j
- 1].ordinal
= e
[i
].ordinal
;
891 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
892 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
893 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
894 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
896 free (e
[i
].internal_name
);
897 free (e
[i
].its_name
);
906 pe_def_file
->num_exports
= j
; /* == NE */
908 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
909 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
911 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
915 count_exported_byname
= 0;
916 count_with_ordinals
= 0;
918 for (i
= 0; i
< NE
; i
++)
920 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
923 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
924 lang_add_gc_name (int_name
);
926 name
= xmalloc (strlen (int_name
) + 2);
927 if (pe_details
->underscored
&& int_name
[0] != '@')
930 strcpy (name
+ 1, int_name
);
932 /* PR 19803: The alias must be preserved as well. */
933 lang_add_gc_name (xstrdup (name
));
936 strcpy (name
, int_name
);
938 blhe
= bfd_link_hash_lookup (info
->hash
,
943 && (blhe
->type
== bfd_link_hash_defined
944 || (blhe
->type
== bfd_link_hash_common
)))
947 if (!pe_def_file
->exports
[i
].flag_noname
)
948 count_exported_byname
++;
950 /* Only fill in the sections. The actual offsets are computed
951 in fill_exported_offsets() after common symbols are laid
953 if (blhe
->type
== bfd_link_hash_defined
)
954 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
956 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
958 if (pe_def_file
->exports
[i
].ordinal
!= -1)
960 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
961 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
962 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
963 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
964 count_with_ordinals
++;
967 /* Check for forward exports. These are indicated in DEF files by an
968 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
969 but we must take care not to be fooled when the user wants to export
970 a symbol that actually really has a dot in it, so we only check
971 for them here, after real defined symbols have already been matched. */
972 else if (strchr (int_name
, '.'))
975 if (!pe_def_file
->exports
[i
].flag_noname
)
976 count_exported_byname
++;
978 pe_def_file
->exports
[i
].flag_forward
= 1;
980 if (pe_def_file
->exports
[i
].ordinal
!= -1)
982 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
983 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
984 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
985 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
986 count_with_ordinals
++;
989 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
991 /* xgettext:c-format */
992 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
997 /* xgettext:c-format */
998 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
1000 blhe
->type
, bfd_link_hash_defined
);
1004 /* xgettext:c-format */
1005 einfo (_("%X%P: cannot export %s: symbol not found\n"),
1012 /* Build the bfd that will contain .edata and .reloc sections. */
1015 build_filler_bfd (int include_edata
)
1017 lang_input_statement_type
*filler_file
;
1018 filler_file
= lang_add_input_file ("dll stuff",
1019 lang_input_file_is_fake_enum
,
1021 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1022 link_info
.output_bfd
);
1023 if (filler_bfd
== NULL
1024 || !bfd_set_arch_mach (filler_bfd
,
1025 bfd_get_arch (link_info
.output_bfd
),
1026 bfd_get_mach (link_info
.output_bfd
)))
1028 einfo (_("%F%P: can not create BFD: %E\n"));
1034 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1036 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1042 einfo (_("%X%P: can not create .edata section: %E\n"));
1045 bfd_set_section_size (edata_s
, edata_sz
);
1048 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1050 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1056 einfo (_("%X%P: can not create .reloc section: %E\n"));
1060 bfd_set_section_size (reloc_s
, 0);
1062 ldlang_add_file (filler_file
);
1065 /* Gather all the exported symbols and build the .edata section. */
1068 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1070 int i
, next_ordinal
;
1071 int name_table_size
= 0;
1074 /* First, we need to know how many exported symbols there are,
1075 and what the range of ordinals is. */
1076 if (pe_def_file
->name
)
1077 dll_name
= pe_def_file
->name
;
1080 dll_name
= bfd_get_filename (abfd
);
1082 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1083 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1084 dll_name
= dlnp
+ 1;
1087 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1089 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1090 min_ordinal
= max_ordinal
- count_exported
+ 1;
1095 max_ordinal
= count_exported
;
1098 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1099 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1100 for (i
= 0; i
< export_table_size
; i
++)
1101 exported_symbols
[i
] = -1;
1103 /* Now we need to assign ordinals to those that don't have them. */
1104 for (i
= 0; i
< NE
; i
++)
1106 if (exported_symbol_sections
[i
]
1107 || pe_def_file
->exports
[i
].flag_forward
)
1109 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1111 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1112 int pi
= exported_symbols
[ei
];
1116 /* xgettext:c-format */
1117 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1118 pe_def_file
->exports
[i
].ordinal
,
1119 pe_def_file
->exports
[i
].name
,
1120 pe_def_file
->exports
[pi
].name
);
1122 exported_symbols
[ei
] = i
;
1124 if (pe_def_file
->exports
[i
].its_name
)
1125 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1127 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1130 /* Reserve space for the forward name. */
1131 if (pe_def_file
->exports
[i
].flag_forward
)
1133 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1137 next_ordinal
= min_ordinal
;
1138 for (i
= 0; i
< NE
; i
++)
1139 if ((exported_symbol_sections
[i
]
1140 || pe_def_file
->exports
[i
].flag_forward
)
1141 && pe_def_file
->exports
[i
].ordinal
== -1)
1143 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1146 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1147 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1150 /* PR 12969: Check for more than 1^16 ordinals. */
1151 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1152 /* xgettext:c-format */
1153 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1154 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1156 /* OK, now we can allocate some memory. */
1157 edata_sz
= (40 /* directory */
1158 + 4 * export_table_size
/* addresses */
1159 + 4 * count_exported_byname
/* name ptrs */
1160 + 2 * count_exported_byname
/* ordinals */
1161 + name_table_size
+ strlen (dll_name
) + 1);
1164 /* Fill the exported symbol offsets. The preliminary work has already
1165 been done in process_def_file_and_drectve(). */
1168 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1171 struct bfd_link_hash_entry
*blhe
;
1173 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1177 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1178 if (pe_details
->underscored
1179 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1182 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1185 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1187 blhe
= bfd_link_hash_lookup (info
->hash
,
1189 false, false, true);
1191 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1192 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1199 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1202 unsigned char *edirectory
;
1203 unsigned char *eaddresses
;
1204 unsigned char *enameptrs
;
1205 unsigned char *eordinals
;
1208 edata_d
= xmalloc (edata_sz
);
1210 /* Note use of array pointer math here. */
1211 edirectory
= edata_d
;
1212 eaddresses
= edirectory
+ 40;
1213 enameptrs
= eaddresses
+ 4 * export_table_size
;
1214 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1215 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1217 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1218 + edata_s->output_section->vma - image_base)
1220 memset (edata_d
, 0, edata_sz
);
1222 if (pe_data (abfd
)->timestamp
== -1)
1223 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1225 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, edata_d
+ 4);
1227 if (pe_def_file
->version_major
!= -1)
1229 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1230 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1233 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1234 strcpy (enamestr
, dll_name
);
1235 enamestr
+= strlen (enamestr
) + 1;
1236 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1237 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1238 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1239 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1240 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1241 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1243 fill_exported_offsets (abfd
, info
);
1245 /* Ok, now for the filling in part.
1246 Scan alphabetically - ie the ordering in the exports[] table,
1247 rather than by ordinal - the ordering in the exported_symbol[]
1248 table. See dlltool.c and:
1249 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1250 for more information. */
1252 for (s
= 0; s
< NE
; s
++)
1254 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1255 if (pe_def_file
->exports
[s
].ordinal
!= -1
1256 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1258 int ord
= pe_def_file
->exports
[s
].ordinal
;
1260 if (pe_def_file
->exports
[s
].flag_forward
)
1262 bfd_put_32 (abfd
, ERVA (enamestr
),
1263 eaddresses
+ 4 * (ord
- min_ordinal
));
1265 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1266 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1270 bfd_vma srva
= (exported_symbol_offsets
[s
]
1271 + ssec
->output_section
->vma
1272 + ssec
->output_offset
);
1274 bfd_put_32 (abfd
, srva
- image_base
,
1275 eaddresses
+ 4 * (ord
- min_ordinal
));
1278 if (!pe_def_file
->exports
[s
].flag_noname
)
1280 char *ename
= pe_def_file
->exports
[s
].name
;
1281 if (pe_def_file
->exports
[s
].its_name
)
1282 ename
= pe_def_file
->exports
[s
].its_name
;
1284 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1286 strcpy (enamestr
, ename
);
1287 enamestr
+= strlen (enamestr
) + 1;
1288 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1290 pe_def_file
->exports
[s
].hint
= hint
++;
1297 static struct bfd_section
*current_sec
;
1300 pe_walk_relocs (struct bfd_link_info
*info
,
1302 const char *symname
,
1303 struct bfd_hash_table
*import_hash
,
1304 void (*cb
) (arelent
*, asection
*, char *, const char *))
1309 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1313 if (!bfd_generic_link_read_symbols (b
))
1315 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1319 symbols
= bfd_get_outsymbols (b
);
1321 for (s
= b
->sections
; s
; s
= s
->next
)
1324 int relsize
, nrelocs
, i
;
1325 int flags
= bfd_section_flags (s
);
1327 /* Skip discarded linkonce sections. */
1328 if (flags
& SEC_LINK_ONCE
1329 && s
->output_section
== bfd_abs_section_ptr
)
1334 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1335 relocs
= xmalloc (relsize
);
1336 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1338 for (i
= 0; i
< nrelocs
; i
++)
1340 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1342 /* Warning: the callback needs to be passed NAME directly. */
1345 if (bfd_hash_lookup (import_hash
, sym
->name
, false, false))
1347 strcpy (name
, sym
->name
);
1348 cb (relocs
[i
], s
, name
, symname
);
1353 if (strcmp (name
, sym
->name
) == 0)
1354 cb (relocs
[i
], s
, name
, symname
);
1360 /* Warning: the allocated symbols are remembered in BFD and reused
1361 later, so don't free them! */
1362 /* free (symbols); */
1368 pe_find_data_imports (const char *symhead
,
1369 void (*cb
) (arelent
*, asection
*, char *, const char *))
1371 struct bfd_link_hash_entry
*undef
;
1372 const size_t headlen
= strlen (symhead
);
1375 struct bfd_hash_table
*import_hash
;
1377 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1378 if (undef
->type
== bfd_link_hash_undefined
)
1380 size_t len
= strlen (undef
->root
.string
);
1387 /* For the pseudo-relocation support version 2, we can collect the symbols
1388 that are subject to auto-import and adjust the relocations en masse. */
1389 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1392 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1393 if (!bfd_hash_table_init (import_hash
,
1395 sizeof (struct bfd_hash_entry
)))
1396 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1401 /* We are being a bit cunning here. The buffer will have space for
1402 prefixes at the beginning. The prefix is modified here and in a
1403 number of functions called from this function. */
1404 #define PREFIX_LEN 32
1405 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1406 name
= buf
+ PREFIX_LEN
;
1408 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1409 if (undef
->type
== bfd_link_hash_undefined
)
1411 struct bfd_link_hash_entry
*sym
;
1414 if (pe_dll_extra_pe_debug
)
1415 printf ("%s:%s\n", __FUNCTION__
, undef
->root
.string
);
1417 strcpy (name
, undef
->root
.string
);
1418 impname
= name
- (sizeof "__imp_" - 1);
1419 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1421 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1423 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1426 bfd_hash_lookup (import_hash
, undef
->root
.string
, true, false);
1429 bfd
*b
= sym
->u
.def
.section
->owner
;
1430 const char *symname
= NULL
;
1434 if (!bfd_generic_link_read_symbols (b
))
1436 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1440 symbols
= bfd_get_outsymbols (b
);
1441 nsyms
= bfd_get_symcount (b
);
1443 for (i
= 0; i
< nsyms
; i
++)
1444 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1446 if (pe_dll_extra_pe_debug
)
1447 printf ("->%s\n", symbols
[i
]->name
);
1449 symname
= symbols
[i
]->name
+ headlen
;
1453 /* If the symobl isn't part of an import table, there is no
1454 point in building a fixup, this would give rise to link
1455 errors for mangled symbols instead of the original one. */
1457 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1462 /* Let's differentiate it somehow from defined. */
1463 undef
->type
= bfd_link_hash_defweak
;
1464 undef
->u
.def
.value
= sym
->u
.def
.value
;
1465 undef
->u
.def
.section
= sym
->u
.def
.section
;
1467 /* We replace the original name with the __imp_ prefixed one, this
1468 1) may trash memory 2) leads to duplicate symbols. But this is
1469 better than having a misleading name that can confuse GDB. */
1470 undef
->root
.string
= sym
->root
.string
;
1472 if (link_info
.pei386_auto_import
== -1)
1474 static bool warned
= false;
1476 info_msg (_("Info: resolving %s by linking to %s "
1477 "(auto-import)\n"), name
, impname
);
1479 /* PR linker/4844. */
1482 einfo (_("%P: warning: auto-importing has been activated "
1483 "without --enable-auto-import specified on the "
1484 "command line; this should work unless it "
1485 "involves constant data structures referencing "
1486 "symbols from auto-imported DLLs\n"));
1493 /* If we have the import hash table, walk the relocations only once. */
1496 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1497 bfd_hash_table_free (import_hash
);
1504 /* Gather all the relocations and build the .reloc section. */
1507 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1509 /* For .reloc stuff. */
1510 reloc_data_type
*reloc_data
;
1511 int total_relocs
= 0;
1513 bfd_vma sec_page
= (bfd_vma
) -1;
1514 bfd_vma page_ptr
, page_count
;
1517 struct bfd_section
*s
;
1519 if (reloc_s
== NULL
|| reloc_s
->output_section
== bfd_abs_section_ptr
)
1522 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1523 for (s
= b
->sections
; s
; s
= s
->next
)
1524 total_relocs
+= s
->reloc_count
;
1526 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1530 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1533 int relsize
, nrelocs
;
1535 for (s
= b
->sections
; s
; s
= s
->next
)
1537 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1540 /* If it's not loaded, we don't need to relocate it this way. */
1541 if (!(s
->output_section
->flags
& SEC_LOAD
))
1544 /* I don't know why there would be a reloc for these, but I've
1545 seen it happen - DJ */
1546 if (s
->output_section
== bfd_abs_section_ptr
)
1549 if (s
->output_section
->vma
== 0)
1551 /* Huh? Shouldn't happen, but punt if it does. */
1552 #if 0 /* This happens when linking with --just-symbols=<file>, so do not generate an error. */
1553 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1554 s
->output_section
->name
, s
->output_section
->index
,
1555 s
->output_section
->flags
);
1560 if (!bfd_generic_link_read_symbols (b
))
1562 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1566 symbols
= bfd_get_outsymbols (b
);
1567 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1568 relocs
= xmalloc (relsize
);
1569 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1571 for (i
= 0; i
< nrelocs
; i
++)
1573 if (pe_dll_extra_pe_debug
)
1575 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1576 printf ("rel: %s\n", sym
->name
);
1578 if (!relocs
[i
]->howto
->pc_relative
1579 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1581 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1582 const struct bfd_link_hash_entry
*blhe
1583 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1584 false, false, false);
1586 /* Don't create relocs for undefined weak symbols. */
1587 if (sym
->flags
== BSF_WEAK
)
1589 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1591 /* Check aux sym and see if it is defined or not. */
1592 struct coff_link_hash_entry
*h
, *h2
;
1593 h
= (struct coff_link_hash_entry
*)blhe
;
1594 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1596 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1597 [h
->aux
->x_sym
.x_tagndx
.l
];
1598 /* We don't want a base reloc if the aux sym is not
1599 found, undefined, or if it is the constant ABS
1600 zero default value. (We broaden that slightly by
1601 not testing the value, just the section; there's
1602 no reason we'd want a reference to any absolute
1603 address to get relocated during rebasing). */
1604 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1605 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1608 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1611 /* Nor for Dwarf FDE references to discarded sections. */
1612 else if (bfd_is_abs_section (sym
->section
->output_section
))
1614 /* We only ignore relocs from .eh_frame sections, as
1615 they are discarded by the final link rather than
1616 resolved against the kept section. */
1617 if (!strcmp (s
->name
, ".eh_frame"))
1620 /* Nor for absolute symbols. */
1621 else if (blhe
&& ldexp_is_final_sym_absolute (blhe
)
1622 && (!blhe
->linker_def
1623 || (strcmp (sym
->name
, "__image_base__")
1624 && strcmp (sym
->name
, U ("__ImageBase")))))
1627 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1628 reloc_data
[total_relocs
].idx
= total_relocs
;
1630 /* Since we're only about to determine .reloc's size,
1631 subsequent output section VMA calculations will shift up
1632 sections at this or higher addresses. Relocations for
1633 such sections would hence end up not being correct. */
1634 if (reloc_data
[total_relocs
].vma
1635 >= reloc_s
->output_section
->vma
)
1636 einfo (_("%P: base relocation for section `%s' above "
1637 ".reloc section\n"), s
->output_section
->name
);
1639 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1641 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1642 relocs
[i
]->howto
->rightshift
)
1644 #ifdef pe_use_x86_64
1645 case BITS_AND_SHIFT (64, 0):
1646 reloc_data
[total_relocs
].type
= 10;
1650 case BITS_AND_SHIFT (32, 0):
1651 reloc_data
[total_relocs
].type
= 3;
1654 case BITS_AND_SHIFT (16, 0):
1655 reloc_data
[total_relocs
].type
= 2;
1658 case BITS_AND_SHIFT (16, 16):
1659 reloc_data
[total_relocs
].type
= 4;
1660 /* FIXME: we can't know the symbol's right value
1661 yet, but we probably can safely assume that
1662 CE will relocate us in 64k blocks, so leaving
1664 reloc_data
[total_relocs
].extra
= 0;
1667 case BITS_AND_SHIFT (26, 2):
1668 reloc_data
[total_relocs
].type
= 5;
1671 case BITS_AND_SHIFT (24, 2):
1672 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1673 Those ARM_xxx definitions should go in proper
1675 if (relocs
[i
]->howto
->type
== 0
1676 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1677 || relocs
[i
]->howto
->type
== 5)
1678 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1679 that has already been fully processed during a
1680 previous link stage, so ignore it here. */
1684 /* xgettext:c-format */
1685 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1686 relocs
[i
]->howto
->bitsize
);
1692 /* Warning: the allocated symbols are remembered in BFD and
1693 reused later, so don't free them! */
1697 /* At this point, we have total_relocs relocation addresses in
1698 reloc_addresses, which are all suitable for the .reloc section.
1699 We must now create the new sections. */
1700 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1702 for (i
= 0; i
< total_relocs
; i
++)
1704 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1706 if (this_page
!= sec_page
)
1708 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1710 sec_page
= this_page
;
1715 if (reloc_data
[i
].type
== 4)
1719 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1720 reloc_d
= xmalloc (reloc_sz
);
1721 sec_page
= (bfd_vma
) -1;
1723 page_ptr
= (bfd_vma
) -1;
1726 for (i
= 0; i
< total_relocs
; i
++)
1728 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1729 bfd_vma this_page
= (rva
& ~0xfff);
1731 if (this_page
!= sec_page
)
1733 while (reloc_sz
& 3)
1734 reloc_d
[reloc_sz
++] = 0;
1736 if (page_ptr
!= (bfd_vma
) -1)
1737 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1739 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1740 page_ptr
= reloc_sz
;
1742 sec_page
= this_page
;
1746 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1747 reloc_d
+ reloc_sz
);
1750 if (reloc_data
[i
].type
== 4)
1752 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1759 while (reloc_sz
& 3)
1760 reloc_d
[reloc_sz
++] = 0;
1762 if (page_ptr
!= (bfd_vma
) -1)
1763 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1766 /* Given the exiting def_file structure, print out a .DEF file that
1767 corresponds to it. */
1770 quoteput (char *s
, FILE *f
, int needs_quotes
)
1774 for (cp
= s
; *cp
; cp
++)
1789 if (*s
== '"' || *s
== '\\')
1803 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1806 FILE *out
= fopen (pe_out_def_filename
, "w");
1809 /* xgettext:c-format */
1810 einfo (_("%P: can't open output def file %s\n"),
1811 pe_out_def_filename
);
1815 if (pe_def_file
->name
)
1817 if (pe_def_file
->is_dll
)
1818 fprintf (out
, "LIBRARY ");
1820 fprintf (out
, "NAME ");
1822 quoteput (pe_def_file
->name
, out
, 1);
1824 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1826 fprintf (out
, " BASE=0x");
1827 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1829 fprintf (out
, "\n");
1832 if (pe_def_file
->description
)
1834 fprintf (out
, "DESCRIPTION ");
1835 quoteput (pe_def_file
->description
, out
, 1);
1836 fprintf (out
, "\n");
1839 if (pe_def_file
->version_minor
!= -1)
1840 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1841 pe_def_file
->version_minor
);
1842 else if (pe_def_file
->version_major
!= -1)
1843 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1845 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1846 fprintf (out
, "\n");
1848 if (pe_def_file
->stack_commit
!= -1)
1849 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1850 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1851 else if (pe_def_file
->stack_reserve
!= -1)
1852 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1854 if (pe_def_file
->heap_commit
!= -1)
1855 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1856 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1857 else if (pe_def_file
->heap_reserve
!= -1)
1858 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1860 if (pe_def_file
->num_section_defs
> 0)
1862 fprintf (out
, "\nSECTIONS\n\n");
1864 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1867 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1869 if (pe_def_file
->section_defs
[i
].class)
1871 fprintf (out
, " CLASS ");
1872 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1875 if (pe_def_file
->section_defs
[i
].flag_read
)
1876 fprintf (out
, " READ");
1878 if (pe_def_file
->section_defs
[i
].flag_write
)
1879 fprintf (out
, " WRITE");
1881 if (pe_def_file
->section_defs
[i
].flag_execute
)
1882 fprintf (out
, " EXECUTE");
1884 if (pe_def_file
->section_defs
[i
].flag_shared
)
1885 fprintf (out
, " SHARED");
1887 fprintf (out
, "\n");
1891 if (pe_def_file
->num_exports
> 0)
1893 fprintf (out
, "EXPORTS\n");
1895 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1897 def_file_export
*e
= pe_def_file
->exports
+ i
;
1899 quoteput (e
->name
, out
, 0);
1901 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1903 fprintf (out
, " = ");
1904 quoteput (e
->internal_name
, out
, 0);
1907 if (e
->ordinal
!= -1)
1908 fprintf (out
, " @%d", e
->ordinal
);
1910 if (e
->flag_private
)
1911 fprintf (out
, " PRIVATE");
1913 if (e
->flag_constant
)
1914 fprintf (out
, " CONSTANT");
1917 fprintf (out
, " NONAME");
1920 fprintf (out
, " DATA");
1922 fprintf (out
, "\n");
1926 if (pe_def_file
->num_imports
> 0)
1928 fprintf (out
, "\nIMPORTS\n\n");
1930 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1932 def_file_import
*im
= pe_def_file
->imports
+ i
;
1935 if (im
->internal_name
1936 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1938 quoteput (im
->internal_name
, out
, 0);
1939 fprintf (out
, " = ");
1942 quoteput (im
->module
->name
, out
, 0);
1946 quoteput (im
->name
, out
, 0);
1948 fprintf (out
, "%d", im
->ordinal
);
1952 fprintf (out
, " == ");
1953 quoteput (im
->its_name
, out
, 0);
1956 fprintf (out
, "\n");
1961 fprintf (out
, _("; no contents available\n"));
1963 if (fclose (out
) == EOF
)
1964 /* xgettext:c-format */
1965 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1968 /* Generate the import library. */
1970 static asymbol
**symtab
;
1973 static const char *dll_filename
;
1974 static char *dll_symname
;
1976 #define UNDSEC bfd_und_section_ptr
1979 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1984 sec
= bfd_make_section_old_way (abfd
, name
);
1985 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1986 bfd_set_section_alignment (sec
, align
);
1987 /* Remember to undo this before trying to link internally! */
1988 sec
->output_section
= sec
;
1990 sym
= bfd_make_empty_symbol (abfd
);
1991 symtab
[symptr
++] = sym
;
1992 sym
->name
= sec
->name
;
1994 sym
->flags
= BSF_LOCAL
;
2001 quick_symbol (bfd
*abfd
,
2010 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
2015 sym
= bfd_make_empty_symbol (abfd
);
2020 symtab
[symptr
++] = sym
;
2023 static arelent
*reltab
= 0;
2024 static int relcount
= 0, relsize
= 0;
2027 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2029 if (relcount
>= relsize
- 1)
2033 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2035 reltab
= xmalloc (relsize
* sizeof (arelent
));
2037 reltab
[relcount
].address
= address
;
2038 reltab
[relcount
].addend
= 0;
2039 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2040 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2045 save_relocs (asection
*sec
)
2049 sec
->relocation
= reltab
;
2050 sec
->reloc_count
= relcount
;
2051 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2052 for (i
= 0; i
< relcount
; i
++)
2053 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2054 sec
->orelocation
[relcount
] = 0;
2055 sec
->flags
|= SEC_RELOC
;
2057 relcount
= relsize
= 0;
2060 /* .section .idata$2
2061 .global __head_my_dll
2078 make_head (bfd
*parent
)
2080 asection
*id2
, *id5
, *id4
;
2081 unsigned char *d2
, *d5
, *d4
;
2085 oname
= xmalloc (20);
2086 sprintf (oname
, "d%06d.o", tmp_seq
);
2089 abfd
= bfd_create (oname
, parent
);
2090 bfd_find_target (pe_details
->object_target
, abfd
);
2091 bfd_make_writable (abfd
);
2093 bfd_set_format (abfd
, bfd_object
);
2094 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2097 symtab
= xmalloc (6 * sizeof (asymbol
*));
2098 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2099 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2100 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2101 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2102 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2104 /* OK, pay attention here. I got confused myself looking back at
2105 it. We create a four-byte section to mark the beginning of the
2106 list, and we include an offset of 4 in the section, so that the
2107 pointer to the list points to the *end* of this section, which is
2108 the start of the list of sections from other objects. */
2110 bfd_set_section_size (id2
, 20);
2114 if (pe_use_nul_prefixed_import_tables
)
2115 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2116 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2117 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2118 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2121 if (pe_use_nul_prefixed_import_tables
)
2122 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2124 bfd_set_section_size (id5
, 0);
2125 d5
= xmalloc (PE_IDATA5_SIZE
);
2127 memset (d5
, 0, PE_IDATA5_SIZE
);
2128 if (pe_use_nul_prefixed_import_tables
)
2129 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2131 bfd_set_section_size (id4
, 0);
2132 d4
= xmalloc (PE_IDATA4_SIZE
);
2134 memset (d4
, 0, PE_IDATA4_SIZE
);
2136 bfd_set_symtab (abfd
, symtab
, symptr
);
2138 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2139 if (pe_use_nul_prefixed_import_tables
)
2141 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2142 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2146 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2147 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2150 bfd_make_readable (abfd
);
2154 /* .section .idata$4
2161 .global __my_dll_iname
2166 make_tail (bfd
*parent
)
2168 asection
*id4
, *id5
, *id7
;
2169 unsigned char *d4
, *d5
, *d7
;
2174 oname
= xmalloc (20);
2175 sprintf (oname
, "d%06d.o", tmp_seq
);
2178 abfd
= bfd_create (oname
, parent
);
2179 bfd_find_target (pe_details
->object_target
, abfd
);
2180 bfd_make_writable (abfd
);
2182 bfd_set_format (abfd
, bfd_object
);
2183 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2186 symtab
= xmalloc (5 * sizeof (asymbol
*));
2187 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2188 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2189 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2190 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2192 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2193 d4
= xmalloc (PE_IDATA4_SIZE
);
2195 memset (d4
, 0, PE_IDATA4_SIZE
);
2197 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2198 d5
= xmalloc (PE_IDATA5_SIZE
);
2200 memset (d5
, 0, PE_IDATA5_SIZE
);
2202 len
= strlen (dll_filename
) + 1;
2205 bfd_set_section_size (id7
, len
);
2208 strcpy ((char *) d7
, dll_filename
);
2209 /* If len was odd, the above
2210 strcpy leaves behind an undefined byte. That is harmless,
2211 but we set it to 0 just so the binary dumps are pretty. */
2214 bfd_set_symtab (abfd
, symtab
, symptr
);
2216 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2217 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2218 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2220 bfd_make_readable (abfd
);
2226 .global ___imp_function
2227 .global __imp__function
2229 jmp *__imp__function:
2243 .asciz "function" xlate? (add underscore, kill at) */
2245 static const unsigned char jmp_ix86_bytes
[] =
2247 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2255 .dw __imp_function */
2257 static const unsigned char jmp_sh_bytes
[] =
2259 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2263 lui $t0,<high:__imp_function>
2264 lw $t0,<low:__imp_function>
2268 static const unsigned char jmp_mips_bytes
[] =
2270 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2271 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2274 static const unsigned char jmp_arm_bytes
[] =
2276 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2277 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2283 make_one (def_file_export
*exp
, bfd
*parent
, bool include_jmp_stub
)
2285 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2286 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2290 const unsigned char *jmp_bytes
= NULL
;
2291 int jmp_byte_count
= 0;
2293 /* Include the jump stub section only if it is needed. A jump
2294 stub is needed if the symbol being imported <sym> is a function
2295 symbol and there is at least one undefined reference to that
2296 symbol. In other words, if all the import references to <sym> are
2297 explicitly through _declspec(dllimport) then the jump stub is not
2299 if (include_jmp_stub
)
2301 switch (pe_details
->pe_arch
)
2304 jmp_bytes
= jmp_ix86_bytes
;
2305 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2308 jmp_bytes
= jmp_sh_bytes
;
2309 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2312 jmp_bytes
= jmp_mips_bytes
;
2313 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2316 case PE_ARCH_arm_wince
:
2317 jmp_bytes
= jmp_arm_bytes
;
2318 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2325 oname
= xmalloc (20);
2326 sprintf (oname
, "d%06d.o", tmp_seq
);
2329 abfd
= bfd_create (oname
, parent
);
2330 bfd_find_target (pe_details
->object_target
, abfd
);
2331 bfd_make_writable (abfd
);
2333 bfd_set_format (abfd
, bfd_object
);
2334 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2337 symtab
= xmalloc (12 * sizeof (asymbol
*));
2339 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2340 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2341 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2342 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2343 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2345 if (*exp
->internal_name
== '@')
2347 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2349 if (include_jmp_stub
)
2350 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2351 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2353 /* Fastcall applies only to functions,
2354 so no need for auto-import symbol. */
2358 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2360 if (include_jmp_stub
)
2361 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2363 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2365 /* Symbol to reference ord/name of imported
2366 data symbol, used to implement auto-import. */
2368 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2371 if (pe_dll_compat_implib
)
2372 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2375 if (include_jmp_stub
)
2377 bfd_set_section_size (tx
, jmp_byte_count
);
2378 td
= xmalloc (jmp_byte_count
);
2380 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2382 switch (pe_details
->pe_arch
)
2385 #ifdef pe_use_x86_64
2386 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2388 /* Mark this object as SAFESEH compatible. */
2389 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2391 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2395 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2398 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2399 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2400 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2403 case PE_ARCH_arm_wince
:
2404 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2412 bfd_set_section_size (tx
, 0);
2414 bfd_set_section_size (id7
, 4);
2418 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2421 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2422 d5
= xmalloc (PE_IDATA5_SIZE
);
2424 memset (d5
, 0, PE_IDATA5_SIZE
);
2426 if (exp
->flag_noname
)
2428 d5
[0] = exp
->ordinal
;
2429 d5
[1] = exp
->ordinal
>> 8;
2430 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2434 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2438 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2439 d4
= xmalloc (PE_IDATA4_SIZE
);
2441 memset (d4
, 0, PE_IDATA4_SIZE
);
2443 if (exp
->flag_noname
)
2445 d4
[0] = exp
->ordinal
;
2446 d4
[1] = exp
->ordinal
>> 8;
2447 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2451 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2455 if (exp
->flag_noname
)
2458 bfd_set_section_size (id6
, 0);
2464 /* { short, asciz } */
2466 len
= 2 + strlen (exp
->its_name
) + 1;
2468 len
= 2 + strlen (exp
->name
) + 1;
2471 bfd_set_section_size (id6
, len
);
2474 memset (d6
, 0, len
);
2476 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2477 contains an invalid value (-1). */
2478 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2483 strcpy ((char*) d6
+ 2, exp
->its_name
);
2485 strcpy ((char *) d6
+ 2, exp
->name
);
2488 bfd_set_symtab (abfd
, symtab
, symptr
);
2490 if (include_jmp_stub
)
2491 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2492 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2493 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2494 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2495 if (!exp
->flag_noname
)
2496 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2498 bfd_make_readable (abfd
);
2503 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2505 /* Name thunks go to idata$4. */
2511 oname
= xmalloc (20);
2512 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2515 abfd
= bfd_create (oname
, parent
);
2516 bfd_find_target (pe_details
->object_target
, abfd
);
2517 bfd_make_writable (abfd
);
2519 bfd_set_format (abfd
, bfd_object
);
2520 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2523 symtab
= xmalloc (3 * sizeof (asymbol
*));
2524 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2525 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2526 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2528 /* We need space for the real thunk and for the null terminator. */
2529 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2530 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2532 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2533 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2536 bfd_set_symtab (abfd
, symtab
, symptr
);
2538 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2540 bfd_make_readable (abfd
);
2545 make_import_fixup_mark (arelent
*rel
, char *name
)
2547 /* We convert reloc to symbol, for later reference. */
2548 static unsigned int counter
;
2549 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2550 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2551 struct bfd_link_hash_entry
*bh
;
2552 char *fixup_name
, buf
[26];
2555 /* "name" buffer has space before the symbol name for prefixes. */
2556 sprintf (buf
, "__fu%d_", counter
++);
2557 prefix_len
= strlen (buf
);
2558 fixup_name
= name
- prefix_len
;
2559 memcpy (fixup_name
, buf
, prefix_len
);
2562 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2563 current_sec
, /* sym->section, */
2564 rel
->address
, NULL
, true, false, &bh
);
2566 return bh
->root
.string
;
2569 /* .section .idata$2
2570 .rva __nm_thnk_SYM (singleton thunk with name of func)
2573 .rva __my_dll_iname (name of dll)
2574 .rva __fuNN_SYM (pointer to reference (address) in text) */
2577 make_import_fixup_entry (const char *name
,
2578 const char *fixup_name
,
2579 const char *symname
,
2587 oname
= xmalloc (20);
2588 sprintf (oname
, "fu%06d.o", tmp_seq
);
2591 abfd
= bfd_create (oname
, parent
);
2592 bfd_find_target (pe_details
->object_target
, abfd
);
2593 bfd_make_writable (abfd
);
2595 bfd_set_format (abfd
, bfd_object
);
2596 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2599 symtab
= xmalloc (6 * sizeof (asymbol
*));
2600 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2602 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2603 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2604 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2606 bfd_set_section_size (id2
, 20);
2611 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2612 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2613 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2616 bfd_set_symtab (abfd
, symtab
, symptr
);
2618 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2620 bfd_make_readable (abfd
);
2624 /* .section .rdata_runtime_pseudo_reloc
2626 .rva __fuNN_SYM (pointer to reference (address) in text) */
2629 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2630 const char *fixup_name
,
2631 bfd_vma addend ATTRIBUTE_UNUSED
,
2636 unsigned char *rt_rel_d
;
2641 oname
= xmalloc (20);
2642 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2645 abfd
= bfd_create (oname
, parent
);
2646 bfd_find_target (pe_details
->object_target
, abfd
);
2647 bfd_make_writable (abfd
);
2649 bfd_set_format (abfd
, bfd_object
);
2650 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2652 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2654 if (runtime_pseudp_reloc_v2_init
)
2655 size
= 3 * sizeof (asymbol
*);
2657 size
= 6 * sizeof (asymbol
*);
2660 size
= 2 * sizeof (asymbol
*);
2663 symtab
= xmalloc (size
);
2666 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2668 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2670 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2673 if (!runtime_pseudp_reloc_v2_init
)
2676 runtime_pseudp_reloc_v2_init
= true;
2679 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2681 bfd_set_section_size (rt_rel
, size
);
2682 rt_rel_d
= xmalloc (size
);
2683 rt_rel
->contents
= rt_rel_d
;
2684 memset (rt_rel_d
, 0, size
);
2685 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2686 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2687 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2689 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2690 save_relocs (rt_rel
);
2692 bfd_set_symtab (abfd
, symtab
, symptr
);
2694 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2698 bfd_set_section_size (rt_rel
, 8);
2699 rt_rel_d
= xmalloc (8);
2700 rt_rel
->contents
= rt_rel_d
;
2701 memset (rt_rel_d
, 0, 8);
2703 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2704 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2706 save_relocs (rt_rel
);
2708 bfd_set_symtab (abfd
, symtab
, symptr
);
2710 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2713 bfd_make_readable (abfd
);
2718 .rva __pei386_runtime_relocator */
2721 pe_create_runtime_relocator_reference (bfd
*parent
)
2723 asection
*extern_rt_rel
;
2724 unsigned char *extern_rt_rel_d
;
2728 oname
= xmalloc (20);
2729 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2732 abfd
= bfd_create (oname
, parent
);
2733 bfd_find_target (pe_details
->object_target
, abfd
);
2734 bfd_make_writable (abfd
);
2736 bfd_set_format (abfd
, bfd_object
);
2737 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2740 symtab
= xmalloc (2 * sizeof (asymbol
*));
2741 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2743 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2746 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2747 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2748 extern_rt_rel
->contents
= extern_rt_rel_d
;
2750 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2751 save_relocs (extern_rt_rel
);
2753 bfd_set_symtab (abfd
, symtab
, symptr
);
2755 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2757 bfd_make_readable (abfd
);
2762 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2763 const char *symname
)
2765 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2768 /* This is the original implementation of the auto-import feature, which
2769 primarily relied on the OS loader to patch things up with some help
2770 from the pseudo-relocator to overcome the main limitation. See the
2771 comment at the beginning of the file for an overview of the feature. */
2772 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2774 struct bfd_link_hash_entry
*name_thunk_sym
;
2775 /* name buffer is allocated with space at beginning for prefixes. */
2776 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2777 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2778 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2780 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2782 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2783 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2785 /* If we ever use autoimport, we have to cast text section writable. */
2786 config
.text_read_only
= false;
2787 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2790 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2792 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2793 link_info
.output_bfd
);
2794 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2798 /* In the original implementation, the pseudo-relocator was only used when
2799 the addend was not null. In the new implementation, the OS loader is
2800 completely bypassed and the pseudo-relocator does the entire work. */
2801 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2802 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2804 if (pe_dll_extra_pe_debug
)
2805 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2806 fixup_name
, (int) addend
);
2808 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2809 link_info
.output_bfd
);
2810 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2812 if (runtime_pseudo_relocs_created
++ == 0)
2814 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2815 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2819 else if (addend
!= 0)
2820 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2821 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2825 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2834 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2835 dll_symname
= xstrdup (dll_filename
);
2836 for (i
= 0; dll_symname
[i
]; i
++)
2837 if (!ISALNUM (dll_symname
[i
]))
2838 dll_symname
[i
] = '_';
2840 unlink_if_ordinary (impfilename
);
2842 outarch
= bfd_openw (impfilename
, 0);
2846 /* xgettext:c-format */
2847 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2852 /* xgettext:c-format */
2853 info_msg (_("Creating library file: %s\n"), impfilename
);
2855 bfd_set_format (outarch
, bfd_archive
);
2856 outarch
->has_armap
= 1;
2858 /* Work out a reasonable size of things to put onto one line. */
2859 ar_head
= make_head (outarch
);
2861 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2862 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2864 /* Iterate the exclude list. */
2865 struct exclude_list_struct
*ex
;
2867 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2869 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2871 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2873 /* If it matched, we must open a fresh BFD for it (the original
2874 input BFD is still needed for the DLL's final link) and add
2875 it into the archive member chain. */
2878 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2879 ? bfd_get_filename (ibfd
->my_archive
)
2880 : bfd_get_filename (ibfd
), NULL
);
2883 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2886 if (ibfd
->my_archive
)
2888 /* Must now iterate through archive until we find the
2889 required member. A minor shame that we'll open the
2890 archive once per member that we require from it, and
2891 leak those archive bfds rather than reuse them. */
2892 bfd
*arbfd
= newbfd
;
2893 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2895 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2896 bfd_get_filename (ibfd
->my_archive
),
2897 bfd_get_filename (ibfd
));
2901 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2903 if (filename_cmp (bfd_get_filename (newbfd
),
2904 bfd_get_filename (ibfd
)) == 0)
2909 einfo (_("%X%P: %s(%s): can't find member in archive"),
2910 bfd_get_filename (ibfd
->my_archive
),
2911 bfd_get_filename (ibfd
));
2915 newbfd
->archive_next
= head
;
2920 for (i
= 0; i
< def
->num_exports
; i
++)
2922 /* The import library doesn't know about the internal name. */
2923 char *internal
= def
->exports
[i
].internal_name
;
2926 /* Don't add PRIVATE entries to import lib. */
2927 if (pe_def_file
->exports
[i
].flag_private
)
2930 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2932 /* PR 19803: If a symbol has been discard due to garbage
2933 collection then do not create any exports for it. */
2935 struct coff_link_hash_entry
*h
;
2937 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2938 false, false, false);
2940 /* If the symbol is hidden and undefined then it
2941 has been swept up by garbage collection. */
2942 && h
->symbol_class
== C_HIDDEN
2943 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2946 /* If necessary, check with an underscore prefix as well. */
2947 if (pe_details
->underscored
&& internal
[0] != '@')
2951 name
= xmalloc (strlen (internal
) + 2);
2952 sprintf (name
, "_%s", internal
);
2954 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2955 false, false, false);
2959 /* If the symbol is hidden and undefined then it
2960 has been swept up by garbage collection. */
2961 && h
->symbol_class
== C_HIDDEN
2962 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2967 n
= make_one (def
->exports
+ i
, outarch
,
2968 ! (def
->exports
+ i
)->flag_data
);
2969 n
->archive_next
= head
;
2971 def
->exports
[i
].internal_name
= internal
;
2974 ar_tail
= make_tail (outarch
);
2976 if (ar_head
== NULL
|| ar_tail
== NULL
)
2979 /* Now stick them all into the archive. */
2980 ar_head
->archive_next
= head
;
2981 ar_tail
->archive_next
= ar_head
;
2984 if (! bfd_set_archive_head (outarch
, head
))
2985 einfo ("%X%P: bfd_set_archive_head: %E\n");
2987 if (! bfd_close (outarch
))
2988 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
2990 while (head
!= NULL
)
2992 bfd
*n
= head
->archive_next
;
2998 static int undef_count
= 0;
3006 static struct key_value
*udef_table
;
3008 static int undef_sort_cmp (const void *l1
, const void *r1
)
3010 const struct key_value
*l
= l1
;
3011 const struct key_value
*r
= r1
;
3013 return strcmp (l
->key
, r
->key
);
3016 static struct bfd_link_hash_entry
*
3017 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3019 struct bfd_link_hash_entry
*h
= NULL
;
3020 struct key_value
*kv
;
3021 struct key_value key
;
3022 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3024 strcpy (lname
, name
);
3026 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3031 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3036 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3037 if (h
->type
== bfd_link_hash_undefined
)
3041 if (lname
[0] == '?')
3044 if (at
|| lname
[0] == '@')
3046 if (lname
[0] == '@')
3048 if (pe_details
->underscored
)
3051 /* Use memmove rather than strcpy as that
3052 can handle overlapping buffers. */
3053 memmove (lname
, lname
+ 1, strlen (lname
));
3055 kv
= bsearch (&key
, udef_table
, undef_count
,
3056 sizeof (struct key_value
), undef_sort_cmp
);
3059 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3060 if (h
->type
== bfd_link_hash_undefined
)
3065 *strchr (lname
, '@') = 0;
3067 kv
= bsearch (&key
, udef_table
, undef_count
,
3068 sizeof (struct key_value
), undef_sort_cmp
);
3071 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3072 if (h
->type
== bfd_link_hash_undefined
)
3078 strcat (lname
, "@");
3080 kv
= bsearch (&key
, udef_table
, undef_count
,
3081 sizeof (struct key_value
), undef_sort_cmp
);
3085 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3086 if (h
->type
== bfd_link_hash_undefined
)
3090 if (lname
[0] == '_' && pe_details
->underscored
)
3094 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3099 kv
= bsearch (&key
, udef_table
, undef_count
,
3100 sizeof (struct key_value
), undef_sort_cmp
);
3104 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3105 if (h
->type
== bfd_link_hash_undefined
)
3117 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3118 void *inf ATTRIBUTE_UNUSED
)
3120 if (h
->type
== bfd_link_hash_undefined
)
3126 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3128 if (h
->type
== bfd_link_hash_undefined
)
3132 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3133 at
= strchr (udef_table
[undef_count
].key
3134 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3137 udef_table
[undef_count
].oname
= h
->root
.string
;
3144 pe_create_undef_table (void)
3148 /* count undefined symbols */
3150 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3152 /* create and fill the corresponding table */
3153 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3156 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3159 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3163 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3165 lang_input_statement_type
*fake_file
;
3167 fake_file
= lang_add_input_file (name
,
3168 lang_input_file_is_fake_enum
,
3170 fake_file
->the_bfd
= abfd
;
3171 ldlang_add_file (fake_file
);
3173 if (!bfd_link_add_symbols (abfd
, linfo
))
3174 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3178 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3181 def_file_module
*module
;
3182 def_file_import
*imp
;
3184 pe_dll_id_target (bfd_get_target (output_bfd
));
3189 imp
= pe_def_file
->imports
;
3191 pe_create_undef_table ();
3193 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3195 int do_this_dll
= 0;
3197 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3199 if (i
>= pe_def_file
->num_imports
)
3202 dll_filename
= module
->name
;
3203 dll_symname
= xstrdup (module
->name
);
3204 for (j
= 0; dll_symname
[j
]; j
++)
3205 if (!ISALNUM (dll_symname
[j
]))
3206 dll_symname
[j
] = '_';
3208 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3210 def_file_export exp
;
3211 struct bfd_link_hash_entry
*blhe
;
3212 int lead_at
= (*imp
[i
].internal_name
== '@');
3213 /* See if we need this import. */
3214 size_t len
= strlen (imp
[i
].internal_name
);
3215 char *name
= xmalloc (len
+ 2 + 6);
3216 bool include_jmp_stub
= false;
3217 bool is_cdecl
= false;
3218 bool is_undef
= false;
3220 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3224 sprintf (name
, "%s", imp
[i
].internal_name
);
3226 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3228 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3229 false, false, false);
3231 /* Include the jump stub for <sym> only if the <sym>
3233 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3236 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3238 sprintf (name
, "%s%s%s", "__imp_", U (""),
3239 imp
[i
].internal_name
);
3241 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3242 false, false, false);
3244 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3248 include_jmp_stub
= true;
3249 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3252 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3254 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3255 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3256 include_jmp_stub
= true;
3258 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3269 bfd
*ar_head
= make_head (output_bfd
);
3270 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
), linfo
);
3273 exp
.internal_name
= imp
[i
].internal_name
;
3274 exp
.name
= imp
[i
].name
;
3275 exp
.its_name
= imp
[i
].its_name
;
3276 exp
.ordinal
= imp
[i
].ordinal
;
3277 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3278 exp
.flag_private
= 0;
3279 exp
.flag_constant
= 0;
3280 exp
.flag_data
= imp
[i
].data
;
3281 exp
.flag_noname
= exp
.name
? 0 : 1;
3282 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3283 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3288 bfd
*ar_tail
= make_tail (output_bfd
);
3289 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3298 free (udef_table
[undef_count
].key
);
3303 /* We were handed a *.DLL file. Parse it and turn it into a set of
3304 IMPORTS directives in the def file. Return TRUE if the file was
3305 handled, FALSE if not. */
3308 pe_get16 (bfd
*abfd
, int where
)
3312 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3313 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3314 return b
[0] + (b
[1] << 8);
3318 pe_get32 (bfd
*abfd
, int where
)
3322 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3323 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3324 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3330 unsigned char *b
= ptr
;
3332 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3336 pe_implied_import_dll (const char *filename
)
3339 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3340 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3341 bfd_vma exp_funcbase
;
3342 unsigned char *expdata
;
3344 bfd_vma name_rvas
, nexp
;
3345 const char *dllname
;
3346 /* Initialization with start > end guarantees that is_data
3347 will not be set by mistake, and avoids compiler warning. */
3348 bfd_vma data_start
= 1;
3349 bfd_vma data_end
= 0;
3350 bfd_vma rdata_start
= 1;
3351 bfd_vma rdata_end
= 0;
3352 bfd_vma bss_start
= 1;
3353 bfd_vma bss_end
= 0;
3356 /* No, I can't use bfd here. kernel32.dll puts its export table in
3357 the middle of the .rdata section. */
3358 dll
= bfd_openr (filename
, pe_details
->target_name
);
3361 einfo (_("%X%P: open %s: %E\n"), filename
);
3365 track_dependency_files (filename
);
3367 /* PEI dlls seem to be bfd_objects. */
3368 if (!bfd_check_format (dll
, bfd_object
))
3370 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3374 /* Get pe_header, optional header and numbers of directory entries. */
3375 pe_header_offset
= pe_get32 (dll
, 0x3c);
3376 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3377 #ifdef pe_use_x86_64
3378 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3380 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3383 /* No import or export directory entry. */
3384 if (num_entries
< 1)
3387 #ifdef pe_use_x86_64
3388 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3389 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3391 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3392 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3395 /* No export table - nothing to export. */
3396 if (export_size
== 0)
3399 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3400 secptr
= (pe_header_offset
+ 4 + 20 +
3401 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3404 /* Get the rva and size of the export section. */
3405 for (i
= 0; i
< nsections
; i
++)
3408 bfd_vma secptr1
= secptr
+ 40 * i
;
3409 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3410 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3411 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3413 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3414 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3416 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3418 expptr
= fptr
+ (export_rva
- vaddr
);
3419 if (export_rva
+ export_size
> vaddr
+ vsize
)
3420 export_size
= vsize
- (export_rva
- vaddr
);
3425 /* Scan sections and store the base and size of the
3426 data and bss segments in data/base_start/end. */
3427 for (i
= 0; i
< nsections
; i
++)
3429 bfd_vma secptr1
= secptr
+ 40 * i
;
3430 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3431 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3432 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3436 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3437 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3439 if (strcmp(sec_name
,".data") == 0)
3442 data_end
= vaddr
+ vsize
;
3444 if (pe_dll_extra_pe_debug
)
3445 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3446 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3447 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3449 else if (strcmp(sec_name
,".rdata") == 0)
3451 rdata_start
= vaddr
;
3452 rdata_end
= vaddr
+ vsize
;
3454 if (pe_dll_extra_pe_debug
)
3455 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3456 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3457 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3459 else if (strcmp (sec_name
,".bss") == 0)
3462 bss_end
= vaddr
+ vsize
;
3464 if (pe_dll_extra_pe_debug
)
3465 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3466 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3467 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3471 expdata
= xmalloc (export_size
);
3472 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3473 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3474 erva
= (char *) expdata
- export_rva
;
3476 if (pe_def_file
== 0)
3477 pe_def_file
= def_file_empty ();
3479 nexp
= pe_as32 (expdata
+ 24);
3480 name_rvas
= pe_as32 (expdata
+ 32);
3481 exp_funcbase
= pe_as32 (expdata
+ 28);
3483 /* Use internal dll name instead of filename
3484 to enable symbolic dll linking. */
3485 dllname
= erva
+ pe_as32 (expdata
+ 12);
3487 /* Check to see if the dll has already been added to
3488 the definition list and if so return without error.
3489 This avoids multiple symbol definitions. */
3490 if (def_get_module (pe_def_file
, dllname
))
3492 if (pe_dll_extra_pe_debug
)
3493 printf ("%s is already loaded\n", dllname
);
3497 /* This is an optimized version of the insertion loop, which avoids lots of
3498 calls to realloc and memmove from def_file_add_import. */
3499 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3500 erva
+ pe_as32 (erva
+ name_rvas
),
3501 dllname
, 0, NULL
, NULL
)) >= 0)
3503 for (i
= 0; i
< nexp
; i
++)
3505 /* Pointer to the names vector. */
3506 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3507 def_file_import
*imp
;
3508 /* Pointer to the function address vector. */
3509 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3510 /* is_data is true if the address is in the data, rdata or bss
3513 (func_rva
>= data_start
&& func_rva
< data_end
)
3514 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3515 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3517 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3518 dllname
, i
, NULL
, NULL
);
3519 /* Mark symbol type. */
3520 imp
->data
= is_data
;
3522 if (pe_dll_extra_pe_debug
)
3523 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3524 __FUNCTION__
, dllname
, erva
+ name_rva
,
3525 (unsigned long) func_rva
, is_data
? "(data)" : "");
3531 /* Iterate through the list of symbols. */
3532 for (i
= 0; i
< nexp
; i
++)
3534 /* Pointer to the names vector. */
3535 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3536 def_file_import
*imp
;
3537 /* Pointer to the function address vector. */
3538 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3541 /* Skip unwanted symbols, which are
3542 exported in buggy auto-import releases. */
3543 if (! startswith (erva
+ name_rva
, "__nm_"))
3546 /* is_data is true if the address is in the data, rdata or bss
3549 (func_rva
>= data_start
&& func_rva
< data_end
)
3550 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3551 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3553 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3554 dllname
, i
, NULL
, NULL
, &is_dup
);
3555 /* Mark symbol type. */
3557 imp
->data
= is_data
;
3559 if (pe_dll_extra_pe_debug
)
3560 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3561 __FUNCTION__
, dllname
, erva
+ name_rva
,
3562 (unsigned long) func_rva
, is_data
? "(data)" : "");
3570 pe_output_file_set_long_section_names (bfd
*abfd
)
3572 if (pe_use_coff_long_section_names
< 0)
3574 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3575 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3578 /* These are the main functions, called from the emulation. The first
3579 is called after the bfds are read, so we can guess at how much space
3580 we need. The second is called after everything is placed, so we
3581 can put the right values in place. */
3584 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3586 pe_dll_id_target (bfd_get_target (abfd
));
3587 pe_output_file_set_long_section_names (abfd
);
3588 process_def_file_and_drectve (abfd
, info
);
3590 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3592 if (pe_dll_enable_reloc_section
)
3594 build_filler_bfd (0);
3595 pe_output_file_set_long_section_names (filler_bfd
);
3600 generate_edata (abfd
, info
);
3601 build_filler_bfd (1);
3602 pe_output_file_set_long_section_names (filler_bfd
);
3606 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3608 pe_dll_id_target (bfd_get_target (abfd
));
3609 pe_output_file_set_long_section_names (abfd
);
3610 build_filler_bfd (0);
3611 pe_output_file_set_long_section_names (filler_bfd
);
3615 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3617 pe_exe_fill_sections (abfd
, info
);
3621 fill_edata (abfd
, info
);
3622 edata_s
->contents
= edata_d
;
3625 if (bfd_link_dll (info
))
3626 pe_data (abfd
)->dll
= 1;
3630 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3632 pe_dll_id_target (bfd_get_target (abfd
));
3633 pe_output_file_set_long_section_names (abfd
);
3634 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3636 generate_reloc (abfd
, info
);
3639 bfd_set_section_size (reloc_s
, reloc_sz
);
3641 /* Resize the sections. */
3642 lang_reset_memory_regions ();
3643 lang_size_sections (NULL
, true);
3645 /* Redo special stuff. */
3646 ldemul_after_allocation ();
3648 /* Do the assignments again. */
3649 lang_do_assignments (lang_final_phase_enum
);
3652 reloc_s
->contents
= reloc_d
;
3656 pe_bfd_is_dll (bfd
*abfd
)
3658 return (bfd_get_format (abfd
) == bfd_object
3660 && pe_data (abfd
)->dll
);