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 bfd_boolean runtime_pseudp_reloc_v2_init
= FALSE
;
180 autofilter_entry_type
;
184 const char *target_name
;
185 const char *object_target
;
186 unsigned int imagebase_reloc
;
189 bfd_boolean underscored
;
190 const autofilter_entry_type
* autofilter_symbollist
;
194 static const autofilter_entry_type autofilter_symbollist_generic
[] =
196 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
197 /* Entry point symbols. */
198 { STRING_COMMA_LEN ("DllMain") },
199 { STRING_COMMA_LEN ("DllMainCRTStartup") },
200 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
201 /* Runtime pseudo-reloc. */
202 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
203 { STRING_COMMA_LEN ("do_pseudo_reloc") },
207 static const autofilter_entry_type autofilter_symbollist_i386
[] =
209 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
210 /* Entry point symbols, and entry hooks. */
211 { STRING_COMMA_LEN ("cygwin_crt0") },
213 { STRING_COMMA_LEN ("DllMain") },
214 { STRING_COMMA_LEN ("DllEntryPoint") },
215 { STRING_COMMA_LEN ("DllMainCRTStartup") },
216 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
217 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
218 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
220 { STRING_COMMA_LEN ("DllMain@12") },
221 { STRING_COMMA_LEN ("DllEntryPoint@0") },
222 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
223 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
224 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
225 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
226 { STRING_COMMA_LEN ("cygwin_attach_dll") },
228 { STRING_COMMA_LEN ("cygwin_premain0") },
229 { STRING_COMMA_LEN ("cygwin_premain1") },
230 { STRING_COMMA_LEN ("cygwin_premain2") },
231 { STRING_COMMA_LEN ("cygwin_premain3") },
232 /* Runtime pseudo-reloc. */
233 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
234 { STRING_COMMA_LEN ("do_pseudo_reloc") },
235 /* Global vars that should not be exported. */
236 { STRING_COMMA_LEN ("impure_ptr") },
237 { STRING_COMMA_LEN ("_impure_ptr") },
238 { STRING_COMMA_LEN ("_fmode") },
239 { STRING_COMMA_LEN ("environ") },
240 { STRING_COMMA_LEN ("__dso_handle") },
244 #define PE_ARCH_i386 1
246 #define PE_ARCH_mips 3
247 #define PE_ARCH_arm 4
248 #define PE_ARCH_arm_wince 5
250 /* Don't make it constant as underscore mode gets possibly overriden
251 by target or -(no-)leading-underscore option. */
252 static pe_details_type pe_detail_list
[] =
271 autofilter_symbollist_i386
281 autofilter_symbollist_i386
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 ? TRUE
: FALSE
);
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;
677 bfd_boolean resort_needed
;
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. */
749 bfd_boolean would_export
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 bfd_boolean 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
)
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 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1632 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1633 relocs
[i
]->howto
->rightshift
)
1635 #ifdef pe_use_x86_64
1636 case BITS_AND_SHIFT (64, 0):
1637 reloc_data
[total_relocs
].type
= 10;
1641 case BITS_AND_SHIFT (32, 0):
1642 reloc_data
[total_relocs
].type
= 3;
1645 case BITS_AND_SHIFT (16, 0):
1646 reloc_data
[total_relocs
].type
= 2;
1649 case BITS_AND_SHIFT (16, 16):
1650 reloc_data
[total_relocs
].type
= 4;
1651 /* FIXME: we can't know the symbol's right value
1652 yet, but we probably can safely assume that
1653 CE will relocate us in 64k blocks, so leaving
1655 reloc_data
[total_relocs
].extra
= 0;
1658 case BITS_AND_SHIFT (26, 2):
1659 reloc_data
[total_relocs
].type
= 5;
1662 case BITS_AND_SHIFT (24, 2):
1663 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1664 Those ARM_xxx definitions should go in proper
1666 if (relocs
[i
]->howto
->type
== 0
1667 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1668 || relocs
[i
]->howto
->type
== 5)
1669 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1670 that has already been fully processed during a
1671 previous link stage, so ignore it here. */
1675 /* xgettext:c-format */
1676 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1677 relocs
[i
]->howto
->bitsize
);
1683 /* Warning: the allocated symbols are remembered in BFD and
1684 reused later, so don't free them! */
1688 /* At this point, we have total_relocs relocation addresses in
1689 reloc_addresses, which are all suitable for the .reloc section.
1690 We must now create the new sections. */
1691 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1693 for (i
= 0; i
< total_relocs
; i
++)
1695 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1697 if (this_page
!= sec_page
)
1699 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1701 sec_page
= this_page
;
1706 if (reloc_data
[i
].type
== 4)
1710 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1711 reloc_d
= xmalloc (reloc_sz
);
1712 sec_page
= (bfd_vma
) -1;
1714 page_ptr
= (bfd_vma
) -1;
1717 for (i
= 0; i
< total_relocs
; i
++)
1719 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1720 bfd_vma this_page
= (rva
& ~0xfff);
1722 if (this_page
!= sec_page
)
1724 while (reloc_sz
& 3)
1725 reloc_d
[reloc_sz
++] = 0;
1727 if (page_ptr
!= (bfd_vma
) -1)
1728 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1730 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1731 page_ptr
= reloc_sz
;
1733 sec_page
= this_page
;
1737 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1738 reloc_d
+ reloc_sz
);
1741 if (reloc_data
[i
].type
== 4)
1743 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1750 while (reloc_sz
& 3)
1751 reloc_d
[reloc_sz
++] = 0;
1753 if (page_ptr
!= (bfd_vma
) -1)
1754 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1757 /* Given the exiting def_file structure, print out a .DEF file that
1758 corresponds to it. */
1761 quoteput (char *s
, FILE *f
, int needs_quotes
)
1765 for (cp
= s
; *cp
; cp
++)
1780 if (*s
== '"' || *s
== '\\')
1794 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1797 FILE *out
= fopen (pe_out_def_filename
, "w");
1800 /* xgettext:c-format */
1801 einfo (_("%P: can't open output def file %s\n"),
1802 pe_out_def_filename
);
1806 if (pe_def_file
->name
)
1808 if (pe_def_file
->is_dll
)
1809 fprintf (out
, "LIBRARY ");
1811 fprintf (out
, "NAME ");
1813 quoteput (pe_def_file
->name
, out
, 1);
1815 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1817 fprintf (out
, " BASE=0x");
1818 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1820 fprintf (out
, "\n");
1823 if (pe_def_file
->description
)
1825 fprintf (out
, "DESCRIPTION ");
1826 quoteput (pe_def_file
->description
, out
, 1);
1827 fprintf (out
, "\n");
1830 if (pe_def_file
->version_minor
!= -1)
1831 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1832 pe_def_file
->version_minor
);
1833 else if (pe_def_file
->version_major
!= -1)
1834 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1836 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1837 fprintf (out
, "\n");
1839 if (pe_def_file
->stack_commit
!= -1)
1840 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1841 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1842 else if (pe_def_file
->stack_reserve
!= -1)
1843 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1845 if (pe_def_file
->heap_commit
!= -1)
1846 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1847 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1848 else if (pe_def_file
->heap_reserve
!= -1)
1849 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1851 if (pe_def_file
->num_section_defs
> 0)
1853 fprintf (out
, "\nSECTIONS\n\n");
1855 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1858 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1860 if (pe_def_file
->section_defs
[i
].class)
1862 fprintf (out
, " CLASS ");
1863 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1866 if (pe_def_file
->section_defs
[i
].flag_read
)
1867 fprintf (out
, " READ");
1869 if (pe_def_file
->section_defs
[i
].flag_write
)
1870 fprintf (out
, " WRITE");
1872 if (pe_def_file
->section_defs
[i
].flag_execute
)
1873 fprintf (out
, " EXECUTE");
1875 if (pe_def_file
->section_defs
[i
].flag_shared
)
1876 fprintf (out
, " SHARED");
1878 fprintf (out
, "\n");
1882 if (pe_def_file
->num_exports
> 0)
1884 fprintf (out
, "EXPORTS\n");
1886 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1888 def_file_export
*e
= pe_def_file
->exports
+ i
;
1890 quoteput (e
->name
, out
, 0);
1892 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1894 fprintf (out
, " = ");
1895 quoteput (e
->internal_name
, out
, 0);
1898 if (e
->ordinal
!= -1)
1899 fprintf (out
, " @%d", e
->ordinal
);
1901 if (e
->flag_private
)
1902 fprintf (out
, " PRIVATE");
1904 if (e
->flag_constant
)
1905 fprintf (out
, " CONSTANT");
1908 fprintf (out
, " NONAME");
1911 fprintf (out
, " DATA");
1913 fprintf (out
, "\n");
1917 if (pe_def_file
->num_imports
> 0)
1919 fprintf (out
, "\nIMPORTS\n\n");
1921 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1923 def_file_import
*im
= pe_def_file
->imports
+ i
;
1926 if (im
->internal_name
1927 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1929 quoteput (im
->internal_name
, out
, 0);
1930 fprintf (out
, " = ");
1933 quoteput (im
->module
->name
, out
, 0);
1937 quoteput (im
->name
, out
, 0);
1939 fprintf (out
, "%d", im
->ordinal
);
1943 fprintf (out
, " == ");
1944 quoteput (im
->its_name
, out
, 0);
1947 fprintf (out
, "\n");
1952 fprintf (out
, _("; no contents available\n"));
1954 if (fclose (out
) == EOF
)
1955 /* xgettext:c-format */
1956 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1959 /* Generate the import library. */
1961 static asymbol
**symtab
;
1964 static const char *dll_filename
;
1965 static char *dll_symname
;
1967 #define UNDSEC bfd_und_section_ptr
1970 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1975 sec
= bfd_make_section_old_way (abfd
, name
);
1976 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1977 bfd_set_section_alignment (sec
, align
);
1978 /* Remember to undo this before trying to link internally! */
1979 sec
->output_section
= sec
;
1981 sym
= bfd_make_empty_symbol (abfd
);
1982 symtab
[symptr
++] = sym
;
1983 sym
->name
= sec
->name
;
1985 sym
->flags
= BSF_LOCAL
;
1992 quick_symbol (bfd
*abfd
,
2001 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
2006 sym
= bfd_make_empty_symbol (abfd
);
2011 symtab
[symptr
++] = sym
;
2014 static arelent
*reltab
= 0;
2015 static int relcount
= 0, relsize
= 0;
2018 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2020 if (relcount
>= relsize
- 1)
2024 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2026 reltab
= xmalloc (relsize
* sizeof (arelent
));
2028 reltab
[relcount
].address
= address
;
2029 reltab
[relcount
].addend
= 0;
2030 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2031 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2036 save_relocs (asection
*sec
)
2040 sec
->relocation
= reltab
;
2041 sec
->reloc_count
= relcount
;
2042 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2043 for (i
= 0; i
< relcount
; i
++)
2044 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2045 sec
->orelocation
[relcount
] = 0;
2046 sec
->flags
|= SEC_RELOC
;
2048 relcount
= relsize
= 0;
2051 /* .section .idata$2
2052 .global __head_my_dll
2069 make_head (bfd
*parent
)
2071 asection
*id2
, *id5
, *id4
;
2072 unsigned char *d2
, *d5
, *d4
;
2076 oname
= xmalloc (20);
2077 sprintf (oname
, "d%06d.o", tmp_seq
);
2080 abfd
= bfd_create (oname
, parent
);
2081 bfd_find_target (pe_details
->object_target
, abfd
);
2082 bfd_make_writable (abfd
);
2084 bfd_set_format (abfd
, bfd_object
);
2085 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2088 symtab
= xmalloc (6 * sizeof (asymbol
*));
2089 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2090 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2091 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2092 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2093 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2095 /* OK, pay attention here. I got confused myself looking back at
2096 it. We create a four-byte section to mark the beginning of the
2097 list, and we include an offset of 4 in the section, so that the
2098 pointer to the list points to the *end* of this section, which is
2099 the start of the list of sections from other objects. */
2101 bfd_set_section_size (id2
, 20);
2105 if (pe_use_nul_prefixed_import_tables
)
2106 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2107 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2108 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2109 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2112 if (pe_use_nul_prefixed_import_tables
)
2113 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2115 bfd_set_section_size (id5
, 0);
2116 d5
= xmalloc (PE_IDATA5_SIZE
);
2118 memset (d5
, 0, PE_IDATA5_SIZE
);
2119 if (pe_use_nul_prefixed_import_tables
)
2120 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2122 bfd_set_section_size (id4
, 0);
2123 d4
= xmalloc (PE_IDATA4_SIZE
);
2125 memset (d4
, 0, PE_IDATA4_SIZE
);
2127 bfd_set_symtab (abfd
, symtab
, symptr
);
2129 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2130 if (pe_use_nul_prefixed_import_tables
)
2132 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2133 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2137 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2138 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2141 bfd_make_readable (abfd
);
2145 /* .section .idata$4
2152 .global __my_dll_iname
2157 make_tail (bfd
*parent
)
2159 asection
*id4
, *id5
, *id7
;
2160 unsigned char *d4
, *d5
, *d7
;
2165 oname
= xmalloc (20);
2166 sprintf (oname
, "d%06d.o", tmp_seq
);
2169 abfd
= bfd_create (oname
, parent
);
2170 bfd_find_target (pe_details
->object_target
, abfd
);
2171 bfd_make_writable (abfd
);
2173 bfd_set_format (abfd
, bfd_object
);
2174 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2177 symtab
= xmalloc (5 * sizeof (asymbol
*));
2178 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2179 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2180 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2181 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2183 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2184 d4
= xmalloc (PE_IDATA4_SIZE
);
2186 memset (d4
, 0, PE_IDATA4_SIZE
);
2188 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2189 d5
= xmalloc (PE_IDATA5_SIZE
);
2191 memset (d5
, 0, PE_IDATA5_SIZE
);
2193 len
= strlen (dll_filename
) + 1;
2196 bfd_set_section_size (id7
, len
);
2199 strcpy ((char *) d7
, dll_filename
);
2200 /* If len was odd, the above
2201 strcpy leaves behind an undefined byte. That is harmless,
2202 but we set it to 0 just so the binary dumps are pretty. */
2205 bfd_set_symtab (abfd
, symtab
, symptr
);
2207 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2208 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2209 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2211 bfd_make_readable (abfd
);
2217 .global ___imp_function
2218 .global __imp__function
2220 jmp *__imp__function:
2234 .asciz "function" xlate? (add underscore, kill at) */
2236 static const unsigned char jmp_ix86_bytes
[] =
2238 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2246 .dw __imp_function */
2248 static const unsigned char jmp_sh_bytes
[] =
2250 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2254 lui $t0,<high:__imp_function>
2255 lw $t0,<low:__imp_function>
2259 static const unsigned char jmp_mips_bytes
[] =
2261 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2262 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2265 static const unsigned char jmp_arm_bytes
[] =
2267 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2268 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2274 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2276 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2277 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2281 const unsigned char *jmp_bytes
= NULL
;
2282 int jmp_byte_count
= 0;
2284 /* Include the jump stub section only if it is needed. A jump
2285 stub is needed if the symbol being imported <sym> is a function
2286 symbol and there is at least one undefined reference to that
2287 symbol. In other words, if all the import references to <sym> are
2288 explicitly through _declspec(dllimport) then the jump stub is not
2290 if (include_jmp_stub
)
2292 switch (pe_details
->pe_arch
)
2295 jmp_bytes
= jmp_ix86_bytes
;
2296 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2299 jmp_bytes
= jmp_sh_bytes
;
2300 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2303 jmp_bytes
= jmp_mips_bytes
;
2304 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2307 case PE_ARCH_arm_wince
:
2308 jmp_bytes
= jmp_arm_bytes
;
2309 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2316 oname
= xmalloc (20);
2317 sprintf (oname
, "d%06d.o", tmp_seq
);
2320 abfd
= bfd_create (oname
, parent
);
2321 bfd_find_target (pe_details
->object_target
, abfd
);
2322 bfd_make_writable (abfd
);
2324 bfd_set_format (abfd
, bfd_object
);
2325 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2328 symtab
= xmalloc (12 * sizeof (asymbol
*));
2330 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2331 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2332 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2333 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2334 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2336 if (*exp
->internal_name
== '@')
2338 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2340 if (include_jmp_stub
)
2341 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2342 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2344 /* Fastcall applies only to functions,
2345 so no need for auto-import symbol. */
2349 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2351 if (include_jmp_stub
)
2352 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2354 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2356 /* Symbol to reference ord/name of imported
2357 data symbol, used to implement auto-import. */
2359 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2362 if (pe_dll_compat_implib
)
2363 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2366 if (include_jmp_stub
)
2368 bfd_set_section_size (tx
, jmp_byte_count
);
2369 td
= xmalloc (jmp_byte_count
);
2371 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2373 switch (pe_details
->pe_arch
)
2376 #ifdef pe_use_x86_64
2377 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2379 /* Mark this object as SAFESEH compatible. */
2380 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2382 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2386 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2389 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2390 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2391 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2394 case PE_ARCH_arm_wince
:
2395 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2403 bfd_set_section_size (tx
, 0);
2405 bfd_set_section_size (id7
, 4);
2409 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2412 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2413 d5
= xmalloc (PE_IDATA5_SIZE
);
2415 memset (d5
, 0, PE_IDATA5_SIZE
);
2417 if (exp
->flag_noname
)
2419 d5
[0] = exp
->ordinal
;
2420 d5
[1] = exp
->ordinal
>> 8;
2421 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2425 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2429 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2430 d4
= xmalloc (PE_IDATA4_SIZE
);
2432 memset (d4
, 0, PE_IDATA4_SIZE
);
2434 if (exp
->flag_noname
)
2436 d4
[0] = exp
->ordinal
;
2437 d4
[1] = exp
->ordinal
>> 8;
2438 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2442 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2446 if (exp
->flag_noname
)
2449 bfd_set_section_size (id6
, 0);
2455 /* { short, asciz } */
2457 len
= 2 + strlen (exp
->its_name
) + 1;
2459 len
= 2 + strlen (exp
->name
) + 1;
2462 bfd_set_section_size (id6
, len
);
2465 memset (d6
, 0, len
);
2467 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2468 contains an invalid value (-1). */
2469 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2474 strcpy ((char*) d6
+ 2, exp
->its_name
);
2476 strcpy ((char *) d6
+ 2, exp
->name
);
2479 bfd_set_symtab (abfd
, symtab
, symptr
);
2481 if (include_jmp_stub
)
2482 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2483 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2484 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2485 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2486 if (!exp
->flag_noname
)
2487 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2489 bfd_make_readable (abfd
);
2494 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2496 /* Name thunks go to idata$4. */
2502 oname
= xmalloc (20);
2503 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2506 abfd
= bfd_create (oname
, parent
);
2507 bfd_find_target (pe_details
->object_target
, abfd
);
2508 bfd_make_writable (abfd
);
2510 bfd_set_format (abfd
, bfd_object
);
2511 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2514 symtab
= xmalloc (3 * sizeof (asymbol
*));
2515 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2516 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2517 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2519 /* We need space for the real thunk and for the null terminator. */
2520 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2521 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2523 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2524 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2527 bfd_set_symtab (abfd
, symtab
, symptr
);
2529 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2531 bfd_make_readable (abfd
);
2536 make_import_fixup_mark (arelent
*rel
, char *name
)
2538 /* We convert reloc to symbol, for later reference. */
2539 static unsigned int counter
;
2540 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2541 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2542 struct bfd_link_hash_entry
*bh
;
2543 char *fixup_name
, buf
[26];
2546 /* "name" buffer has space before the symbol name for prefixes. */
2547 sprintf (buf
, "__fu%d_", counter
++);
2548 prefix_len
= strlen (buf
);
2549 fixup_name
= name
- prefix_len
;
2550 memcpy (fixup_name
, buf
, prefix_len
);
2553 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2554 current_sec
, /* sym->section, */
2555 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2557 return bh
->root
.string
;
2560 /* .section .idata$2
2561 .rva __nm_thnk_SYM (singleton thunk with name of func)
2564 .rva __my_dll_iname (name of dll)
2565 .rva __fuNN_SYM (pointer to reference (address) in text) */
2568 make_import_fixup_entry (const char *name
,
2569 const char *fixup_name
,
2570 const char *symname
,
2578 oname
= xmalloc (20);
2579 sprintf (oname
, "fu%06d.o", tmp_seq
);
2582 abfd
= bfd_create (oname
, parent
);
2583 bfd_find_target (pe_details
->object_target
, abfd
);
2584 bfd_make_writable (abfd
);
2586 bfd_set_format (abfd
, bfd_object
);
2587 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2590 symtab
= xmalloc (6 * sizeof (asymbol
*));
2591 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2593 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2594 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2595 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2597 bfd_set_section_size (id2
, 20);
2602 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2603 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2604 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2607 bfd_set_symtab (abfd
, symtab
, symptr
);
2609 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2611 bfd_make_readable (abfd
);
2615 /* .section .rdata_runtime_pseudo_reloc
2617 .rva __fuNN_SYM (pointer to reference (address) in text) */
2620 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2621 const char *fixup_name
,
2622 bfd_vma addend ATTRIBUTE_UNUSED
,
2627 unsigned char *rt_rel_d
;
2632 oname
= xmalloc (20);
2633 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2636 abfd
= bfd_create (oname
, parent
);
2637 bfd_find_target (pe_details
->object_target
, abfd
);
2638 bfd_make_writable (abfd
);
2640 bfd_set_format (abfd
, bfd_object
);
2641 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2643 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2645 if (runtime_pseudp_reloc_v2_init
)
2646 size
= 3 * sizeof (asymbol
*);
2648 size
= 6 * sizeof (asymbol
*);
2651 size
= 2 * sizeof (asymbol
*);
2654 symtab
= xmalloc (size
);
2657 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2659 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2661 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2664 if (!runtime_pseudp_reloc_v2_init
)
2667 runtime_pseudp_reloc_v2_init
= TRUE
;
2670 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2672 bfd_set_section_size (rt_rel
, size
);
2673 rt_rel_d
= xmalloc (size
);
2674 rt_rel
->contents
= rt_rel_d
;
2675 memset (rt_rel_d
, 0, size
);
2676 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2677 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2678 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2680 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2681 save_relocs (rt_rel
);
2683 bfd_set_symtab (abfd
, symtab
, symptr
);
2685 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2689 bfd_set_section_size (rt_rel
, 8);
2690 rt_rel_d
= xmalloc (8);
2691 rt_rel
->contents
= rt_rel_d
;
2692 memset (rt_rel_d
, 0, 8);
2694 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2695 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2697 save_relocs (rt_rel
);
2699 bfd_set_symtab (abfd
, symtab
, symptr
);
2701 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2704 bfd_make_readable (abfd
);
2709 .rva __pei386_runtime_relocator */
2712 pe_create_runtime_relocator_reference (bfd
*parent
)
2714 asection
*extern_rt_rel
;
2715 unsigned char *extern_rt_rel_d
;
2719 oname
= xmalloc (20);
2720 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2723 abfd
= bfd_create (oname
, parent
);
2724 bfd_find_target (pe_details
->object_target
, abfd
);
2725 bfd_make_writable (abfd
);
2727 bfd_set_format (abfd
, bfd_object
);
2728 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2731 symtab
= xmalloc (2 * sizeof (asymbol
*));
2732 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2734 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2737 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2738 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2739 extern_rt_rel
->contents
= extern_rt_rel_d
;
2741 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2742 save_relocs (extern_rt_rel
);
2744 bfd_set_symtab (abfd
, symtab
, symptr
);
2746 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2748 bfd_make_readable (abfd
);
2753 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2754 const char *symname
)
2756 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2759 /* This is the original implementation of the auto-import feature, which
2760 primarily relied on the OS loader to patch things up with some help
2761 from the pseudo-relocator to overcome the main limitation. See the
2762 comment at the beginning of the file for an overview of the feature. */
2763 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2765 struct bfd_link_hash_entry
*name_thunk_sym
;
2766 /* name buffer is allocated with space at beginning for prefixes. */
2767 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2768 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2769 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2771 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2773 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2774 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2776 /* If we ever use autoimport, we have to cast text section writable. */
2777 config
.text_read_only
= FALSE
;
2778 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2781 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2783 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2784 link_info
.output_bfd
);
2785 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2789 /* In the original implementation, the pseudo-relocator was only used when
2790 the addend was not null. In the new implementation, the OS loader is
2791 completely bypassed and the pseudo-relocator does the entire work. */
2792 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2793 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2795 if (pe_dll_extra_pe_debug
)
2796 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2797 fixup_name
, (int) addend
);
2799 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2800 link_info
.output_bfd
);
2801 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2803 if (runtime_pseudo_relocs_created
++ == 0)
2805 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2806 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2810 else if (addend
!= 0)
2811 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2812 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2816 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2825 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2826 dll_symname
= xstrdup (dll_filename
);
2827 for (i
= 0; dll_symname
[i
]; i
++)
2828 if (!ISALNUM (dll_symname
[i
]))
2829 dll_symname
[i
] = '_';
2831 unlink_if_ordinary (impfilename
);
2833 outarch
= bfd_openw (impfilename
, 0);
2837 /* xgettext:c-format */
2838 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2843 /* xgettext:c-format */
2844 info_msg (_("Creating library file: %s\n"), impfilename
);
2846 bfd_set_format (outarch
, bfd_archive
);
2847 outarch
->has_armap
= 1;
2849 /* Work out a reasonable size of things to put onto one line. */
2850 ar_head
= make_head (outarch
);
2852 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2853 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2855 /* Iterate the exclude list. */
2856 struct exclude_list_struct
*ex
;
2858 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2860 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2862 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2864 /* If it matched, we must open a fresh BFD for it (the original
2865 input BFD is still needed for the DLL's final link) and add
2866 it into the archive member chain. */
2869 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2870 ? bfd_get_filename (ibfd
->my_archive
)
2871 : bfd_get_filename (ibfd
), NULL
);
2874 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2877 if (ibfd
->my_archive
)
2879 /* Must now iterate through archive until we find the
2880 required member. A minor shame that we'll open the
2881 archive once per member that we require from it, and
2882 leak those archive bfds rather than reuse them. */
2883 bfd
*arbfd
= newbfd
;
2884 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2886 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2887 bfd_get_filename (ibfd
->my_archive
),
2888 bfd_get_filename (ibfd
));
2892 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2894 if (filename_cmp (bfd_get_filename (newbfd
),
2895 bfd_get_filename (ibfd
)) == 0)
2900 einfo (_("%X%P: %s(%s): can't find member in archive"),
2901 bfd_get_filename (ibfd
->my_archive
),
2902 bfd_get_filename (ibfd
));
2906 newbfd
->archive_next
= head
;
2911 for (i
= 0; i
< def
->num_exports
; i
++)
2913 /* The import library doesn't know about the internal name. */
2914 char *internal
= def
->exports
[i
].internal_name
;
2917 /* Don't add PRIVATE entries to import lib. */
2918 if (pe_def_file
->exports
[i
].flag_private
)
2921 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2923 /* PR 19803: If a symbol has been discard due to garbage
2924 collection then do not create any exports for it. */
2926 struct coff_link_hash_entry
*h
;
2928 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2929 FALSE
, FALSE
, FALSE
);
2931 /* If the symbol is hidden and undefined then it
2932 has been swept up by garbage collection. */
2933 && h
->symbol_class
== C_HIDDEN
2934 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2937 /* If necessary, check with an underscore prefix as well. */
2938 if (pe_details
->underscored
&& internal
[0] != '@')
2942 name
= xmalloc (strlen (internal
) + 2);
2943 sprintf (name
, "_%s", internal
);
2945 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2946 FALSE
, FALSE
, FALSE
);
2950 /* If the symbol is hidden and undefined then it
2951 has been swept up by garbage collection. */
2952 && h
->symbol_class
== C_HIDDEN
2953 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2958 n
= make_one (def
->exports
+ i
, outarch
,
2959 ! (def
->exports
+ i
)->flag_data
);
2960 n
->archive_next
= head
;
2962 def
->exports
[i
].internal_name
= internal
;
2965 ar_tail
= make_tail (outarch
);
2967 if (ar_head
== NULL
|| ar_tail
== NULL
)
2970 /* Now stick them all into the archive. */
2971 ar_head
->archive_next
= head
;
2972 ar_tail
->archive_next
= ar_head
;
2975 if (! bfd_set_archive_head (outarch
, head
))
2976 einfo ("%X%P: bfd_set_archive_head: %E\n");
2978 if (! bfd_close (outarch
))
2979 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
2981 while (head
!= NULL
)
2983 bfd
*n
= head
->archive_next
;
2989 static int undef_count
= 0;
2997 static struct key_value
*udef_table
;
2999 static int undef_sort_cmp (const void *l1
, const void *r1
)
3001 const struct key_value
*l
= l1
;
3002 const struct key_value
*r
= r1
;
3004 return strcmp (l
->key
, r
->key
);
3007 static struct bfd_link_hash_entry
*
3008 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3010 struct bfd_link_hash_entry
*h
= NULL
;
3011 struct key_value
*kv
;
3012 struct key_value key
;
3013 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3015 strcpy (lname
, name
);
3017 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3022 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3027 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3028 if (h
->type
== bfd_link_hash_undefined
)
3032 if (lname
[0] == '?')
3035 if (at
|| lname
[0] == '@')
3037 if (lname
[0] == '@')
3039 if (pe_details
->underscored
)
3042 /* Use memmove rather than strcpy as that
3043 can handle overlapping buffers. */
3044 memmove (lname
, lname
+ 1, strlen (lname
));
3046 kv
= bsearch (&key
, udef_table
, undef_count
,
3047 sizeof (struct key_value
), undef_sort_cmp
);
3050 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3051 if (h
->type
== bfd_link_hash_undefined
)
3056 *strchr (lname
, '@') = 0;
3058 kv
= bsearch (&key
, udef_table
, undef_count
,
3059 sizeof (struct key_value
), undef_sort_cmp
);
3062 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3063 if (h
->type
== bfd_link_hash_undefined
)
3069 strcat (lname
, "@");
3071 kv
= bsearch (&key
, udef_table
, undef_count
,
3072 sizeof (struct key_value
), undef_sort_cmp
);
3076 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3077 if (h
->type
== bfd_link_hash_undefined
)
3081 if (lname
[0] == '_' && pe_details
->underscored
)
3085 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3090 kv
= bsearch (&key
, udef_table
, undef_count
,
3091 sizeof (struct key_value
), undef_sort_cmp
);
3095 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3096 if (h
->type
== bfd_link_hash_undefined
)
3108 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3109 void *inf ATTRIBUTE_UNUSED
)
3111 if (h
->type
== bfd_link_hash_undefined
)
3117 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3119 if (h
->type
== bfd_link_hash_undefined
)
3123 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3124 at
= strchr (udef_table
[undef_count
].key
3125 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3128 udef_table
[undef_count
].oname
= h
->root
.string
;
3135 pe_create_undef_table (void)
3139 /* count undefined symbols */
3141 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3143 /* create and fill the corresponding table */
3144 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3147 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3150 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3154 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3156 lang_input_statement_type
*fake_file
;
3158 fake_file
= lang_add_input_file (name
,
3159 lang_input_file_is_fake_enum
,
3161 fake_file
->the_bfd
= abfd
;
3162 ldlang_add_file (fake_file
);
3164 if (!bfd_link_add_symbols (abfd
, linfo
))
3165 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3169 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3172 def_file_module
*module
;
3173 def_file_import
*imp
;
3175 pe_dll_id_target (bfd_get_target (output_bfd
));
3180 imp
= pe_def_file
->imports
;
3182 pe_create_undef_table ();
3184 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3186 int do_this_dll
= 0;
3188 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3190 if (i
>= pe_def_file
->num_imports
)
3193 dll_filename
= module
->name
;
3194 dll_symname
= xstrdup (module
->name
);
3195 for (j
= 0; dll_symname
[j
]; j
++)
3196 if (!ISALNUM (dll_symname
[j
]))
3197 dll_symname
[j
] = '_';
3199 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3201 def_file_export exp
;
3202 struct bfd_link_hash_entry
*blhe
;
3203 int lead_at
= (*imp
[i
].internal_name
== '@');
3204 /* See if we need this import. */
3205 size_t len
= strlen (imp
[i
].internal_name
);
3206 char *name
= xmalloc (len
+ 2 + 6);
3207 bfd_boolean include_jmp_stub
= FALSE
;
3208 bfd_boolean is_cdecl
= FALSE
;
3209 bfd_boolean is_undef
= FALSE
;
3211 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3215 sprintf (name
, "%s", imp
[i
].internal_name
);
3217 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3219 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3220 FALSE
, FALSE
, FALSE
);
3222 /* Include the jump stub for <sym> only if the <sym>
3224 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3227 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3229 sprintf (name
, "%s%s%s", "__imp_", U (""),
3230 imp
[i
].internal_name
);
3232 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3233 FALSE
, FALSE
, FALSE
);
3235 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3239 include_jmp_stub
= TRUE
;
3240 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3243 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3245 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3246 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3247 include_jmp_stub
= TRUE
;
3249 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3260 bfd
*ar_head
= make_head (output_bfd
);
3261 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
), linfo
);
3264 exp
.internal_name
= imp
[i
].internal_name
;
3265 exp
.name
= imp
[i
].name
;
3266 exp
.its_name
= imp
[i
].its_name
;
3267 exp
.ordinal
= imp
[i
].ordinal
;
3268 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3269 exp
.flag_private
= 0;
3270 exp
.flag_constant
= 0;
3271 exp
.flag_data
= imp
[i
].data
;
3272 exp
.flag_noname
= exp
.name
? 0 : 1;
3273 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3274 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3279 bfd
*ar_tail
= make_tail (output_bfd
);
3280 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3289 free (udef_table
[undef_count
].key
);
3294 /* We were handed a *.DLL file. Parse it and turn it into a set of
3295 IMPORTS directives in the def file. Return TRUE if the file was
3296 handled, FALSE if not. */
3299 pe_get16 (bfd
*abfd
, int where
)
3303 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3304 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3305 return b
[0] + (b
[1] << 8);
3309 pe_get32 (bfd
*abfd
, int where
)
3313 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3314 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3315 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3321 unsigned char *b
= ptr
;
3323 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3327 pe_implied_import_dll (const char *filename
)
3330 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3331 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3332 bfd_vma exp_funcbase
;
3333 unsigned char *expdata
;
3335 bfd_vma name_rvas
, nexp
;
3336 const char *dllname
;
3337 /* Initialization with start > end guarantees that is_data
3338 will not be set by mistake, and avoids compiler warning. */
3339 bfd_vma data_start
= 1;
3340 bfd_vma data_end
= 0;
3341 bfd_vma rdata_start
= 1;
3342 bfd_vma rdata_end
= 0;
3343 bfd_vma bss_start
= 1;
3344 bfd_vma bss_end
= 0;
3347 /* No, I can't use bfd here. kernel32.dll puts its export table in
3348 the middle of the .rdata section. */
3349 dll
= bfd_openr (filename
, pe_details
->target_name
);
3352 einfo (_("%X%P: open %s: %E\n"), filename
);
3356 track_dependency_files (filename
);
3358 /* PEI dlls seem to be bfd_objects. */
3359 if (!bfd_check_format (dll
, bfd_object
))
3361 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3365 /* Get pe_header, optional header and numbers of directory entries. */
3366 pe_header_offset
= pe_get32 (dll
, 0x3c);
3367 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3368 #ifdef pe_use_x86_64
3369 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3371 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3374 /* No import or export directory entry. */
3375 if (num_entries
< 1)
3378 #ifdef pe_use_x86_64
3379 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3380 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3382 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3383 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3386 /* No export table - nothing to export. */
3387 if (export_size
== 0)
3390 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3391 secptr
= (pe_header_offset
+ 4 + 20 +
3392 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3395 /* Get the rva and size of the export section. */
3396 for (i
= 0; i
< nsections
; i
++)
3399 bfd_vma secptr1
= secptr
+ 40 * i
;
3400 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3401 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3402 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3404 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3405 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3407 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3409 expptr
= fptr
+ (export_rva
- vaddr
);
3410 if (export_rva
+ export_size
> vaddr
+ vsize
)
3411 export_size
= vsize
- (export_rva
- vaddr
);
3416 /* Scan sections and store the base and size of the
3417 data and bss segments in data/base_start/end. */
3418 for (i
= 0; i
< nsections
; i
++)
3420 bfd_vma secptr1
= secptr
+ 40 * i
;
3421 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3422 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3423 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3427 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3428 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3430 if (strcmp(sec_name
,".data") == 0)
3433 data_end
= vaddr
+ vsize
;
3435 if (pe_dll_extra_pe_debug
)
3436 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3437 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3438 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3440 else if (strcmp(sec_name
,".rdata") == 0)
3442 rdata_start
= vaddr
;
3443 rdata_end
= vaddr
+ vsize
;
3445 if (pe_dll_extra_pe_debug
)
3446 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3447 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3448 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3450 else if (strcmp (sec_name
,".bss") == 0)
3453 bss_end
= vaddr
+ vsize
;
3455 if (pe_dll_extra_pe_debug
)
3456 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3457 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3458 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3462 expdata
= xmalloc (export_size
);
3463 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3464 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3465 erva
= (char *) expdata
- export_rva
;
3467 if (pe_def_file
== 0)
3468 pe_def_file
= def_file_empty ();
3470 nexp
= pe_as32 (expdata
+ 24);
3471 name_rvas
= pe_as32 (expdata
+ 32);
3472 exp_funcbase
= pe_as32 (expdata
+ 28);
3474 /* Use internal dll name instead of filename
3475 to enable symbolic dll linking. */
3476 dllname
= erva
+ pe_as32 (expdata
+ 12);
3478 /* Check to see if the dll has already been added to
3479 the definition list and if so return without error.
3480 This avoids multiple symbol definitions. */
3481 if (def_get_module (pe_def_file
, dllname
))
3483 if (pe_dll_extra_pe_debug
)
3484 printf ("%s is already loaded\n", dllname
);
3488 /* This is an optimized version of the insertion loop, which avoids lots of
3489 calls to realloc and memmove from def_file_add_import. */
3490 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3491 erva
+ pe_as32 (erva
+ name_rvas
),
3492 dllname
, 0, NULL
, NULL
)) >= 0)
3494 for (i
= 0; i
< nexp
; i
++)
3496 /* Pointer to the names vector. */
3497 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3498 def_file_import
*imp
;
3499 /* Pointer to the function address vector. */
3500 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3501 /* is_data is true if the address is in the data, rdata or bss
3504 (func_rva
>= data_start
&& func_rva
< data_end
)
3505 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3506 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3508 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3509 dllname
, i
, NULL
, NULL
);
3510 /* Mark symbol type. */
3511 imp
->data
= is_data
;
3513 if (pe_dll_extra_pe_debug
)
3514 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3515 __FUNCTION__
, dllname
, erva
+ name_rva
,
3516 (unsigned long) func_rva
, is_data
? "(data)" : "");
3522 /* Iterate through the list of symbols. */
3523 for (i
= 0; i
< nexp
; i
++)
3525 /* Pointer to the names vector. */
3526 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3527 def_file_import
*imp
;
3528 /* Pointer to the function address vector. */
3529 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3532 /* Skip unwanted symbols, which are
3533 exported in buggy auto-import releases. */
3534 if (! startswith (erva
+ name_rva
, "__nm_"))
3537 /* is_data is true if the address is in the data, rdata or bss
3540 (func_rva
>= data_start
&& func_rva
< data_end
)
3541 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3542 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3544 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3545 dllname
, i
, NULL
, NULL
, &is_dup
);
3546 /* Mark symbol type. */
3548 imp
->data
= is_data
;
3550 if (pe_dll_extra_pe_debug
)
3551 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3552 __FUNCTION__
, dllname
, erva
+ name_rva
,
3553 (unsigned long) func_rva
, is_data
? "(data)" : "");
3561 pe_output_file_set_long_section_names (bfd
*abfd
)
3563 if (pe_use_coff_long_section_names
< 0)
3565 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3566 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3569 /* These are the main functions, called from the emulation. The first
3570 is called after the bfds are read, so we can guess at how much space
3571 we need. The second is called after everything is placed, so we
3572 can put the right values in place. */
3575 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3577 pe_dll_id_target (bfd_get_target (abfd
));
3578 pe_output_file_set_long_section_names (abfd
);
3579 process_def_file_and_drectve (abfd
, info
);
3581 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3583 if (pe_dll_enable_reloc_section
)
3585 build_filler_bfd (0);
3586 pe_output_file_set_long_section_names (filler_bfd
);
3591 generate_edata (abfd
, info
);
3592 build_filler_bfd (1);
3593 pe_output_file_set_long_section_names (filler_bfd
);
3597 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3599 pe_dll_id_target (bfd_get_target (abfd
));
3600 pe_output_file_set_long_section_names (abfd
);
3601 build_filler_bfd (0);
3602 pe_output_file_set_long_section_names (filler_bfd
);
3606 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3608 pe_exe_fill_sections (abfd
, info
);
3612 fill_edata (abfd
, info
);
3613 edata_s
->contents
= edata_d
;
3616 if (bfd_link_dll (info
))
3617 pe_data (abfd
)->dll
= 1;
3621 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3623 pe_dll_id_target (bfd_get_target (abfd
));
3624 pe_output_file_set_long_section_names (abfd
);
3625 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3627 generate_reloc (abfd
, info
);
3630 bfd_set_section_size (reloc_s
, reloc_sz
);
3632 /* Resize the sections. */
3633 lang_reset_memory_regions ();
3634 lang_size_sections (NULL
, TRUE
);
3636 /* Redo special stuff. */
3637 ldemul_after_allocation ();
3639 /* Do the assignments again. */
3640 lang_do_assignments (lang_final_phase_enum
);
3643 reloc_s
->contents
= reloc_d
;
3647 pe_bfd_is_dll (bfd
*abfd
)
3649 return (bfd_get_format (abfd
) == bfd_object
3651 && pe_data (abfd
)->dll
);