1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2022 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 ("libucrt") },
352 { STRING_COMMA_LEN ("libucrtbase") },
356 /* Regardless of the suffix issue mentioned above, we must ensure that
357 we do not falsely match on a leading substring, such as when libtool
358 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
359 This routine ensures that the leading part of the name matches and that
360 it is followed by only an optional version suffix and a file extension,
361 returning zero if so or -1 if not. */
362 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
364 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
367 libname
+= afptr
->len
;
369 /* Be liberal in interpreting what counts as a version suffix; we
370 accept anything that has a dash to separate it from the name and
371 begins with a digit. */
372 if (libname
[0] == '-')
374 if (!ISDIGIT (*++libname
))
376 /* Ensure the filename has an extension. */
377 while (*++libname
!= '.')
381 else if (libname
[0] != '.')
387 static const autofilter_entry_type autofilter_objlist
[] =
389 { STRING_COMMA_LEN ("crt0.o") },
390 { STRING_COMMA_LEN ("crt1.o") },
391 { STRING_COMMA_LEN ("crt2.o") },
392 { STRING_COMMA_LEN ("dllcrt1.o") },
393 { STRING_COMMA_LEN ("dllcrt2.o") },
394 { STRING_COMMA_LEN ("gcrt0.o") },
395 { STRING_COMMA_LEN ("gcrt1.o") },
396 { STRING_COMMA_LEN ("gcrt2.o") },
397 { STRING_COMMA_LEN ("crtbegin.o") },
398 { STRING_COMMA_LEN ("crtend.o") },
402 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
404 /* _imp_ is treated specially, as it is always underscored. */
405 /* { STRING_COMMA_LEN ("_imp_") }, */
406 /* Don't export some c++ symbols. */
407 { STRING_COMMA_LEN ("__rtti_") },
408 { STRING_COMMA_LEN ("__builtin_") },
409 /* Don't re-export auto-imported symbols. */
410 { STRING_COMMA_LEN ("__nm_") },
411 /* Don't export symbols specifying internal DLL layout. */
412 { STRING_COMMA_LEN ("_head_") },
413 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
414 /* Don't export section labels or artificial symbols
416 { STRING_COMMA_LEN (".") },
420 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
422 { STRING_COMMA_LEN ("_iname") },
423 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
427 #define U(str) (pe_details->underscored ? "_" str : str)
430 pe_dll_id_target (const char *target
)
434 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
435 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
436 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
438 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
440 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
443 pe_detail_list
[i
].underscored
= u
!= 0;
444 pe_details
= pe_detail_list
+ i
;
445 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
448 einfo (_("%X%P: unsupported PEI architecture: %s\n"), target
);
452 /* Helper functions for qsort. Relocs must be sorted so that we can write
453 them out by pages. */
465 reloc_sort (const void *va
, const void *vb
)
467 const reloc_data_type
*a
= (const reloc_data_type
*) va
;
468 const reloc_data_type
*b
= (const reloc_data_type
*) vb
;
482 pe_export_sort (const void *va
, const void *vb
)
484 const def_file_export
*a
= va
;
485 const def_file_export
*b
= vb
;
493 return strcmp (an
, bn
);
496 /* Read and process the .DEF file. */
498 /* These correspond to the entries in pe_def_file->exports[]. I use
499 exported_symbol_sections[i] to tag whether or not the symbol was
500 defined, since we can't export symbols we don't have. */
502 static bfd_vma
*exported_symbol_offsets
;
503 static struct bfd_section
**exported_symbol_sections
;
504 static int export_table_size
;
505 static int count_exported
;
506 static int count_exported_byname
;
507 static int count_with_ordinals
;
508 static const char *dll_filename
;
509 static int min_ordinal
, max_ordinal
;
510 static int *exported_symbols
;
512 typedef struct exclude_list_struct
515 struct exclude_list_struct
*next
;
520 static struct exclude_list_struct
*excludes
= 0;
523 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
526 char *exclude_string
;
528 local_copy
= xstrdup (new_excludes
);
530 exclude_string
= strtok (local_copy
, ",:");
531 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
533 struct exclude_list_struct
*new_exclude
;
535 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
536 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
537 strcpy (new_exclude
->string
, exclude_string
);
538 new_exclude
->type
= type
;
539 new_exclude
->next
= excludes
;
540 excludes
= new_exclude
;
547 is_import (const char* n
)
549 return (startswith (n
, "__imp_"));
552 /* abfd is a bfd containing n (or NULL)
553 It can be used for contextual checks. */
556 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
559 struct exclude_list_struct
*ex
;
560 const autofilter_entry_type
*afptr
;
561 const char * libname
= NULL
;
563 if (abfd
&& abfd
->my_archive
)
564 libname
= lbasename (bfd_get_filename (abfd
->my_archive
));
566 key
.name
= key
.its_name
= (char *) n
;
568 /* Return false if n is in the d->exports table. */
569 if (d
->num_exports
!= 0
570 && bsearch (&key
, d
->exports
, d
->num_exports
,
571 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
574 if (pe_dll_do_default_excludes
)
579 if (pe_dll_extra_pe_debug
)
580 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
581 n
, abfd
, abfd
->my_archive
);
583 /* First of all, make context checks:
584 Don't export anything from standard libs. */
587 afptr
= autofilter_liblist
;
591 if (libnamencmp (libname
, afptr
) == 0 )
597 /* Next, exclude symbols from certain startup objects. */
599 if (abfd
&& (p
= lbasename (bfd_get_filename (abfd
))))
601 afptr
= autofilter_objlist
;
604 if (strcmp (p
, afptr
->name
) == 0)
610 /* Don't try to blindly exclude all symbols
611 that begin with '__'; this was tried and
612 it is too restrictive. Instead we have
613 a target specific list to use: */
614 afptr
= pe_details
->autofilter_symbollist
;
618 if (strcmp (n
, afptr
->name
) == 0)
624 /* Next, exclude symbols starting with ... */
625 afptr
= autofilter_symbolprefixlist
;
628 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
634 /* Finally, exclude symbols ending with ... */
636 afptr
= autofilter_symbolsuffixlist
;
639 if ((len
>= afptr
->len
)
640 /* Add 1 to insure match with trailing '\0'. */
641 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
642 afptr
->len
+ 1) == 0)
649 for (ex
= excludes
; ex
; ex
= ex
->next
)
651 if (ex
->type
== EXCLUDELIBS
)
654 && ((filename_cmp (libname
, ex
->string
) == 0)
655 || (strcasecmp ("ALL", ex
->string
) == 0)))
658 else if (ex
->type
== EXCLUDEFORIMPLIB
)
660 if (filename_cmp (bfd_get_filename (abfd
), ex
->string
) == 0)
663 else if (strcmp (n
, ex
->string
) == 0)
671 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
675 struct bfd_link_hash_entry
*blhe
;
677 struct bfd_section
*s
;
678 def_file_export
*e
= 0;
682 pe_def_file
= def_file_empty ();
684 /* First, run around to all the objects looking for the .drectve
685 sections, and push those into the def file too. */
686 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
688 s
= bfd_get_section_by_name (b
, ".drectve");
692 char *buf
= xmalloc (size
);
694 bfd_get_section_contents (b
, s
, buf
, 0, size
);
695 def_file_add_directive (pe_def_file
, buf
, size
);
700 /* Process aligned common symbol information from the
701 .drectve sections now; common symbol allocation is
702 done before final link, so it will be too late to
703 process them in process_embedded_commands() called
704 from _bfd_coff_link_input_bfd(). */
705 if (pe_def_file
->aligncomms
)
707 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
710 struct coff_link_hash_entry
*sym_hash
;
711 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
712 ac
->symbol_name
, false, false, false);
713 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
714 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
716 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
722 if (pe_def_file
->exclude_symbols
)
724 for (ui
= 0; ui
< pe_def_file
->num_exclude_symbols
; ui
++)
726 pe_dll_add_excludes (pe_def_file
->exclude_symbols
[ui
].symbol_name
,
731 /* If we are building an executable and there is nothing
732 to export, we do not build an export table at all. */
733 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
734 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
737 /* Now, maybe export everything else the default way. */
738 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
739 && !pe_dll_exclude_all_symbols
)
741 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
746 if (!bfd_generic_link_read_symbols (b
))
748 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
752 symbols
= bfd_get_outsymbols (b
);
753 nsyms
= bfd_get_symcount (b
);
755 for (j
= 0; j
< nsyms
; j
++)
757 /* We should export symbols which are either global or not
758 anything at all. (.bss data is the latter)
759 We should not export undefined symbols. */
761 = (symbols
[j
]->section
!= bfd_und_section_ptr
762 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
763 || (symbols
[j
]->flags
== 0)));
764 if (link_info
.version_info
&& would_export
)
766 = !bfd_hide_sym_by_version (link_info
.version_info
,
770 const char *sn
= symbols
[j
]->name
;
772 /* We should not re-export imported stuff. */
778 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
779 sprintf (name
, "%s%s", "__imp_", sn
);
781 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
782 false, false, false);
785 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
789 if (pe_details
->underscored
&& *sn
== '_')
792 if (auto_export (b
, pe_def_file
, sn
))
797 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
799 /* Fill data flag properly, from dlltool.c. */
801 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
809 #define NE pe_def_file->num_exports
811 /* Don't create an empty export table. */
815 resort_needed
= false;
817 /* Canonicalize the export list. */
820 for (i
= 0; i
< NE
; i
++)
822 /* Check for fastcall/stdcall-decoration, but ignore
823 C++ mangled names. */
824 if (pe_def_file
->exports
[i
].name
[0] != '?'
825 && strchr (pe_def_file
->exports
[i
].name
, '@'))
827 /* This will preserve internal_name, which may have been
828 pointing to the same memory as name, or might not
830 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
831 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
832 char *tmp_at
= strrchr (tmp
, '@');
837 einfo (_("%X%P: cannot export %s: invalid export name\n"),
838 pe_def_file
->exports
[i
].name
);
839 pe_def_file
->exports
[i
].name
= tmp
;
840 resort_needed
= true;
845 /* Re-sort the exports table as we have possibly changed the order
846 by removing leading @. */
848 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
851 if (pe_dll_stdcall_aliases
)
853 for (i
= 0; i
< NE
; i
++)
855 if (is_import (pe_def_file
->exports
[i
].name
))
858 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
861 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
862 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
864 *(strchr (tmp
, '@')) = 0;
865 if (auto_export (NULL
, pe_def_file
, tmp
))
866 def_file_add_export (pe_def_file
, tmp
,
867 pe_def_file
->exports
[i
].internal_name
,
875 /* Convenience, but watch out for it changing. */
876 e
= pe_def_file
->exports
;
878 for (i
= 0, j
= 0; i
< NE
; i
++)
880 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
882 /* This is a duplicate. */
883 if (e
[j
- 1].ordinal
!= -1
884 && e
[i
].ordinal
!= -1
885 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
887 if (pe_dll_warn_dup_exports
)
888 /* xgettext:c-format */
889 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
890 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
894 if (pe_dll_warn_dup_exports
)
895 /* xgettext:c-format */
896 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
900 if (e
[i
].ordinal
!= -1)
901 e
[j
- 1].ordinal
= e
[i
].ordinal
;
902 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
903 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
904 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
905 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
907 free (e
[i
].internal_name
);
908 free (e
[i
].its_name
);
917 pe_def_file
->num_exports
= j
; /* == NE */
919 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
920 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
922 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
926 count_exported_byname
= 0;
927 count_with_ordinals
= 0;
929 for (i
= 0; i
< NE
; i
++)
931 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
934 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
935 lang_add_gc_name (int_name
);
937 name
= xmalloc (strlen (int_name
) + 2);
938 if (pe_details
->underscored
&& int_name
[0] != '@')
941 strcpy (name
+ 1, int_name
);
943 /* PR 19803: The alias must be preserved as well. */
944 lang_add_gc_name (xstrdup (name
));
947 strcpy (name
, int_name
);
949 blhe
= bfd_link_hash_lookup (info
->hash
,
954 && (blhe
->type
== bfd_link_hash_defined
955 || (blhe
->type
== bfd_link_hash_common
)))
958 if (!pe_def_file
->exports
[i
].flag_noname
)
959 count_exported_byname
++;
961 /* Only fill in the sections. The actual offsets are computed
962 in fill_exported_offsets() after common symbols are laid
964 if (blhe
->type
== bfd_link_hash_defined
)
965 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
967 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
969 if (pe_def_file
->exports
[i
].ordinal
!= -1)
971 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
972 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
973 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
974 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
975 count_with_ordinals
++;
978 /* Check for forward exports. These are indicated in DEF files by an
979 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
980 but we must take care not to be fooled when the user wants to export
981 a symbol that actually really has a dot in it, so we only check
982 for them here, after real defined symbols have already been matched. */
983 else if (strchr (int_name
, '.'))
986 if (!pe_def_file
->exports
[i
].flag_noname
)
987 count_exported_byname
++;
989 pe_def_file
->exports
[i
].flag_forward
= 1;
991 if (pe_def_file
->exports
[i
].ordinal
!= -1)
993 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
994 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
995 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
996 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
997 count_with_ordinals
++;
1000 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
1002 /* xgettext:c-format */
1003 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
1008 /* xgettext:c-format */
1009 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
1011 blhe
->type
, bfd_link_hash_defined
);
1015 /* xgettext:c-format */
1016 einfo (_("%X%P: cannot export %s: symbol not found\n"),
1023 /* Build the bfd that will contain .edata and .reloc sections. */
1026 build_filler_bfd (int include_edata
)
1028 lang_input_statement_type
*filler_file
;
1029 filler_file
= lang_add_input_file ("dll stuff",
1030 lang_input_file_is_fake_enum
,
1032 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1033 link_info
.output_bfd
);
1034 if (filler_bfd
== NULL
1035 || !bfd_set_arch_mach (filler_bfd
,
1036 bfd_get_arch (link_info
.output_bfd
),
1037 bfd_get_mach (link_info
.output_bfd
)))
1039 einfo (_("%F%P: can not create BFD: %E\n"));
1045 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1047 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1053 einfo (_("%X%P: can not create .edata section: %E\n"));
1056 bfd_set_section_size (edata_s
, edata_sz
);
1059 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1061 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1067 einfo (_("%X%P: can not create .reloc section: %E\n"));
1071 bfd_set_section_size (reloc_s
, 0);
1073 ldlang_add_file (filler_file
);
1076 /* Gather all the exported symbols and build the .edata section. */
1079 generate_edata (void)
1081 int i
, next_ordinal
;
1082 int name_table_size
= 0;
1084 /* First, we need to know how many exported symbols there are,
1085 and what the range of ordinals is. */
1086 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1088 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1089 min_ordinal
= max_ordinal
- count_exported
+ 1;
1094 max_ordinal
= count_exported
;
1097 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1098 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1099 for (i
= 0; i
< export_table_size
; i
++)
1100 exported_symbols
[i
] = -1;
1102 /* Now we need to assign ordinals to those that don't have them. */
1103 for (i
= 0; i
< NE
; i
++)
1105 if (exported_symbol_sections
[i
]
1106 || pe_def_file
->exports
[i
].flag_forward
)
1108 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1110 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1111 int pi
= exported_symbols
[ei
];
1115 /* xgettext:c-format */
1116 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1117 pe_def_file
->exports
[i
].ordinal
,
1118 pe_def_file
->exports
[i
].name
,
1119 pe_def_file
->exports
[pi
].name
);
1121 exported_symbols
[ei
] = i
;
1123 if (pe_def_file
->exports
[i
].its_name
)
1124 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1126 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1129 /* Reserve space for the forward name. */
1130 if (pe_def_file
->exports
[i
].flag_forward
)
1132 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1136 next_ordinal
= min_ordinal
;
1137 for (i
= 0; i
< NE
; i
++)
1138 if ((exported_symbol_sections
[i
]
1139 || pe_def_file
->exports
[i
].flag_forward
)
1140 && pe_def_file
->exports
[i
].ordinal
== -1)
1142 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1145 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1146 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1149 /* PR 12969: Check for more than 1^16 ordinals. */
1150 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1151 /* xgettext:c-format */
1152 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1153 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1155 /* OK, now we can allocate some memory. */
1156 edata_sz
= (40 /* directory */
1157 + 4 * export_table_size
/* addresses */
1158 + 4 * count_exported_byname
/* name ptrs */
1159 + 2 * count_exported_byname
/* ordinals */
1160 + name_table_size
+ strlen (dll_filename
) + 1);
1163 /* Fill the exported symbol offsets. The preliminary work has already
1164 been done in process_def_file_and_drectve(). */
1167 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1170 struct bfd_link_hash_entry
*blhe
;
1172 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1176 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1177 if (pe_details
->underscored
1178 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1181 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1184 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1186 blhe
= bfd_link_hash_lookup (info
->hash
,
1188 false, false, true);
1190 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1191 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1198 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1201 unsigned char *edirectory
;
1202 unsigned char *eaddresses
;
1203 unsigned char *enameptrs
;
1204 unsigned char *eordinals
;
1207 edata_d
= xmalloc (edata_sz
);
1209 /* Note use of array pointer math here. */
1210 edirectory
= edata_d
;
1211 eaddresses
= edirectory
+ 40;
1212 enameptrs
= eaddresses
+ 4 * export_table_size
;
1213 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1214 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1216 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1217 + edata_s->output_section->vma - image_base)
1219 memset (edata_d
, 0, edata_sz
);
1221 if (pe_data (abfd
)->timestamp
== -1)
1222 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1224 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, edata_d
+ 4);
1226 if (pe_def_file
->version_major
!= -1)
1228 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1229 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1232 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1233 strcpy (enamestr
, dll_filename
);
1234 enamestr
+= strlen (enamestr
) + 1;
1235 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1236 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1237 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1238 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1239 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1240 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1242 fill_exported_offsets (abfd
, info
);
1244 /* Ok, now for the filling in part.
1245 Scan alphabetically - ie the ordering in the exports[] table,
1246 rather than by ordinal - the ordering in the exported_symbol[]
1247 table. See dlltool.c and:
1248 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1249 for more information. */
1251 for (s
= 0; s
< NE
; s
++)
1253 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1254 if (pe_def_file
->exports
[s
].ordinal
!= -1
1255 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1257 int ord
= pe_def_file
->exports
[s
].ordinal
;
1259 if (pe_def_file
->exports
[s
].flag_forward
)
1261 bfd_put_32 (abfd
, ERVA (enamestr
),
1262 eaddresses
+ 4 * (ord
- min_ordinal
));
1264 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1265 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1269 bfd_vma srva
= (exported_symbol_offsets
[s
]
1270 + ssec
->output_section
->vma
1271 + ssec
->output_offset
);
1273 bfd_put_32 (abfd
, srva
- image_base
,
1274 eaddresses
+ 4 * (ord
- min_ordinal
));
1277 if (!pe_def_file
->exports
[s
].flag_noname
)
1279 char *ename
= pe_def_file
->exports
[s
].name
;
1280 if (pe_def_file
->exports
[s
].its_name
)
1281 ename
= pe_def_file
->exports
[s
].its_name
;
1283 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1285 strcpy (enamestr
, ename
);
1286 enamestr
+= strlen (enamestr
) + 1;
1287 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1289 pe_def_file
->exports
[s
].hint
= hint
++;
1296 static struct bfd_section
*current_sec
;
1299 pe_walk_relocs (struct bfd_link_info
*info
,
1301 const char *symname
,
1302 struct bfd_hash_table
*import_hash
,
1303 void (*cb
) (arelent
*, asection
*, char *, const char *))
1308 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1312 if (!bfd_generic_link_read_symbols (b
))
1314 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1318 symbols
= bfd_get_outsymbols (b
);
1320 for (s
= b
->sections
; s
; s
= s
->next
)
1323 int relsize
, nrelocs
, i
;
1324 int flags
= bfd_section_flags (s
);
1326 /* Skip discarded linkonce sections. */
1327 if (flags
& SEC_LINK_ONCE
1328 && s
->output_section
== bfd_abs_section_ptr
)
1333 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1334 relocs
= xmalloc (relsize
);
1335 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1337 for (i
= 0; i
< nrelocs
; i
++)
1339 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1341 /* Warning: the callback needs to be passed NAME directly. */
1344 if (bfd_hash_lookup (import_hash
, sym
->name
, false, false))
1346 strcpy (name
, sym
->name
);
1347 cb (relocs
[i
], s
, name
, symname
);
1352 if (strcmp (name
, sym
->name
) == 0)
1353 cb (relocs
[i
], s
, name
, symname
);
1359 /* Warning: the allocated symbols are remembered in BFD and reused
1360 later, so don't free them! */
1361 /* free (symbols); */
1367 pe_find_data_imports (const char *symhead
,
1368 void (*cb
) (arelent
*, asection
*, char *, const char *))
1370 struct bfd_link_hash_entry
*undef
;
1371 const size_t headlen
= strlen (symhead
);
1374 struct bfd_hash_table
*import_hash
;
1376 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1377 if (undef
->type
== bfd_link_hash_undefined
)
1379 size_t len
= strlen (undef
->root
.string
);
1386 /* For the pseudo-relocation support version 2, we can collect the symbols
1387 that are subject to auto-import and adjust the relocations en masse. */
1388 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1391 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1392 if (!bfd_hash_table_init (import_hash
,
1394 sizeof (struct bfd_hash_entry
)))
1395 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1400 /* We are being a bit cunning here. The buffer will have space for
1401 prefixes at the beginning. The prefix is modified here and in a
1402 number of functions called from this function. */
1403 #define PREFIX_LEN 32
1404 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1405 name
= buf
+ PREFIX_LEN
;
1407 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1408 if (undef
->type
== bfd_link_hash_undefined
)
1410 struct bfd_link_hash_entry
*sym
;
1413 if (pe_dll_extra_pe_debug
)
1414 printf ("%s:%s\n", __FUNCTION__
, undef
->root
.string
);
1416 strcpy (name
, undef
->root
.string
);
1417 impname
= name
- (sizeof "__imp_" - 1);
1418 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1420 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1422 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1425 bfd_hash_lookup (import_hash
, undef
->root
.string
, true, false);
1428 bfd
*b
= sym
->u
.def
.section
->owner
;
1429 const char *symname
= NULL
;
1433 if (!bfd_generic_link_read_symbols (b
))
1435 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1439 symbols
= bfd_get_outsymbols (b
);
1440 nsyms
= bfd_get_symcount (b
);
1442 for (i
= 0; i
< nsyms
; i
++)
1443 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1445 if (pe_dll_extra_pe_debug
)
1446 printf ("->%s\n", symbols
[i
]->name
);
1448 symname
= symbols
[i
]->name
+ headlen
;
1452 /* If the symobl isn't part of an import table, there is no
1453 point in building a fixup, this would give rise to link
1454 errors for mangled symbols instead of the original one. */
1456 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1461 /* Let's differentiate it somehow from defined. */
1462 undef
->type
= bfd_link_hash_defweak
;
1463 undef
->u
.def
.value
= sym
->u
.def
.value
;
1464 undef
->u
.def
.section
= sym
->u
.def
.section
;
1466 /* We replace the original name with the __imp_ prefixed one, this
1467 1) may trash memory 2) leads to duplicate symbols. But this is
1468 better than having a misleading name that can confuse GDB. */
1469 undef
->root
.string
= sym
->root
.string
;
1471 if (link_info
.pei386_auto_import
== -1)
1473 static bool warned
= false;
1475 info_msg (_("Info: resolving %s by linking to %s "
1476 "(auto-import)\n"), name
, impname
);
1478 /* PR linker/4844. */
1481 einfo (_("%P: warning: auto-importing has been activated "
1482 "without --enable-auto-import specified on the "
1483 "command line; this should work unless it "
1484 "involves constant data structures referencing "
1485 "symbols from auto-imported DLLs\n"));
1492 /* If we have the import hash table, walk the relocations only once. */
1495 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1496 bfd_hash_table_free (import_hash
);
1503 /* Gather all the relocations and build the .reloc section. */
1506 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1508 /* For .reloc stuff. */
1509 reloc_data_type
*reloc_data
;
1510 int total_relocs
= 0;
1512 bfd_vma sec_page
= (bfd_vma
) -1;
1513 bfd_vma page_ptr
, page_count
;
1516 struct bfd_section
*s
;
1518 if (reloc_s
== NULL
|| reloc_s
->output_section
== bfd_abs_section_ptr
)
1521 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1522 for (s
= b
->sections
; s
; s
= s
->next
)
1523 total_relocs
+= s
->reloc_count
;
1525 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1529 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1532 int relsize
, nrelocs
;
1534 for (s
= b
->sections
; s
; s
= s
->next
)
1536 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1539 /* If it's not loaded, we don't need to relocate it this way. */
1540 if (!(s
->output_section
->flags
& SEC_LOAD
))
1543 /* I don't know why there would be a reloc for these, but I've
1544 seen it happen - DJ */
1545 if (s
->output_section
== bfd_abs_section_ptr
)
1548 if (s
->output_section
->vma
== 0)
1550 /* Huh? Shouldn't happen, but punt if it does. */
1551 #if 0 /* This happens when linking with --just-symbols=<file>, so do not generate an error. */
1552 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1553 s
->output_section
->name
, s
->output_section
->index
,
1554 s
->output_section
->flags
);
1559 if (!bfd_generic_link_read_symbols (b
))
1561 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1565 symbols
= bfd_get_outsymbols (b
);
1566 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1567 relocs
= xmalloc (relsize
);
1568 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1570 for (i
= 0; i
< nrelocs
; i
++)
1572 if (pe_dll_extra_pe_debug
)
1574 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1575 printf ("rel: %s\n", sym
->name
);
1577 if (!relocs
[i
]->howto
->pc_relative
1578 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1580 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1581 const struct bfd_link_hash_entry
*blhe
1582 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1583 false, false, false);
1585 /* Don't create relocs for undefined weak symbols. */
1586 if (sym
->flags
== BSF_WEAK
)
1588 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1590 /* Check aux sym and see if it is defined or not. */
1591 struct coff_link_hash_entry
*h
, *h2
;
1592 h
= (struct coff_link_hash_entry
*)blhe
;
1593 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1595 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1596 [h
->aux
->x_sym
.x_tagndx
.l
];
1597 /* We don't want a base reloc if the aux sym is not
1598 found, undefined, or if it is the constant ABS
1599 zero default value. (We broaden that slightly by
1600 not testing the value, just the section; there's
1601 no reason we'd want a reference to any absolute
1602 address to get relocated during rebasing). */
1603 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1604 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1607 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1610 /* Nor for Dwarf FDE references to discarded sections. */
1611 else if (bfd_is_abs_section (sym
->section
->output_section
))
1613 /* We only ignore relocs from .eh_frame sections, as
1614 they are discarded by the final link rather than
1615 resolved against the kept section. */
1616 if (!strcmp (s
->name
, ".eh_frame"))
1619 /* Nor for absolute symbols. */
1620 else if (blhe
&& ldexp_is_final_sym_absolute (blhe
)
1621 && (!blhe
->linker_def
1622 || (strcmp (sym
->name
, "__image_base__")
1623 && strcmp (sym
->name
, U ("__ImageBase")))))
1626 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1627 reloc_data
[total_relocs
].idx
= total_relocs
;
1629 /* Since we're only about to determine .reloc's size,
1630 subsequent output section VMA calculations will shift up
1631 sections at this or higher addresses. Relocations for
1632 such sections would hence end up not being correct. */
1633 if (reloc_data
[total_relocs
].vma
1634 >= reloc_s
->output_section
->vma
)
1635 einfo (_("%P: base relocation for section `%s' above "
1636 ".reloc section\n"), s
->output_section
->name
);
1638 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1640 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1641 relocs
[i
]->howto
->rightshift
)
1643 #ifdef pe_use_x86_64
1644 case BITS_AND_SHIFT (64, 0):
1645 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_DIR64
;
1649 case BITS_AND_SHIFT (32, 0):
1650 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_HIGHLOW
;
1653 case BITS_AND_SHIFT (16, 0):
1654 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_LOW
;
1657 case BITS_AND_SHIFT (16, 16):
1658 reloc_data
[total_relocs
].type
= IMAGE_REL_BASED_HIGHADJ
;
1659 /* FIXME: we can't know the symbol's right value
1660 yet, but we probably can safely assume that
1661 CE will relocate us in 64k blocks, so leaving
1663 reloc_data
[total_relocs
].extra
= 0;
1666 case BITS_AND_SHIFT (26, 2):
1667 reloc_data
[total_relocs
].type
=
1668 IMAGE_REL_BASED_ARM_MOV32
;
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
== IMAGE_REL_BASED_HIGHADJ
)
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
== IMAGE_REL_BASED_HIGHADJ
)
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
)
1825 fprintf (out
, " BASE=0x%" PRIx64
,
1826 (uint64_t) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
);
1827 fprintf (out
, "\n");
1830 if (pe_def_file
->description
)
1832 fprintf (out
, "DESCRIPTION ");
1833 quoteput (pe_def_file
->description
, out
, 1);
1834 fprintf (out
, "\n");
1837 if (pe_def_file
->version_minor
!= -1)
1838 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1839 pe_def_file
->version_minor
);
1840 else if (pe_def_file
->version_major
!= -1)
1841 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1843 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1844 fprintf (out
, "\n");
1846 if (pe_def_file
->stack_commit
!= -1)
1847 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1848 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1849 else if (pe_def_file
->stack_reserve
!= -1)
1850 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1852 if (pe_def_file
->heap_commit
!= -1)
1853 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1854 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1855 else if (pe_def_file
->heap_reserve
!= -1)
1856 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1858 if (pe_def_file
->num_section_defs
> 0)
1860 fprintf (out
, "\nSECTIONS\n\n");
1862 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1865 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1867 if (pe_def_file
->section_defs
[i
].class)
1869 fprintf (out
, " CLASS ");
1870 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1873 if (pe_def_file
->section_defs
[i
].flag_read
)
1874 fprintf (out
, " READ");
1876 if (pe_def_file
->section_defs
[i
].flag_write
)
1877 fprintf (out
, " WRITE");
1879 if (pe_def_file
->section_defs
[i
].flag_execute
)
1880 fprintf (out
, " EXECUTE");
1882 if (pe_def_file
->section_defs
[i
].flag_shared
)
1883 fprintf (out
, " SHARED");
1885 fprintf (out
, "\n");
1889 if (pe_def_file
->num_exports
> 0)
1891 fprintf (out
, "EXPORTS\n");
1893 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1895 def_file_export
*e
= pe_def_file
->exports
+ i
;
1897 quoteput (e
->name
, out
, 0);
1899 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1901 fprintf (out
, " = ");
1902 quoteput (e
->internal_name
, out
, 0);
1905 if (e
->ordinal
!= -1)
1906 fprintf (out
, " @%d", e
->ordinal
);
1908 if (e
->flag_private
)
1909 fprintf (out
, " PRIVATE");
1911 if (e
->flag_constant
)
1912 fprintf (out
, " CONSTANT");
1915 fprintf (out
, " NONAME");
1918 fprintf (out
, " DATA");
1920 fprintf (out
, "\n");
1924 if (pe_def_file
->num_imports
> 0)
1926 fprintf (out
, "\nIMPORTS\n\n");
1928 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1930 def_file_import
*im
= pe_def_file
->imports
+ i
;
1933 if (im
->internal_name
1934 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1936 quoteput (im
->internal_name
, out
, 0);
1937 fprintf (out
, " = ");
1940 quoteput (im
->module
->name
, out
, 0);
1944 quoteput (im
->name
, out
, 0);
1946 fprintf (out
, "%d", im
->ordinal
);
1950 fprintf (out
, " == ");
1951 quoteput (im
->its_name
, out
, 0);
1954 fprintf (out
, "\n");
1959 fprintf (out
, _("; no contents available\n"));
1961 if (fclose (out
) == EOF
)
1962 /* xgettext:c-format */
1963 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1966 /* Generate the import library. */
1968 static asymbol
**symtab
;
1971 static char *dll_symname
;
1973 #define UNDSEC bfd_und_section_ptr
1976 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1981 sec
= bfd_make_section_old_way (abfd
, name
);
1982 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1983 bfd_set_section_alignment (sec
, align
);
1984 /* Remember to undo this before trying to link internally! */
1985 sec
->output_section
= sec
;
1987 sym
= bfd_make_empty_symbol (abfd
);
1988 symtab
[symptr
++] = sym
;
1989 sym
->name
= sec
->name
;
1991 sym
->flags
= BSF_LOCAL
;
1998 quick_symbol (bfd
*abfd
,
2007 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
2012 sym
= bfd_make_empty_symbol (abfd
);
2017 symtab
[symptr
++] = sym
;
2020 static arelent
*reltab
= 0;
2021 static int relcount
= 0, relsize
= 0;
2024 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2026 if (relcount
>= relsize
- 1)
2030 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2032 reltab
= xmalloc (relsize
* sizeof (arelent
));
2034 reltab
[relcount
].address
= address
;
2035 reltab
[relcount
].addend
= 0;
2036 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2037 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2042 save_relocs (asection
*sec
)
2046 sec
->relocation
= reltab
;
2047 sec
->reloc_count
= relcount
;
2048 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2049 for (i
= 0; i
< relcount
; i
++)
2050 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2051 sec
->orelocation
[relcount
] = 0;
2052 sec
->flags
|= SEC_RELOC
;
2054 relcount
= relsize
= 0;
2057 /* .section .idata$2
2058 .global __head_my_dll
2075 make_head (bfd
*parent
)
2077 asection
*id2
, *id5
, *id4
;
2078 unsigned char *d2
, *d5
, *d4
;
2082 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2083 /* In theory we should return NULL here at let our caller decide what to
2084 do. But currently the return value is not checked, just used, and
2085 besides, this condition only happens when the system has run out of
2086 memory. So just give up. */
2087 exit (EXIT_FAILURE
);
2090 abfd
= bfd_create (oname
, parent
);
2091 bfd_find_target (pe_details
->object_target
, abfd
);
2092 bfd_make_writable (abfd
);
2094 bfd_set_format (abfd
, bfd_object
);
2095 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2098 symtab
= xmalloc (6 * sizeof (asymbol
*));
2099 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2100 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2101 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2102 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2103 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2105 /* OK, pay attention here. I got confused myself looking back at
2106 it. We create a four-byte section to mark the beginning of the
2107 list, and we include an offset of 4 in the section, so that the
2108 pointer to the list points to the *end* of this section, which is
2109 the start of the list of sections from other objects. */
2111 bfd_set_section_size (id2
, 20);
2115 if (pe_use_nul_prefixed_import_tables
)
2116 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2117 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2118 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2119 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2122 if (pe_use_nul_prefixed_import_tables
)
2123 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2125 bfd_set_section_size (id5
, 0);
2126 d5
= xmalloc (PE_IDATA5_SIZE
);
2128 memset (d5
, 0, PE_IDATA5_SIZE
);
2129 if (pe_use_nul_prefixed_import_tables
)
2130 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2132 bfd_set_section_size (id4
, 0);
2133 d4
= xmalloc (PE_IDATA4_SIZE
);
2135 memset (d4
, 0, PE_IDATA4_SIZE
);
2137 bfd_set_symtab (abfd
, symtab
, symptr
);
2139 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2140 if (pe_use_nul_prefixed_import_tables
)
2142 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2143 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2147 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2148 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2151 bfd_make_readable (abfd
);
2155 /* .section .idata$4
2162 .global __my_dll_iname
2167 make_tail (bfd
*parent
)
2169 asection
*id4
, *id5
, *id7
;
2170 unsigned char *d4
, *d5
, *d7
;
2175 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2176 /* In theory we should return NULL here at let our caller decide what to
2177 do. But currently the return value is not checked, just used, and
2178 besides, this condition only happens when the system has run out of
2179 memory. So just give up. */
2180 exit (EXIT_FAILURE
);
2183 abfd
= bfd_create (oname
, parent
);
2184 bfd_find_target (pe_details
->object_target
, abfd
);
2185 bfd_make_writable (abfd
);
2187 bfd_set_format (abfd
, bfd_object
);
2188 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2191 symtab
= xmalloc (5 * sizeof (asymbol
*));
2192 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2193 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2194 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2195 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2197 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2198 d4
= xmalloc (PE_IDATA4_SIZE
);
2200 memset (d4
, 0, PE_IDATA4_SIZE
);
2202 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2203 d5
= xmalloc (PE_IDATA5_SIZE
);
2205 memset (d5
, 0, PE_IDATA5_SIZE
);
2207 len
= strlen (dll_filename
) + 1;
2210 bfd_set_section_size (id7
, len
);
2213 strcpy ((char *) d7
, dll_filename
);
2214 /* If len was odd, the above
2215 strcpy leaves behind an undefined byte. That is harmless,
2216 but we set it to 0 just so the binary dumps are pretty. */
2219 bfd_set_symtab (abfd
, symtab
, symptr
);
2221 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2222 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2223 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2225 bfd_make_readable (abfd
);
2231 .global ___imp_function
2232 .global __imp__function
2234 jmp *__imp__function:
2248 .asciz "function" xlate? (add underscore, kill at) */
2250 static const unsigned char jmp_ix86_bytes
[] =
2252 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2260 .dw __imp_function */
2262 static const unsigned char jmp_sh_bytes
[] =
2264 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2268 lui $t0,<high:__imp_function>
2269 lw $t0,<low:__imp_function>
2273 static const unsigned char jmp_mips_bytes
[] =
2275 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2276 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2279 static const unsigned char jmp_arm_bytes
[] =
2281 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2282 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2288 make_one (def_file_export
*exp
, bfd
*parent
, bool include_jmp_stub
)
2290 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2291 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2295 const unsigned char *jmp_bytes
= NULL
;
2296 int jmp_byte_count
= 0;
2298 /* Include the jump stub section only if it is needed. A jump
2299 stub is needed if the symbol being imported <sym> is a function
2300 symbol and there is at least one undefined reference to that
2301 symbol. In other words, if all the import references to <sym> are
2302 explicitly through _declspec(dllimport) then the jump stub is not
2304 if (include_jmp_stub
)
2306 switch (pe_details
->pe_arch
)
2309 jmp_bytes
= jmp_ix86_bytes
;
2310 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2313 jmp_bytes
= jmp_sh_bytes
;
2314 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2317 jmp_bytes
= jmp_mips_bytes
;
2318 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2321 case PE_ARCH_arm_wince
:
2322 jmp_bytes
= jmp_arm_bytes
;
2323 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2330 if (asprintf (&oname
, "%s_d%06d.o", dll_symname
, tmp_seq
) < 4)
2331 /* In theory we should return NULL here at let our caller decide what to
2332 do. But currently the return value is not checked, just used, and
2333 besides, this condition only happens when the system has run out of
2334 memory. So just give up. */
2335 exit (EXIT_FAILURE
);
2338 abfd
= bfd_create (oname
, parent
);
2339 bfd_find_target (pe_details
->object_target
, abfd
);
2340 bfd_make_writable (abfd
);
2342 bfd_set_format (abfd
, bfd_object
);
2343 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2346 symtab
= xmalloc (12 * sizeof (asymbol
*));
2348 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2349 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2350 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2351 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2352 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2354 if (*exp
->internal_name
== '@')
2356 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2358 if (include_jmp_stub
)
2359 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2360 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2362 /* Fastcall applies only to functions,
2363 so no need for auto-import symbol. */
2367 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2369 if (include_jmp_stub
)
2370 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2372 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2374 /* Symbol to reference ord/name of imported
2375 data symbol, used to implement auto-import. */
2377 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2380 if (pe_dll_compat_implib
)
2381 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2384 if (include_jmp_stub
)
2386 bfd_set_section_size (tx
, jmp_byte_count
);
2387 td
= xmalloc (jmp_byte_count
);
2389 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2391 switch (pe_details
->pe_arch
)
2394 #ifdef pe_use_x86_64
2395 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2397 /* Mark this object as SAFESEH compatible. */
2398 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2400 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2404 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2407 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2408 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2409 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2412 case PE_ARCH_arm_wince
:
2413 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2421 bfd_set_section_size (tx
, 0);
2423 bfd_set_section_size (id7
, 4);
2427 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2430 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2431 d5
= xmalloc (PE_IDATA5_SIZE
);
2433 memset (d5
, 0, PE_IDATA5_SIZE
);
2435 if (exp
->flag_noname
)
2437 d5
[0] = exp
->ordinal
;
2438 d5
[1] = exp
->ordinal
>> 8;
2439 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2443 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2447 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2448 d4
= xmalloc (PE_IDATA4_SIZE
);
2450 memset (d4
, 0, PE_IDATA4_SIZE
);
2452 if (exp
->flag_noname
)
2454 d4
[0] = exp
->ordinal
;
2455 d4
[1] = exp
->ordinal
>> 8;
2456 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2460 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2464 if (exp
->flag_noname
)
2467 bfd_set_section_size (id6
, 0);
2473 /* { short, asciz } */
2475 len
= 2 + strlen (exp
->its_name
) + 1;
2477 len
= 2 + strlen (exp
->name
) + 1;
2480 bfd_set_section_size (id6
, len
);
2483 memset (d6
, 0, len
);
2485 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2486 contains an invalid value (-1). */
2487 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2492 strcpy ((char*) d6
+ 2, exp
->its_name
);
2494 strcpy ((char *) d6
+ 2, exp
->name
);
2497 bfd_set_symtab (abfd
, symtab
, symptr
);
2499 if (include_jmp_stub
)
2500 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2501 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2502 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2503 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2504 if (!exp
->flag_noname
)
2505 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2507 bfd_make_readable (abfd
);
2512 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2514 /* Name thunks go to idata$4. */
2520 if (asprintf (&oname
, "%s_nmth%06d.o", dll_symname
, tmp_seq
) < 4)
2521 /* In theory we should return NULL here at let our caller decide what to
2522 do. But currently the return value is not checked, just used, and
2523 besides, this condition only happens when the system has run out of
2524 memory. So just give up. */
2525 exit (EXIT_FAILURE
);
2528 abfd
= bfd_create (oname
, parent
);
2529 bfd_find_target (pe_details
->object_target
, abfd
);
2530 bfd_make_writable (abfd
);
2532 bfd_set_format (abfd
, bfd_object
);
2533 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2536 symtab
= xmalloc (3 * sizeof (asymbol
*));
2537 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2538 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2539 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2541 /* We need space for the real thunk and for the null terminator. */
2542 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2543 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2545 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2546 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2549 bfd_set_symtab (abfd
, symtab
, symptr
);
2551 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2553 bfd_make_readable (abfd
);
2558 make_import_fixup_mark (arelent
*rel
, char *name
)
2560 /* We convert reloc to symbol, for later reference. */
2561 static unsigned int counter
;
2562 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2563 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2564 struct bfd_link_hash_entry
*bh
;
2565 char *fixup_name
, buf
[256];
2568 /* "name" buffer has space before the symbol name for prefixes. */
2569 sprintf (buf
, "__fu%d_", counter
++);
2570 prefix_len
= strlen (buf
);
2571 fixup_name
= name
- prefix_len
;
2572 memcpy (fixup_name
, buf
, prefix_len
);
2575 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2576 current_sec
, /* sym->section, */
2577 rel
->address
, NULL
, true, false, &bh
);
2579 return bh
->root
.string
;
2582 /* .section .idata$2
2583 .rva __nm_thnk_SYM (singleton thunk with name of func)
2586 .rva __my_dll_iname (name of dll)
2587 .rva __fuNN_SYM (pointer to reference (address) in text) */
2590 make_import_fixup_entry (const char *name
,
2591 const char *fixup_name
,
2592 const char *symname
,
2600 if (asprintf (&oname
, "%s_fu%06d.o", dll_symname
, tmp_seq
) < 4)
2601 /* In theory we should return NULL here at let our caller decide what to
2602 do. But currently the return value is not checked, just used, and
2603 besides, this condition only happens when the system has run out of
2604 memory. So just give up. */
2605 exit (EXIT_FAILURE
);
2608 abfd
= bfd_create (oname
, parent
);
2609 bfd_find_target (pe_details
->object_target
, abfd
);
2610 bfd_make_writable (abfd
);
2612 bfd_set_format (abfd
, bfd_object
);
2613 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2616 symtab
= xmalloc (6 * sizeof (asymbol
*));
2617 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2619 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2620 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2621 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2623 bfd_set_section_size (id2
, 20);
2628 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2629 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2630 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2633 bfd_set_symtab (abfd
, symtab
, symptr
);
2635 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2637 bfd_make_readable (abfd
);
2641 /* .section .rdata_runtime_pseudo_reloc
2643 .rva __fuNN_SYM (pointer to reference (address) in text) */
2646 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2647 const char *fixup_name
,
2648 bfd_vma addend ATTRIBUTE_UNUSED
,
2653 unsigned char *rt_rel_d
;
2658 if (asprintf (&oname
, "%s_rtr%06d.o", dll_symname
, tmp_seq
) < 4)
2659 /* In theory we should return NULL here at let our caller decide what to
2660 do. But currently the return value is not checked, just used, and
2661 besides, this condition only happens when the system has run out of
2662 memory. So just give up. */
2663 exit (EXIT_FAILURE
);
2666 abfd
= bfd_create (oname
, parent
);
2667 bfd_find_target (pe_details
->object_target
, abfd
);
2668 bfd_make_writable (abfd
);
2670 bfd_set_format (abfd
, bfd_object
);
2671 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2673 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2675 if (runtime_pseudp_reloc_v2_init
)
2676 size
= 3 * sizeof (asymbol
*);
2678 size
= 6 * sizeof (asymbol
*);
2681 size
= 2 * sizeof (asymbol
*);
2684 symtab
= xmalloc (size
);
2687 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2689 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2691 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2694 if (!runtime_pseudp_reloc_v2_init
)
2697 runtime_pseudp_reloc_v2_init
= true;
2700 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2702 bfd_set_section_size (rt_rel
, size
);
2703 rt_rel_d
= xmalloc (size
);
2704 rt_rel
->contents
= rt_rel_d
;
2705 memset (rt_rel_d
, 0, size
);
2706 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2707 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2708 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2710 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2711 save_relocs (rt_rel
);
2713 bfd_set_symtab (abfd
, symtab
, symptr
);
2715 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2719 bfd_set_section_size (rt_rel
, 8);
2720 rt_rel_d
= xmalloc (8);
2721 rt_rel
->contents
= rt_rel_d
;
2722 memset (rt_rel_d
, 0, 8);
2724 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2725 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2727 save_relocs (rt_rel
);
2729 bfd_set_symtab (abfd
, symtab
, symptr
);
2731 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2734 bfd_make_readable (abfd
);
2739 .rva __pei386_runtime_relocator */
2742 pe_create_runtime_relocator_reference (bfd
*parent
)
2744 asection
*extern_rt_rel
;
2745 unsigned char *extern_rt_rel_d
;
2749 if (asprintf (&oname
, "%s_ertr%06d.o", dll_symname
, tmp_seq
) < 4)
2750 /* In theory we should return NULL here at let our caller decide what to
2751 do. But currently the return value is not checked, just used, and
2752 besides, this condition only happens when the system has run out of
2753 memory. So just give up. */
2754 exit (EXIT_FAILURE
);
2757 abfd
= bfd_create (oname
, parent
);
2758 bfd_find_target (pe_details
->object_target
, abfd
);
2759 bfd_make_writable (abfd
);
2761 bfd_set_format (abfd
, bfd_object
);
2762 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2765 symtab
= xmalloc (2 * sizeof (asymbol
*));
2766 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2768 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2771 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2772 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2773 extern_rt_rel
->contents
= extern_rt_rel_d
;
2775 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2776 save_relocs (extern_rt_rel
);
2778 bfd_set_symtab (abfd
, symtab
, symptr
);
2780 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2782 bfd_make_readable (abfd
);
2787 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2788 const char *symname
)
2790 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2793 /* This is the original implementation of the auto-import feature, which
2794 primarily relied on the OS loader to patch things up with some help
2795 from the pseudo-relocator to overcome the main limitation. See the
2796 comment at the beginning of the file for an overview of the feature. */
2797 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2799 struct bfd_link_hash_entry
*name_thunk_sym
;
2800 /* name buffer is allocated with space at beginning for prefixes. */
2801 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2802 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2803 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2805 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2807 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2808 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2810 /* If we ever use autoimport, we have to cast text section writable. */
2811 config
.text_read_only
= false;
2812 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2815 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2817 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2818 link_info
.output_bfd
);
2819 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2823 /* In the original implementation, the pseudo-relocator was only used when
2824 the addend was not null. In the new implementation, the OS loader is
2825 completely bypassed and the pseudo-relocator does the entire work. */
2826 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2827 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2829 if (pe_dll_extra_pe_debug
)
2830 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2831 fixup_name
, (int) addend
);
2833 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
,
2834 rel
->howto
->bitsize
,
2835 link_info
.output_bfd
);
2836 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2838 if (runtime_pseudo_relocs_created
++ == 0)
2840 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2841 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2845 else if (addend
!= 0)
2846 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2847 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2851 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2860 unlink_if_ordinary (impfilename
);
2862 outarch
= bfd_openw (impfilename
, 0);
2866 /* xgettext:c-format */
2867 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2872 /* xgettext:c-format */
2873 info_msg (_("Creating library file: %s\n"), impfilename
);
2875 bfd_set_format (outarch
, bfd_archive
);
2876 outarch
->has_armap
= 1;
2878 /* Work out a reasonable size of things to put onto one line. */
2879 ar_head
= make_head (outarch
);
2881 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2882 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2884 /* Iterate the exclude list. */
2885 struct exclude_list_struct
*ex
;
2887 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2889 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2891 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2893 /* If it matched, we must open a fresh BFD for it (the original
2894 input BFD is still needed for the DLL's final link) and add
2895 it into the archive member chain. */
2898 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2899 ? bfd_get_filename (ibfd
->my_archive
)
2900 : bfd_get_filename (ibfd
), NULL
);
2903 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2906 if (ibfd
->my_archive
)
2908 /* Must now iterate through archive until we find the
2909 required member. A minor shame that we'll open the
2910 archive once per member that we require from it, and
2911 leak those archive bfds rather than reuse them. */
2912 bfd
*arbfd
= newbfd
;
2913 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2915 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2916 bfd_get_filename (ibfd
->my_archive
),
2917 bfd_get_filename (ibfd
));
2921 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2923 if (filename_cmp (bfd_get_filename (newbfd
),
2924 bfd_get_filename (ibfd
)) == 0)
2929 einfo (_("%X%P: %s(%s): can't find member in archive"),
2930 bfd_get_filename (ibfd
->my_archive
),
2931 bfd_get_filename (ibfd
));
2935 newbfd
->archive_next
= head
;
2940 for (i
= 0; i
< def
->num_exports
; i
++)
2942 /* The import library doesn't know about the internal name. */
2943 char *internal
= def
->exports
[i
].internal_name
;
2946 /* Don't add PRIVATE entries to import lib. */
2947 if (pe_def_file
->exports
[i
].flag_private
)
2950 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2952 /* PR 19803: If a symbol has been discard due to garbage
2953 collection then do not create any exports for it. */
2955 struct coff_link_hash_entry
*h
;
2957 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2958 false, false, false);
2960 /* If the symbol is hidden and undefined then it
2961 has been swept up by garbage collection. */
2962 && h
->symbol_class
== C_HIDDEN
2963 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2966 /* If necessary, check with an underscore prefix as well. */
2967 if (pe_details
->underscored
&& internal
[0] != '@')
2971 name
= xmalloc (strlen (internal
) + 2);
2972 sprintf (name
, "_%s", internal
);
2974 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2975 false, false, false);
2979 /* If the symbol is hidden and undefined then it
2980 has been swept up by garbage collection. */
2981 && h
->symbol_class
== C_HIDDEN
2982 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2987 n
= make_one (def
->exports
+ i
, outarch
, !(def
->exports
+ i
)->flag_data
);
2988 n
->archive_next
= head
;
2990 def
->exports
[i
].internal_name
= internal
;
2993 ar_tail
= make_tail (outarch
);
2995 if (ar_head
== NULL
|| ar_tail
== NULL
)
2998 /* Now stick them all into the archive. */
2999 ar_head
->archive_next
= head
;
3000 ar_tail
->archive_next
= ar_head
;
3003 if (! bfd_set_archive_head (outarch
, head
))
3004 einfo ("%X%P: bfd_set_archive_head: %E\n");
3006 if (! bfd_close (outarch
))
3007 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
3009 while (head
!= NULL
)
3011 bfd
*n
= head
->archive_next
;
3017 static int undef_count
= 0;
3025 static struct key_value
*udef_table
;
3027 static int undef_sort_cmp (const void *l1
, const void *r1
)
3029 const struct key_value
*l
= l1
;
3030 const struct key_value
*r
= r1
;
3032 return strcmp (l
->key
, r
->key
);
3035 static struct bfd_link_hash_entry
*
3036 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3038 struct bfd_link_hash_entry
*h
= NULL
;
3039 struct key_value
*kv
;
3040 struct key_value key
;
3041 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3043 strcpy (lname
, name
);
3045 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3050 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3055 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3056 if (h
->type
== bfd_link_hash_undefined
)
3060 if (lname
[0] == '?')
3063 if (at
|| lname
[0] == '@')
3065 if (lname
[0] == '@')
3067 if (pe_details
->underscored
)
3070 /* Use memmove rather than strcpy as that
3071 can handle overlapping buffers. */
3072 memmove (lname
, lname
+ 1, strlen (lname
));
3074 kv
= bsearch (&key
, udef_table
, undef_count
,
3075 sizeof (struct key_value
), undef_sort_cmp
);
3078 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3079 if (h
->type
== bfd_link_hash_undefined
)
3084 *strchr (lname
, '@') = 0;
3086 kv
= bsearch (&key
, udef_table
, undef_count
,
3087 sizeof (struct key_value
), undef_sort_cmp
);
3090 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3091 if (h
->type
== bfd_link_hash_undefined
)
3097 strcat (lname
, "@");
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
)
3109 if (lname
[0] == '_' && pe_details
->underscored
)
3113 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3118 kv
= bsearch (&key
, udef_table
, undef_count
,
3119 sizeof (struct key_value
), undef_sort_cmp
);
3123 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, false, false, false);
3124 if (h
->type
== bfd_link_hash_undefined
)
3136 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3137 void *inf ATTRIBUTE_UNUSED
)
3139 if (h
->type
== bfd_link_hash_undefined
)
3145 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3147 if (h
->type
== bfd_link_hash_undefined
)
3151 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3152 at
= strchr (udef_table
[undef_count
].key
3153 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3156 udef_table
[undef_count
].oname
= h
->root
.string
;
3163 pe_create_undef_table (void)
3167 /* count undefined symbols */
3169 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3171 /* create and fill the corresponding table */
3172 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3175 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3178 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3182 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3184 lang_input_statement_type
*fake_file
;
3186 fake_file
= lang_add_input_file (name
,
3187 lang_input_file_is_fake_enum
,
3189 fake_file
->the_bfd
= abfd
;
3190 ldlang_add_file (fake_file
);
3192 if (!bfd_link_add_symbols (abfd
, linfo
))
3193 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3197 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3199 pe_dll_id_target (bfd_get_target (output_bfd
));
3204 def_file_module
*module
;
3205 def_file_import
*imp
;
3207 imp
= pe_def_file
->imports
;
3209 pe_create_undef_table ();
3211 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3213 int do_this_dll
= 0;
3215 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
3216 if (imp
[i
].module
== module
)
3218 if (i
>= pe_def_file
->num_imports
)
3221 dll_filename
= module
->name
;
3222 dll_symname
= xstrdup (module
->name
);
3223 for (j
= 0; dll_symname
[j
]; j
++)
3224 if (!ISALNUM (dll_symname
[j
]))
3225 dll_symname
[j
] = '_';
3227 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3229 def_file_export exp
;
3230 struct bfd_link_hash_entry
*blhe
;
3231 int lead_at
= (*imp
[i
].internal_name
== '@');
3232 /* See if we need this import. */
3233 size_t len
= strlen (imp
[i
].internal_name
);
3234 char *name
= xmalloc (len
+ 2 + 6);
3235 bool include_jmp_stub
= false;
3236 bool is_cdecl
= false;
3237 bool is_undef
= false;
3239 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3243 sprintf (name
, "%s", imp
[i
].internal_name
);
3245 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3247 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3248 false, false, false);
3250 /* Include the jump stub for <sym> only if the <sym>
3252 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3255 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3257 sprintf (name
, "%s%s%s", "__imp_", U (""),
3258 imp
[i
].internal_name
);
3260 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3261 false, false, false);
3263 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3267 include_jmp_stub
= true;
3268 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3272 && (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3274 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3275 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3276 include_jmp_stub
= true;
3278 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3289 bfd
*ar_head
= make_head (output_bfd
);
3290 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
),
3294 exp
.internal_name
= imp
[i
].internal_name
;
3295 exp
.name
= imp
[i
].name
;
3296 exp
.its_name
= imp
[i
].its_name
;
3297 exp
.ordinal
= imp
[i
].ordinal
;
3298 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3299 exp
.flag_private
= 0;
3300 exp
.flag_constant
= 0;
3301 exp
.flag_data
= imp
[i
].data
;
3302 exp
.flag_noname
= exp
.name
? 0 : 1;
3303 one
= make_one (&exp
, output_bfd
,
3304 !exp
.flag_data
&& include_jmp_stub
);
3305 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3310 bfd
*ar_tail
= make_tail (output_bfd
);
3311 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3320 free (udef_table
[undef_count
].key
);
3325 if (pe_def_file
&& pe_def_file
->name
)
3326 dll_filename
= pe_def_file
->name
;
3329 dll_filename
= bfd_get_filename (output_bfd
);
3330 for (const char *p
= dll_filename
; *p
; p
++)
3331 if (*p
== '\\' || *p
== '/' || *p
== ':')
3332 dll_filename
= p
+ 1;
3334 dll_symname
= xstrdup (dll_filename
);
3335 for (int i
= 0; dll_symname
[i
]; i
++)
3336 if (!ISALNUM (dll_symname
[i
]))
3337 dll_symname
[i
] = '_';
3340 /* We were handed a *.DLL file. Parse it and turn it into a set of
3341 IMPORTS directives in the def file. Return TRUE if the file was
3342 handled, FALSE if not. */
3345 pe_get16 (bfd
*abfd
, int where
)
3349 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3350 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3351 return b
[0] + (b
[1] << 8);
3355 pe_get32 (bfd
*abfd
, int where
)
3359 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3360 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3361 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3367 unsigned char *b
= ptr
;
3369 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3373 pe_implied_import_dll (const char *filename
)
3376 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3377 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3378 bfd_vma exp_funcbase
;
3379 unsigned char *expdata
;
3381 bfd_vma name_rvas
, nexp
;
3382 const char *dllname
;
3383 /* Initialization with start > end guarantees that is_data
3384 will not be set by mistake, and avoids compiler warning. */
3385 bfd_vma data_start
= 1;
3386 bfd_vma data_end
= 0;
3387 bfd_vma rdata_start
= 1;
3388 bfd_vma rdata_end
= 0;
3389 bfd_vma bss_start
= 1;
3390 bfd_vma bss_end
= 0;
3393 /* No, I can't use bfd here. kernel32.dll puts its export table in
3394 the middle of the .rdata section. */
3395 dll
= bfd_openr (filename
, pe_details
->target_name
);
3398 einfo (_("%X%P: open %s: %E\n"), filename
);
3402 track_dependency_files (filename
);
3404 /* PEI dlls seem to be bfd_objects. */
3405 if (!bfd_check_format (dll
, bfd_object
))
3407 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3411 /* Get pe_header, optional header and numbers of directory entries. */
3412 pe_header_offset
= pe_get32 (dll
, 0x3c);
3413 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3414 #ifdef pe_use_x86_64
3415 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3417 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3420 /* No import or export directory entry. */
3421 if (num_entries
< 1)
3424 #ifdef pe_use_x86_64
3425 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3426 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3428 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3429 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3432 /* No export table - nothing to export. */
3433 if (export_size
== 0)
3436 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3437 secptr
= (pe_header_offset
+ 4 + 20 +
3438 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3441 /* Get the rva and size of the export section. */
3442 for (i
= 0; i
< nsections
; i
++)
3445 bfd_vma secptr1
= secptr
+ 40 * i
;
3446 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3447 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3448 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3450 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3451 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3453 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3455 expptr
= fptr
+ (export_rva
- vaddr
);
3456 if (export_rva
+ export_size
> vaddr
+ vsize
)
3457 export_size
= vsize
- (export_rva
- vaddr
);
3462 /* Scan sections and store the base and size of the
3463 data and bss segments in data/base_start/end. */
3464 for (i
= 0; i
< nsections
; i
++)
3466 bfd_vma secptr1
= secptr
+ 40 * i
;
3467 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3468 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3469 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3473 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3474 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3476 if (strcmp(sec_name
,".data") == 0)
3479 data_end
= vaddr
+ vsize
;
3481 if (pe_dll_extra_pe_debug
)
3482 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3483 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3484 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3486 else if (strcmp(sec_name
,".rdata") == 0)
3488 rdata_start
= vaddr
;
3489 rdata_end
= vaddr
+ vsize
;
3491 if (pe_dll_extra_pe_debug
)
3492 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3493 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3494 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3496 else if (strcmp (sec_name
,".bss") == 0)
3499 bss_end
= vaddr
+ vsize
;
3501 if (pe_dll_extra_pe_debug
)
3502 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3503 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3504 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3508 expdata
= xmalloc (export_size
);
3509 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3510 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3511 erva
= (char *) expdata
- export_rva
;
3513 if (pe_def_file
== 0)
3514 pe_def_file
= def_file_empty ();
3516 nexp
= pe_as32 (expdata
+ 24);
3517 name_rvas
= pe_as32 (expdata
+ 32);
3518 exp_funcbase
= pe_as32 (expdata
+ 28);
3520 /* Use internal dll name instead of filename
3521 to enable symbolic dll linking. */
3522 dllname
= erva
+ pe_as32 (expdata
+ 12);
3524 /* Check to see if the dll has already been added to
3525 the definition list and if so return without error.
3526 This avoids multiple symbol definitions. */
3527 if (def_get_module (pe_def_file
, dllname
))
3529 if (pe_dll_extra_pe_debug
)
3530 printf ("%s is already loaded\n", dllname
);
3534 /* This is an optimized version of the insertion loop, which avoids lots of
3535 calls to realloc and memmove from def_file_add_import. */
3536 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3537 erva
+ pe_as32 (erva
+ name_rvas
),
3538 dllname
, 0, NULL
, NULL
)) >= 0)
3540 for (i
= 0; i
< nexp
; i
++)
3542 /* Pointer to the names vector. */
3543 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3544 def_file_import
*imp
;
3545 /* Pointer to the function address vector. */
3546 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3547 /* is_data is true if the address is in the data, rdata or bss
3550 (func_rva
>= data_start
&& func_rva
< data_end
)
3551 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3552 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3554 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3555 dllname
, i
, NULL
, NULL
);
3556 /* 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)" : "");
3568 /* Iterate through the list of symbols. */
3569 for (i
= 0; i
< nexp
; i
++)
3571 /* Pointer to the names vector. */
3572 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3573 def_file_import
*imp
;
3574 /* Pointer to the function address vector. */
3575 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3578 /* Skip unwanted symbols, which are
3579 exported in buggy auto-import releases. */
3580 if (! startswith (erva
+ name_rva
, "__nm_"))
3582 bool is_dup
= false;
3583 /* is_data is true if the address is in the data, rdata or bss
3586 (func_rva
>= data_start
&& func_rva
< data_end
)
3587 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3588 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3590 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3591 dllname
, i
, NULL
, NULL
, &is_dup
);
3592 /* Mark symbol type. */
3594 imp
->data
= is_data
;
3596 if (pe_dll_extra_pe_debug
)
3597 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3598 __FUNCTION__
, dllname
, erva
+ name_rva
,
3599 (unsigned long) func_rva
, is_data
? "(data)" : "");
3607 pe_output_file_set_long_section_names (bfd
*abfd
)
3609 if (pe_use_coff_long_section_names
< 0)
3611 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3612 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3615 /* These are the main functions, called from the emulation. The first
3616 is called after the bfds are read, so we can guess at how much space
3617 we need. The second is called after everything is placed, so we
3618 can put the right values in place. */
3621 pe_dll_build_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 process_def_file_and_drectve (abfd
, info
);
3627 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3629 if (pe_dll_enable_reloc_section
)
3631 build_filler_bfd (0);
3632 pe_output_file_set_long_section_names (filler_bfd
);
3638 build_filler_bfd (1);
3639 pe_output_file_set_long_section_names (filler_bfd
);
3643 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3645 pe_dll_id_target (bfd_get_target (abfd
));
3646 pe_output_file_set_long_section_names (abfd
);
3647 build_filler_bfd (0);
3648 pe_output_file_set_long_section_names (filler_bfd
);
3652 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3654 pe_exe_fill_sections (abfd
, info
);
3658 fill_edata (abfd
, info
);
3659 edata_s
->contents
= edata_d
;
3662 if (bfd_link_dll (info
))
3663 pe_data (abfd
)->dll
= 1;
3667 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3669 pe_dll_id_target (bfd_get_target (abfd
));
3670 pe_output_file_set_long_section_names (abfd
);
3671 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3673 generate_reloc (abfd
, info
);
3676 bfd_set_section_size (reloc_s
, reloc_sz
);
3678 /* Resize the sections. */
3679 lang_reset_memory_regions ();
3680 lang_size_sections (NULL
, true);
3682 /* Redo special stuff. */
3683 ldemul_after_allocation ();
3685 /* Do the assignments again. */
3686 lang_do_assignments (lang_final_phase_enum
);
3689 reloc_s
->contents
= reloc_d
;
3693 pe_bfd_is_dll (bfd
*abfd
)
3695 return (bfd_get_format (abfd
) == bfd_object
3697 && pe_data (abfd
)->dll
);