1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998-2020 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
= 0;
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 (CONST_STRNEQ (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 (bsearch (&key
, d
->exports
, d
->num_exports
,
569 sizeof (pe_def_file
->exports
[0]), pe_export_sort
))
572 if (pe_dll_do_default_excludes
)
577 if (pe_dll_extra_pe_debug
)
578 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
579 n
, abfd
, abfd
->my_archive
);
581 /* First of all, make context checks:
582 Don't export anything from standard libs. */
585 afptr
= autofilter_liblist
;
589 if (libnamencmp (libname
, afptr
) == 0 )
595 /* Next, exclude symbols from certain startup objects. */
597 if (abfd
&& (p
= lbasename (bfd_get_filename (abfd
))))
599 afptr
= autofilter_objlist
;
602 if (strcmp (p
, afptr
->name
) == 0)
608 /* Don't try to blindly exclude all symbols
609 that begin with '__'; this was tried and
610 it is too restrictive. Instead we have
611 a target specific list to use: */
612 afptr
= pe_details
->autofilter_symbollist
;
616 if (strcmp (n
, afptr
->name
) == 0)
622 /* Next, exclude symbols starting with ... */
623 afptr
= autofilter_symbolprefixlist
;
626 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
632 /* Finally, exclude symbols ending with ... */
634 afptr
= autofilter_symbolsuffixlist
;
637 if ((len
>= afptr
->len
)
638 /* Add 1 to insure match with trailing '\0'. */
639 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
640 afptr
->len
+ 1) == 0)
647 for (ex
= excludes
; ex
; ex
= ex
->next
)
649 if (ex
->type
== EXCLUDELIBS
)
652 && ((filename_cmp (libname
, ex
->string
) == 0)
653 || (strcasecmp ("ALL", ex
->string
) == 0)))
656 else if (ex
->type
== EXCLUDEFORIMPLIB
)
658 if (filename_cmp (bfd_get_filename (abfd
), ex
->string
) == 0)
661 else if (strcmp (n
, ex
->string
) == 0)
669 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
672 struct bfd_link_hash_entry
*blhe
;
674 struct bfd_section
*s
;
675 def_file_export
*e
= 0;
676 bfd_boolean resort_needed
;
679 pe_def_file
= def_file_empty ();
681 /* First, run around to all the objects looking for the .drectve
682 sections, and push those into the def file too. */
683 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
685 s
= bfd_get_section_by_name (b
, ".drectve");
689 char *buf
= xmalloc (size
);
691 bfd_get_section_contents (b
, s
, buf
, 0, size
);
692 def_file_add_directive (pe_def_file
, buf
, size
);
697 /* Process aligned common symbol information from the
698 .drectve sections now; common symbol allocation is
699 done before final link, so it will be too late to
700 process them in process_embedded_commands() called
701 from _bfd_coff_link_input_bfd(). */
702 if (pe_def_file
->aligncomms
)
704 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
707 struct coff_link_hash_entry
*sym_hash
;
708 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
709 ac
->symbol_name
, FALSE
, FALSE
, FALSE
);
710 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
711 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
713 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
719 /* If we are building an executable and there is nothing
720 to export, we do not build an export table at all. */
721 if (bfd_link_executable (info
) && pe_def_file
->num_exports
== 0
722 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
725 /* Now, maybe export everything else the default way. */
726 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
727 && !pe_dll_exclude_all_symbols
)
729 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
734 if (!bfd_generic_link_read_symbols (b
))
736 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
740 symbols
= bfd_get_outsymbols (b
);
741 nsyms
= bfd_get_symcount (b
);
743 for (j
= 0; j
< nsyms
; j
++)
745 /* We should export symbols which are either global or not
746 anything at all. (.bss data is the latter)
747 We should not export undefined symbols. */
748 bfd_boolean would_export
749 = (symbols
[j
]->section
!= bfd_und_section_ptr
750 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
751 || (symbols
[j
]->flags
== 0)));
752 if (link_info
.version_info
&& would_export
)
754 = !bfd_hide_sym_by_version (link_info
.version_info
,
758 const char *sn
= symbols
[j
]->name
;
760 /* We should not re-export imported stuff. */
766 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
767 sprintf (name
, "%s%s", "__imp_", sn
);
769 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
770 FALSE
, FALSE
, FALSE
);
773 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
777 if (pe_details
->underscored
&& *sn
== '_')
780 if (auto_export (b
, pe_def_file
, sn
))
785 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
787 /* Fill data flag properly, from dlltool.c. */
789 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
797 #define NE pe_def_file->num_exports
799 /* Don't create an empty export table. */
803 resort_needed
= FALSE
;
805 /* Canonicalize the export list. */
808 for (i
= 0; i
< NE
; i
++)
810 /* Check for fastcall/stdcall-decoration, but ignore
811 C++ mangled names. */
812 if (pe_def_file
->exports
[i
].name
[0] != '?'
813 && strchr (pe_def_file
->exports
[i
].name
, '@'))
815 /* This will preserve internal_name, which may have been
816 pointing to the same memory as name, or might not
818 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
819 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
820 char *tmp_at
= strrchr (tmp
, '@');
825 einfo (_("%X%P: cannot export %s: invalid export name\n"),
826 pe_def_file
->exports
[i
].name
);
827 pe_def_file
->exports
[i
].name
= tmp
;
828 resort_needed
= TRUE
;
833 /* Re-sort the exports table as we have possibly changed the order
834 by removing leading @. */
836 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
839 if (pe_dll_stdcall_aliases
)
841 for (i
= 0; i
< NE
; i
++)
843 if (is_import (pe_def_file
->exports
[i
].name
))
846 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
849 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
850 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
852 *(strchr (tmp
, '@')) = 0;
853 if (auto_export (NULL
, pe_def_file
, tmp
))
854 def_file_add_export (pe_def_file
, tmp
,
855 pe_def_file
->exports
[i
].internal_name
,
863 /* Convenience, but watch out for it changing. */
864 e
= pe_def_file
->exports
;
866 for (i
= 0, j
= 0; i
< NE
; i
++)
868 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
870 /* This is a duplicate. */
871 if (e
[j
- 1].ordinal
!= -1
872 && e
[i
].ordinal
!= -1
873 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
875 if (pe_dll_warn_dup_exports
)
876 /* xgettext:c-format */
877 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
878 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
882 if (pe_dll_warn_dup_exports
)
883 /* xgettext:c-format */
884 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
888 if (e
[i
].ordinal
!= -1)
889 e
[j
- 1].ordinal
= e
[i
].ordinal
;
890 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
891 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
892 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
893 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
896 if (e
[i
].internal_name
)
897 free (e
[i
].internal_name
);
899 free (e
[i
].its_name
);
908 pe_def_file
->num_exports
= j
; /* == NE */
910 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
911 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
913 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
917 count_exported_byname
= 0;
918 count_with_ordinals
= 0;
920 for (i
= 0; i
< NE
; i
++)
922 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
925 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
926 lang_add_gc_name (int_name
);
928 name
= xmalloc (strlen (int_name
) + 2);
929 if (pe_details
->underscored
&& int_name
[0] != '@')
932 strcpy (name
+ 1, int_name
);
934 /* PR 19803: The alias must be preserved as well. */
935 lang_add_gc_name (xstrdup (name
));
938 strcpy (name
, int_name
);
940 blhe
= bfd_link_hash_lookup (info
->hash
,
945 && (blhe
->type
== bfd_link_hash_defined
946 || (blhe
->type
== bfd_link_hash_common
)))
949 if (!pe_def_file
->exports
[i
].flag_noname
)
950 count_exported_byname
++;
952 /* Only fill in the sections. The actual offsets are computed
953 in fill_exported_offsets() after common symbols are laid
955 if (blhe
->type
== bfd_link_hash_defined
)
956 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
958 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
960 if (pe_def_file
->exports
[i
].ordinal
!= -1)
962 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
963 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
964 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
965 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
966 count_with_ordinals
++;
969 /* Check for forward exports. These are indicated in DEF files by an
970 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
971 but we must take care not to be fooled when the user wants to export
972 a symbol that actually really has a dot in it, so we only check
973 for them here, after real defined symbols have already been matched. */
974 else if (strchr (int_name
, '.'))
977 if (!pe_def_file
->exports
[i
].flag_noname
)
978 count_exported_byname
++;
980 pe_def_file
->exports
[i
].flag_forward
= 1;
982 if (pe_def_file
->exports
[i
].ordinal
!= -1)
984 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
985 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
986 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
987 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
988 count_with_ordinals
++;
991 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
993 /* xgettext:c-format */
994 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
999 /* xgettext:c-format */
1000 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
1002 blhe
->type
, bfd_link_hash_defined
);
1006 /* xgettext:c-format */
1007 einfo (_("%X%P: cannot export %s: symbol not found\n"),
1014 /* Build the bfd that will contain .edata and .reloc sections. */
1017 build_filler_bfd (int include_edata
)
1019 lang_input_statement_type
*filler_file
;
1020 filler_file
= lang_add_input_file ("dll stuff",
1021 lang_input_file_is_fake_enum
,
1023 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1024 link_info
.output_bfd
);
1025 if (filler_bfd
== NULL
1026 || !bfd_set_arch_mach (filler_bfd
,
1027 bfd_get_arch (link_info
.output_bfd
),
1028 bfd_get_mach (link_info
.output_bfd
)))
1030 einfo (_("%F%P: can not create BFD: %E\n"));
1036 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1038 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1044 einfo (_("%X%P: can not create .edata section: %E\n"));
1047 bfd_set_section_size (edata_s
, edata_sz
);
1050 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1052 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1058 einfo (_("%X%P: can not create .reloc section: %E\n"));
1062 bfd_set_section_size (reloc_s
, 0);
1064 ldlang_add_file (filler_file
);
1067 /* Gather all the exported symbols and build the .edata section. */
1070 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1072 int i
, next_ordinal
;
1073 int name_table_size
= 0;
1076 /* First, we need to know how many exported symbols there are,
1077 and what the range of ordinals is. */
1078 if (pe_def_file
->name
)
1079 dll_name
= pe_def_file
->name
;
1082 dll_name
= bfd_get_filename (abfd
);
1084 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1085 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1086 dll_name
= dlnp
+ 1;
1089 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1091 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1092 min_ordinal
= max_ordinal
- count_exported
+ 1;
1097 max_ordinal
= count_exported
;
1100 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1101 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1102 for (i
= 0; i
< export_table_size
; i
++)
1103 exported_symbols
[i
] = -1;
1105 /* Now we need to assign ordinals to those that don't have them. */
1106 for (i
= 0; i
< NE
; i
++)
1108 if (exported_symbol_sections
[i
]
1109 || pe_def_file
->exports
[i
].flag_forward
)
1111 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1113 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1114 int pi
= exported_symbols
[ei
];
1118 /* xgettext:c-format */
1119 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1120 pe_def_file
->exports
[i
].ordinal
,
1121 pe_def_file
->exports
[i
].name
,
1122 pe_def_file
->exports
[pi
].name
);
1124 exported_symbols
[ei
] = i
;
1126 if (pe_def_file
->exports
[i
].its_name
)
1127 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1129 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1132 /* Reserve space for the forward name. */
1133 if (pe_def_file
->exports
[i
].flag_forward
)
1135 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1139 next_ordinal
= min_ordinal
;
1140 for (i
= 0; i
< NE
; i
++)
1141 if ((exported_symbol_sections
[i
]
1142 || pe_def_file
->exports
[i
].flag_forward
)
1143 && pe_def_file
->exports
[i
].ordinal
== -1)
1145 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1148 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1149 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1152 /* PR 12969: Check for more than 1^16 ordinals. */
1153 if (max_ordinal
> 65535 || next_ordinal
> 65535)
1154 /* xgettext:c-format */
1155 einfo(_("%X%P: error: export ordinal too large: %d\n"),
1156 max_ordinal
> next_ordinal
? max_ordinal
: next_ordinal
);
1158 /* OK, now we can allocate some memory. */
1159 edata_sz
= (40 /* directory */
1160 + 4 * export_table_size
/* addresses */
1161 + 4 * count_exported_byname
/* name ptrs */
1162 + 2 * count_exported_byname
/* ordinals */
1163 + name_table_size
+ strlen (dll_name
) + 1);
1166 /* Fill the exported symbol offsets. The preliminary work has already
1167 been done in process_def_file_and_drectve(). */
1170 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1173 struct bfd_link_hash_entry
*blhe
;
1175 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1179 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1180 if (pe_details
->underscored
1181 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1184 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1187 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1189 blhe
= bfd_link_hash_lookup (info
->hash
,
1191 FALSE
, FALSE
, TRUE
);
1193 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1194 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1201 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1204 unsigned char *edirectory
;
1205 unsigned char *eaddresses
;
1206 unsigned char *enameptrs
;
1207 unsigned char *eordinals
;
1210 edata_d
= xmalloc (edata_sz
);
1212 /* Note use of array pointer math here. */
1213 edirectory
= edata_d
;
1214 eaddresses
= edirectory
+ 40;
1215 enameptrs
= eaddresses
+ 4 * export_table_size
;
1216 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1217 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1219 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1220 + edata_s->output_section->vma - image_base)
1222 memset (edata_d
, 0, edata_sz
);
1224 if (pe_data (abfd
)->timestamp
== -1)
1225 H_PUT_32 (abfd
, time (0), edata_d
+ 4);
1227 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, edata_d
+ 4);
1229 if (pe_def_file
->version_major
!= -1)
1231 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1232 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1235 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1236 strcpy (enamestr
, dll_name
);
1237 enamestr
+= strlen (enamestr
) + 1;
1238 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1239 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1240 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1241 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1242 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1243 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1245 fill_exported_offsets (abfd
, info
);
1247 /* Ok, now for the filling in part.
1248 Scan alphabetically - ie the ordering in the exports[] table,
1249 rather than by ordinal - the ordering in the exported_symbol[]
1250 table. See dlltool.c and:
1251 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1252 for more information. */
1254 for (s
= 0; s
< NE
; s
++)
1256 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1257 if (pe_def_file
->exports
[s
].ordinal
!= -1
1258 && (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1260 int ord
= pe_def_file
->exports
[s
].ordinal
;
1262 if (pe_def_file
->exports
[s
].flag_forward
)
1264 bfd_put_32 (abfd
, ERVA (enamestr
),
1265 eaddresses
+ 4 * (ord
- min_ordinal
));
1267 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1268 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1272 bfd_vma srva
= (exported_symbol_offsets
[s
]
1273 + ssec
->output_section
->vma
1274 + ssec
->output_offset
);
1276 bfd_put_32 (abfd
, srva
- image_base
,
1277 eaddresses
+ 4 * (ord
- min_ordinal
));
1280 if (!pe_def_file
->exports
[s
].flag_noname
)
1282 char *ename
= pe_def_file
->exports
[s
].name
;
1283 if (pe_def_file
->exports
[s
].its_name
)
1284 ename
= pe_def_file
->exports
[s
].its_name
;
1286 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1288 strcpy (enamestr
, ename
);
1289 enamestr
+= strlen (enamestr
) + 1;
1290 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1292 pe_def_file
->exports
[s
].hint
= hint
++;
1299 static struct bfd_section
*current_sec
;
1302 pe_walk_relocs (struct bfd_link_info
*info
,
1304 const char *symname
,
1305 struct bfd_hash_table
*import_hash
,
1306 void (*cb
) (arelent
*, asection
*, char *, const char *))
1311 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1315 if (!bfd_generic_link_read_symbols (b
))
1317 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1321 symbols
= bfd_get_outsymbols (b
);
1323 for (s
= b
->sections
; s
; s
= s
->next
)
1326 int relsize
, nrelocs
, i
;
1327 int flags
= bfd_section_flags (s
);
1329 /* Skip discarded linkonce sections. */
1330 if (flags
& SEC_LINK_ONCE
1331 && s
->output_section
== bfd_abs_section_ptr
)
1336 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1337 relocs
= xmalloc (relsize
);
1338 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1340 for (i
= 0; i
< nrelocs
; i
++)
1342 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1344 /* Warning: the callback needs to be passed NAME directly. */
1347 if (bfd_hash_lookup (import_hash
, sym
->name
, FALSE
, FALSE
))
1349 strcpy (name
, sym
->name
);
1350 cb (relocs
[i
], s
, name
, symname
);
1355 if (strcmp (name
, sym
->name
) == 0)
1356 cb (relocs
[i
], s
, name
, symname
);
1362 /* Warning: the allocated symbols are remembered in BFD and reused
1363 later, so don't free them! */
1364 /* free (symbols); */
1370 pe_find_data_imports (const char *symhead
,
1371 void (*cb
) (arelent
*, asection
*, char *, const char *))
1373 struct bfd_link_hash_entry
*undef
;
1374 const size_t headlen
= strlen (symhead
);
1377 struct bfd_hash_table
*import_hash
;
1379 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1380 if (undef
->type
== bfd_link_hash_undefined
)
1382 size_t len
= strlen (undef
->root
.string
);
1389 /* For the pseudo-relocation support version 2, we can collect the symbols
1390 that are subject to auto-import and adjust the relocations en masse. */
1391 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
1394 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
1395 if (!bfd_hash_table_init (import_hash
,
1397 sizeof (struct bfd_hash_entry
)))
1398 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1403 /* We are being a bit cunning here. The buffer will have space for
1404 prefixes at the beginning. The prefix is modified here and in a
1405 number of functions called from this function. */
1406 #define PREFIX_LEN 32
1407 buf
= xmalloc (PREFIX_LEN
+ namelen
+ 1);
1408 name
= buf
+ PREFIX_LEN
;
1410 for (undef
= link_info
.hash
->undefs
; undef
; undef
= undef
->u
.undef
.next
)
1411 if (undef
->type
== bfd_link_hash_undefined
)
1413 struct bfd_link_hash_entry
*sym
;
1416 if (pe_dll_extra_pe_debug
)
1417 printf ("%s:%s\n", __FUNCTION__
, undef
->root
.string
);
1419 strcpy (name
, undef
->root
.string
);
1420 impname
= name
- (sizeof "__imp_" - 1);
1421 memcpy (impname
, "__imp_", sizeof "__imp_" - 1);
1423 sym
= bfd_link_hash_lookup (link_info
.hash
, impname
, 0, 0, 1);
1425 if (sym
&& sym
->type
== bfd_link_hash_defined
)
1428 bfd_hash_lookup (import_hash
, undef
->root
.string
, TRUE
, FALSE
);
1431 bfd
*b
= sym
->u
.def
.section
->owner
;
1432 const char *symname
= NULL
;
1436 if (!bfd_generic_link_read_symbols (b
))
1438 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1442 symbols
= bfd_get_outsymbols (b
);
1443 nsyms
= bfd_get_symcount (b
);
1445 for (i
= 0; i
< nsyms
; i
++)
1446 if (strncmp (symbols
[i
]->name
, symhead
, headlen
) == 0)
1448 if (pe_dll_extra_pe_debug
)
1449 printf ("->%s\n", symbols
[i
]->name
);
1451 symname
= symbols
[i
]->name
+ headlen
;
1455 /* If the symobl isn't part of an import table, there is no
1456 point in building a fixup, this would give rise to link
1457 errors for mangled symbols instead of the original one. */
1459 pe_walk_relocs (&link_info
, name
, symname
, NULL
, cb
);
1464 /* Let's differentiate it somehow from defined. */
1465 undef
->type
= bfd_link_hash_defweak
;
1466 undef
->u
.def
.value
= sym
->u
.def
.value
;
1467 undef
->u
.def
.section
= sym
->u
.def
.section
;
1469 /* We replace the original name with the __imp_ prefixed one, this
1470 1) may trash memory 2) leads to duplicate symbols. But this is
1471 better than having a misleading name that can confuse GDB. */
1472 undef
->root
.string
= sym
->root
.string
;
1474 if (link_info
.pei386_auto_import
== -1)
1476 static bfd_boolean warned
= FALSE
;
1478 info_msg (_("Info: resolving %s by linking to %s "
1479 "(auto-import)\n"), name
, impname
);
1481 /* PR linker/4844. */
1484 einfo (_("%P: warning: auto-importing has been activated "
1485 "without --enable-auto-import specified on the "
1486 "command line; this should work unless it "
1487 "involves constant data structures referencing "
1488 "symbols from auto-imported DLLs\n"));
1495 /* If we have the import hash table, walk the relocations only once. */
1498 pe_walk_relocs (&link_info
, name
, NULL
, import_hash
, cb
);
1499 bfd_hash_table_free (import_hash
);
1506 /* Gather all the relocations and build the .reloc section. */
1509 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1512 /* For .reloc stuff. */
1513 reloc_data_type
*reloc_data
;
1514 int total_relocs
= 0;
1516 bfd_vma sec_page
= (bfd_vma
) -1;
1517 bfd_vma page_ptr
, page_count
;
1520 struct bfd_section
*s
;
1523 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1524 for (s
= b
->sections
; s
; s
= s
->next
)
1525 total_relocs
+= s
->reloc_count
;
1527 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1531 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1534 int relsize
, nrelocs
;
1536 for (s
= b
->sections
; s
; s
= s
->next
)
1538 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1541 /* If it's not loaded, we don't need to relocate it this way. */
1542 if (!(s
->output_section
->flags
& SEC_LOAD
))
1545 /* I don't know why there would be a reloc for these, but I've
1546 seen it happen - DJ */
1547 if (s
->output_section
== bfd_abs_section_ptr
)
1550 if (s
->output_section
->vma
== 0)
1552 /* Huh? Shouldn't happen, but punt if it does. */
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
);
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
;
1582 /* Don't create relocs for undefined weak symbols. */
1583 if (sym
->flags
== BSF_WEAK
)
1585 struct bfd_link_hash_entry
*blhe
1586 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1587 FALSE
, FALSE
, FALSE
);
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"))
1620 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1621 reloc_data
[total_relocs
].idx
= total_relocs
;
1623 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1625 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1626 relocs
[i
]->howto
->rightshift
)
1628 #ifdef pe_use_x86_64
1629 case BITS_AND_SHIFT (64, 0):
1630 reloc_data
[total_relocs
].type
= 10;
1634 case BITS_AND_SHIFT (32, 0):
1635 reloc_data
[total_relocs
].type
= 3;
1638 case BITS_AND_SHIFT (16, 0):
1639 reloc_data
[total_relocs
].type
= 2;
1642 case BITS_AND_SHIFT (16, 16):
1643 reloc_data
[total_relocs
].type
= 4;
1644 /* FIXME: we can't know the symbol's right value
1645 yet, but we probably can safely assume that
1646 CE will relocate us in 64k blocks, so leaving
1648 reloc_data
[total_relocs
].extra
= 0;
1651 case BITS_AND_SHIFT (26, 2):
1652 reloc_data
[total_relocs
].type
= 5;
1655 case BITS_AND_SHIFT (24, 2):
1656 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1657 Those ARM_xxx definitions should go in proper
1659 if (relocs
[i
]->howto
->type
== 0
1660 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1661 || relocs
[i
]->howto
->type
== 5)
1662 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1663 that has already been fully processed during a
1664 previous link stage, so ignore it here. */
1668 /* xgettext:c-format */
1669 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1670 relocs
[i
]->howto
->bitsize
);
1676 /* Warning: the allocated symbols are remembered in BFD and
1677 reused later, so don't free them! */
1681 /* At this point, we have total_relocs relocation addresses in
1682 reloc_addresses, which are all suitable for the .reloc section.
1683 We must now create the new sections. */
1684 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1686 for (i
= 0; i
< total_relocs
; i
++)
1688 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1690 if (this_page
!= sec_page
)
1692 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1694 sec_page
= this_page
;
1699 if (reloc_data
[i
].type
== 4)
1703 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1704 reloc_d
= xmalloc (reloc_sz
);
1705 sec_page
= (bfd_vma
) -1;
1707 page_ptr
= (bfd_vma
) -1;
1710 for (i
= 0; i
< total_relocs
; i
++)
1712 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1713 bfd_vma this_page
= (rva
& ~0xfff);
1715 if (this_page
!= sec_page
)
1717 while (reloc_sz
& 3)
1718 reloc_d
[reloc_sz
++] = 0;
1720 if (page_ptr
!= (bfd_vma
) -1)
1721 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1723 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1724 page_ptr
= reloc_sz
;
1726 sec_page
= this_page
;
1730 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1731 reloc_d
+ reloc_sz
);
1734 if (reloc_data
[i
].type
== 4)
1736 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1743 while (reloc_sz
& 3)
1744 reloc_d
[reloc_sz
++] = 0;
1746 if (page_ptr
!= (bfd_vma
) -1)
1747 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1749 while (reloc_sz
< reloc_s
->size
)
1750 reloc_d
[reloc_sz
++] = 0;
1753 /* Given the exiting def_file structure, print out a .DEF file that
1754 corresponds to it. */
1757 quoteput (char *s
, FILE *f
, int needs_quotes
)
1761 for (cp
= s
; *cp
; cp
++)
1776 if (*s
== '"' || *s
== '\\')
1790 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1793 FILE *out
= fopen (pe_out_def_filename
, "w");
1796 /* xgettext:c-format */
1797 einfo (_("%P: can't open output def file %s\n"),
1798 pe_out_def_filename
);
1802 if (pe_def_file
->name
)
1804 if (pe_def_file
->is_dll
)
1805 fprintf (out
, "LIBRARY ");
1807 fprintf (out
, "NAME ");
1809 quoteput (pe_def_file
->name
, out
, 1);
1811 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1813 fprintf (out
, " BASE=0x");
1814 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1816 fprintf (out
, "\n");
1819 if (pe_def_file
->description
)
1821 fprintf (out
, "DESCRIPTION ");
1822 quoteput (pe_def_file
->description
, out
, 1);
1823 fprintf (out
, "\n");
1826 if (pe_def_file
->version_minor
!= -1)
1827 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1828 pe_def_file
->version_minor
);
1829 else if (pe_def_file
->version_major
!= -1)
1830 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1832 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1833 fprintf (out
, "\n");
1835 if (pe_def_file
->stack_commit
!= -1)
1836 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1837 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1838 else if (pe_def_file
->stack_reserve
!= -1)
1839 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1841 if (pe_def_file
->heap_commit
!= -1)
1842 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1843 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1844 else if (pe_def_file
->heap_reserve
!= -1)
1845 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1847 if (pe_def_file
->num_section_defs
> 0)
1849 fprintf (out
, "\nSECTIONS\n\n");
1851 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1854 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1856 if (pe_def_file
->section_defs
[i
].class)
1858 fprintf (out
, " CLASS ");
1859 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1862 if (pe_def_file
->section_defs
[i
].flag_read
)
1863 fprintf (out
, " READ");
1865 if (pe_def_file
->section_defs
[i
].flag_write
)
1866 fprintf (out
, " WRITE");
1868 if (pe_def_file
->section_defs
[i
].flag_execute
)
1869 fprintf (out
, " EXECUTE");
1871 if (pe_def_file
->section_defs
[i
].flag_shared
)
1872 fprintf (out
, " SHARED");
1874 fprintf (out
, "\n");
1878 if (pe_def_file
->num_exports
> 0)
1880 fprintf (out
, "EXPORTS\n");
1882 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1884 def_file_export
*e
= pe_def_file
->exports
+ i
;
1886 quoteput (e
->name
, out
, 0);
1888 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1890 fprintf (out
, " = ");
1891 quoteput (e
->internal_name
, out
, 0);
1894 if (e
->ordinal
!= -1)
1895 fprintf (out
, " @%d", e
->ordinal
);
1897 if (e
->flag_private
)
1898 fprintf (out
, " PRIVATE");
1900 if (e
->flag_constant
)
1901 fprintf (out
, " CONSTANT");
1904 fprintf (out
, " NONAME");
1907 fprintf (out
, " DATA");
1909 fprintf (out
, "\n");
1913 if (pe_def_file
->num_imports
> 0)
1915 fprintf (out
, "\nIMPORTS\n\n");
1917 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1919 def_file_import
*im
= pe_def_file
->imports
+ i
;
1922 if (im
->internal_name
1923 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1925 quoteput (im
->internal_name
, out
, 0);
1926 fprintf (out
, " = ");
1929 quoteput (im
->module
->name
, out
, 0);
1933 quoteput (im
->name
, out
, 0);
1935 fprintf (out
, "%d", im
->ordinal
);
1939 fprintf (out
, " == ");
1940 quoteput (im
->its_name
, out
, 0);
1943 fprintf (out
, "\n");
1948 fprintf (out
, _("; no contents available\n"));
1950 if (fclose (out
) == EOF
)
1951 /* xgettext:c-format */
1952 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1955 /* Generate the import library. */
1957 static asymbol
**symtab
;
1960 static const char *dll_filename
;
1961 static char *dll_symname
;
1963 #define UNDSEC bfd_und_section_ptr
1966 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1971 sec
= bfd_make_section_old_way (abfd
, name
);
1972 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1973 bfd_set_section_alignment (sec
, align
);
1974 /* Remember to undo this before trying to link internally! */
1975 sec
->output_section
= sec
;
1977 sym
= bfd_make_empty_symbol (abfd
);
1978 symtab
[symptr
++] = sym
;
1979 sym
->name
= sec
->name
;
1981 sym
->flags
= BSF_LOCAL
;
1988 quick_symbol (bfd
*abfd
,
1997 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
2002 sym
= bfd_make_empty_symbol (abfd
);
2007 symtab
[symptr
++] = sym
;
2010 static arelent
*reltab
= 0;
2011 static int relcount
= 0, relsize
= 0;
2014 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2016 if (relcount
>= relsize
- 1)
2020 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2022 reltab
= xmalloc (relsize
* sizeof (arelent
));
2024 reltab
[relcount
].address
= address
;
2025 reltab
[relcount
].addend
= 0;
2026 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2027 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2032 save_relocs (asection
*sec
)
2036 sec
->relocation
= reltab
;
2037 sec
->reloc_count
= relcount
;
2038 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2039 for (i
= 0; i
< relcount
; i
++)
2040 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2041 sec
->orelocation
[relcount
] = 0;
2042 sec
->flags
|= SEC_RELOC
;
2044 relcount
= relsize
= 0;
2047 /* .section .idata$2
2048 .global __head_my_dll
2065 make_head (bfd
*parent
)
2067 asection
*id2
, *id5
, *id4
;
2068 unsigned char *d2
, *d5
, *d4
;
2072 oname
= xmalloc (20);
2073 sprintf (oname
, "d%06d.o", tmp_seq
);
2076 abfd
= bfd_create (oname
, parent
);
2077 bfd_find_target (pe_details
->object_target
, abfd
);
2078 bfd_make_writable (abfd
);
2080 bfd_set_format (abfd
, bfd_object
);
2081 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2084 symtab
= xmalloc (6 * sizeof (asymbol
*));
2085 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2086 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2087 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2088 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2089 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2091 /* OK, pay attention here. I got confused myself looking back at
2092 it. We create a four-byte section to mark the beginning of the
2093 list, and we include an offset of 4 in the section, so that the
2094 pointer to the list points to the *end* of this section, which is
2095 the start of the list of sections from other objects. */
2097 bfd_set_section_size (id2
, 20);
2101 if (pe_use_nul_prefixed_import_tables
)
2102 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2103 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2104 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2105 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2108 if (pe_use_nul_prefixed_import_tables
)
2109 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2111 bfd_set_section_size (id5
, 0);
2112 d5
= xmalloc (PE_IDATA5_SIZE
);
2114 memset (d5
, 0, PE_IDATA5_SIZE
);
2115 if (pe_use_nul_prefixed_import_tables
)
2116 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2118 bfd_set_section_size (id4
, 0);
2119 d4
= xmalloc (PE_IDATA4_SIZE
);
2121 memset (d4
, 0, PE_IDATA4_SIZE
);
2123 bfd_set_symtab (abfd
, symtab
, symptr
);
2125 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2126 if (pe_use_nul_prefixed_import_tables
)
2128 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2129 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2133 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2134 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2137 bfd_make_readable (abfd
);
2141 /* .section .idata$4
2148 .global __my_dll_iname
2153 make_tail (bfd
*parent
)
2155 asection
*id4
, *id5
, *id7
;
2156 unsigned char *d4
, *d5
, *d7
;
2161 oname
= xmalloc (20);
2162 sprintf (oname
, "d%06d.o", tmp_seq
);
2165 abfd
= bfd_create (oname
, parent
);
2166 bfd_find_target (pe_details
->object_target
, abfd
);
2167 bfd_make_writable (abfd
);
2169 bfd_set_format (abfd
, bfd_object
);
2170 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2173 symtab
= xmalloc (5 * sizeof (asymbol
*));
2174 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2175 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2176 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2177 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2179 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2180 d4
= xmalloc (PE_IDATA4_SIZE
);
2182 memset (d4
, 0, PE_IDATA4_SIZE
);
2184 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2185 d5
= xmalloc (PE_IDATA5_SIZE
);
2187 memset (d5
, 0, PE_IDATA5_SIZE
);
2189 len
= strlen (dll_filename
) + 1;
2192 bfd_set_section_size (id7
, len
);
2195 strcpy ((char *) d7
, dll_filename
);
2196 /* If len was odd, the above
2197 strcpy leaves behind an undefined byte. That is harmless,
2198 but we set it to 0 just so the binary dumps are pretty. */
2201 bfd_set_symtab (abfd
, symtab
, symptr
);
2203 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2204 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2205 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2207 bfd_make_readable (abfd
);
2213 .global ___imp_function
2214 .global __imp__function
2216 jmp *__imp__function:
2230 .asciz "function" xlate? (add underscore, kill at) */
2232 static const unsigned char jmp_ix86_bytes
[] =
2234 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2242 .dw __imp_function */
2244 static const unsigned char jmp_sh_bytes
[] =
2246 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2250 lui $t0,<high:__imp_function>
2251 lw $t0,<low:__imp_function>
2255 static const unsigned char jmp_mips_bytes
[] =
2257 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2258 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2261 static const unsigned char jmp_arm_bytes
[] =
2263 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2264 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2270 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2272 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2273 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2277 const unsigned char *jmp_bytes
= NULL
;
2278 int jmp_byte_count
= 0;
2280 /* Include the jump stub section only if it is needed. A jump
2281 stub is needed if the symbol being imported <sym> is a function
2282 symbol and there is at least one undefined reference to that
2283 symbol. In other words, if all the import references to <sym> are
2284 explicitly through _declspec(dllimport) then the jump stub is not
2286 if (include_jmp_stub
)
2288 switch (pe_details
->pe_arch
)
2291 jmp_bytes
= jmp_ix86_bytes
;
2292 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2295 jmp_bytes
= jmp_sh_bytes
;
2296 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2299 jmp_bytes
= jmp_mips_bytes
;
2300 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2303 case PE_ARCH_arm_wince
:
2304 jmp_bytes
= jmp_arm_bytes
;
2305 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2312 oname
= xmalloc (20);
2313 sprintf (oname
, "d%06d.o", tmp_seq
);
2316 abfd
= bfd_create (oname
, parent
);
2317 bfd_find_target (pe_details
->object_target
, abfd
);
2318 bfd_make_writable (abfd
);
2320 bfd_set_format (abfd
, bfd_object
);
2321 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2324 symtab
= xmalloc (12 * sizeof (asymbol
*));
2326 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2327 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2328 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2329 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2330 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2332 if (*exp
->internal_name
== '@')
2334 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2336 if (include_jmp_stub
)
2337 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2338 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2340 /* Fastcall applies only to functions,
2341 so no need for auto-import symbol. */
2345 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2347 if (include_jmp_stub
)
2348 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2350 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2352 /* Symbol to reference ord/name of imported
2353 data symbol, used to implement auto-import. */
2355 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2358 if (pe_dll_compat_implib
)
2359 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2362 if (include_jmp_stub
)
2364 bfd_set_section_size (tx
, jmp_byte_count
);
2365 td
= xmalloc (jmp_byte_count
);
2367 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2369 switch (pe_details
->pe_arch
)
2372 #ifdef pe_use_x86_64
2373 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2375 /* Mark this object as SAFESEH compatible. */
2376 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2378 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2382 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2385 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2386 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2387 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2390 case PE_ARCH_arm_wince
:
2391 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2399 bfd_set_section_size (tx
, 0);
2401 bfd_set_section_size (id7
, 4);
2405 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2408 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2409 d5
= xmalloc (PE_IDATA5_SIZE
);
2411 memset (d5
, 0, PE_IDATA5_SIZE
);
2413 if (exp
->flag_noname
)
2415 d5
[0] = exp
->ordinal
;
2416 d5
[1] = exp
->ordinal
>> 8;
2417 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2421 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2425 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2426 d4
= xmalloc (PE_IDATA4_SIZE
);
2428 memset (d4
, 0, PE_IDATA4_SIZE
);
2430 if (exp
->flag_noname
)
2432 d4
[0] = exp
->ordinal
;
2433 d4
[1] = exp
->ordinal
>> 8;
2434 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2438 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2442 if (exp
->flag_noname
)
2445 bfd_set_section_size (id6
, 0);
2451 /* { short, asciz } */
2453 len
= 2 + strlen (exp
->its_name
) + 1;
2455 len
= 2 + strlen (exp
->name
) + 1;
2458 bfd_set_section_size (id6
, len
);
2461 memset (d6
, 0, len
);
2463 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2464 contains an invalid value (-1). */
2465 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2470 strcpy ((char*) d6
+ 2, exp
->its_name
);
2472 strcpy ((char *) d6
+ 2, exp
->name
);
2475 bfd_set_symtab (abfd
, symtab
, symptr
);
2477 if (include_jmp_stub
)
2478 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2479 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2480 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2481 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2482 if (!exp
->flag_noname
)
2483 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2485 bfd_make_readable (abfd
);
2490 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2492 /* Name thunks go to idata$4. */
2498 oname
= xmalloc (20);
2499 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2502 abfd
= bfd_create (oname
, parent
);
2503 bfd_find_target (pe_details
->object_target
, abfd
);
2504 bfd_make_writable (abfd
);
2506 bfd_set_format (abfd
, bfd_object
);
2507 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2510 symtab
= xmalloc (3 * sizeof (asymbol
*));
2511 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2512 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2513 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2515 /* We need space for the real thunk and for the null terminator. */
2516 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2517 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2519 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2520 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2523 bfd_set_symtab (abfd
, symtab
, symptr
);
2525 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2527 bfd_make_readable (abfd
);
2532 make_import_fixup_mark (arelent
*rel
, char *name
)
2534 /* We convert reloc to symbol, for later reference. */
2535 static unsigned int counter
;
2536 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2537 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2538 struct bfd_link_hash_entry
*bh
;
2539 char *fixup_name
, buf
[26];
2542 /* "name" buffer has space before the symbol name for prefixes. */
2543 sprintf (buf
, "__fu%d_", counter
++);
2544 prefix_len
= strlen (buf
);
2545 fixup_name
= name
- prefix_len
;
2546 memcpy (fixup_name
, buf
, prefix_len
);
2549 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2550 current_sec
, /* sym->section, */
2551 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2553 return bh
->root
.string
;
2556 /* .section .idata$2
2557 .rva __nm_thnk_SYM (singleton thunk with name of func)
2560 .rva __my_dll_iname (name of dll)
2561 .rva __fuNN_SYM (pointer to reference (address) in text) */
2564 make_import_fixup_entry (const char *name
,
2565 const char *fixup_name
,
2566 const char *symname
,
2574 oname
= xmalloc (20);
2575 sprintf (oname
, "fu%06d.o", tmp_seq
);
2578 abfd
= bfd_create (oname
, parent
);
2579 bfd_find_target (pe_details
->object_target
, abfd
);
2580 bfd_make_writable (abfd
);
2582 bfd_set_format (abfd
, bfd_object
);
2583 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2586 symtab
= xmalloc (6 * sizeof (asymbol
*));
2587 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2589 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2590 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2591 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2593 bfd_set_section_size (id2
, 20);
2598 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2599 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2600 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2603 bfd_set_symtab (abfd
, symtab
, symptr
);
2605 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2607 bfd_make_readable (abfd
);
2611 /* .section .rdata_runtime_pseudo_reloc
2613 .rva __fuNN_SYM (pointer to reference (address) in text) */
2616 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2617 const char *fixup_name
,
2618 bfd_vma addend ATTRIBUTE_UNUSED
,
2623 unsigned char *rt_rel_d
;
2628 oname
= xmalloc (20);
2629 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2632 abfd
= bfd_create (oname
, parent
);
2633 bfd_find_target (pe_details
->object_target
, abfd
);
2634 bfd_make_writable (abfd
);
2636 bfd_set_format (abfd
, bfd_object
);
2637 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2639 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2641 if (runtime_pseudp_reloc_v2_init
)
2642 size
= 3 * sizeof (asymbol
*);
2644 size
= 6 * sizeof (asymbol
*);
2647 size
= 2 * sizeof (asymbol
*);
2650 symtab
= xmalloc (size
);
2653 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2655 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2657 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2660 if (!runtime_pseudp_reloc_v2_init
)
2663 runtime_pseudp_reloc_v2_init
= TRUE
;
2666 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2668 bfd_set_section_size (rt_rel
, size
);
2669 rt_rel_d
= xmalloc (size
);
2670 rt_rel
->contents
= rt_rel_d
;
2671 memset (rt_rel_d
, 0, size
);
2672 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2673 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2674 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2676 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2677 save_relocs (rt_rel
);
2679 bfd_set_symtab (abfd
, symtab
, symptr
);
2681 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2685 bfd_set_section_size (rt_rel
, 8);
2686 rt_rel_d
= xmalloc (8);
2687 rt_rel
->contents
= rt_rel_d
;
2688 memset (rt_rel_d
, 0, 8);
2690 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2691 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2693 save_relocs (rt_rel
);
2695 bfd_set_symtab (abfd
, symtab
, symptr
);
2697 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2700 bfd_make_readable (abfd
);
2705 .rva __pei386_runtime_relocator */
2708 pe_create_runtime_relocator_reference (bfd
*parent
)
2710 asection
*extern_rt_rel
;
2711 unsigned char *extern_rt_rel_d
;
2715 oname
= xmalloc (20);
2716 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2719 abfd
= bfd_create (oname
, parent
);
2720 bfd_find_target (pe_details
->object_target
, abfd
);
2721 bfd_make_writable (abfd
);
2723 bfd_set_format (abfd
, bfd_object
);
2724 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2727 symtab
= xmalloc (2 * sizeof (asymbol
*));
2728 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2730 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2733 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2734 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2735 extern_rt_rel
->contents
= extern_rt_rel_d
;
2737 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2738 save_relocs (extern_rt_rel
);
2740 bfd_set_symtab (abfd
, symtab
, symptr
);
2742 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2744 bfd_make_readable (abfd
);
2749 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2750 const char *symname
)
2752 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2755 /* This is the original implementation of the auto-import feature, which
2756 primarily relied on the OS loader to patch things up with some help
2757 from the pseudo-relocator to overcome the main limitation. See the
2758 comment at the beginning of the file for an overview of the feature. */
2759 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2761 struct bfd_link_hash_entry
*name_thunk_sym
;
2762 /* name buffer is allocated with space at beginning for prefixes. */
2763 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2764 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2765 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2767 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2769 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2770 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2772 /* If we ever use autoimport, we have to cast text section writable. */
2773 config
.text_read_only
= FALSE
;
2774 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2777 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2779 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2780 link_info
.output_bfd
);
2781 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2785 /* In the original implementation, the pseudo-relocator was only used when
2786 the addend was not null. In the new implementation, the OS loader is
2787 completely bypassed and the pseudo-relocator does the entire work. */
2788 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2789 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2791 if (pe_dll_extra_pe_debug
)
2792 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2793 fixup_name
, (int) addend
);
2795 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2796 link_info
.output_bfd
);
2797 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2799 if (runtime_pseudo_relocs_created
++ == 0)
2801 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2802 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2806 else if (addend
!= 0)
2807 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2808 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2812 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2821 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2822 dll_symname
= xstrdup (dll_filename
);
2823 for (i
= 0; dll_symname
[i
]; i
++)
2824 if (!ISALNUM (dll_symname
[i
]))
2825 dll_symname
[i
] = '_';
2827 unlink_if_ordinary (impfilename
);
2829 outarch
= bfd_openw (impfilename
, 0);
2833 /* xgettext:c-format */
2834 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2839 /* xgettext:c-format */
2840 info_msg (_("Creating library file: %s\n"), impfilename
);
2842 bfd_set_format (outarch
, bfd_archive
);
2843 outarch
->has_armap
= 1;
2845 /* Work out a reasonable size of things to put onto one line. */
2846 ar_head
= make_head (outarch
);
2848 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2849 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2851 /* Iterate the exclude list. */
2852 struct exclude_list_struct
*ex
;
2854 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2856 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2858 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2860 /* If it matched, we must open a fresh BFD for it (the original
2861 input BFD is still needed for the DLL's final link) and add
2862 it into the archive member chain. */
2865 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2866 ? bfd_get_filename (ibfd
->my_archive
)
2867 : bfd_get_filename (ibfd
), NULL
);
2870 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2873 if (ibfd
->my_archive
)
2875 /* Must now iterate through archive until we find the
2876 required member. A minor shame that we'll open the
2877 archive once per member that we require from it, and
2878 leak those archive bfds rather than reuse them. */
2879 bfd
*arbfd
= newbfd
;
2880 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2882 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2883 bfd_get_filename (ibfd
->my_archive
),
2884 bfd_get_filename (ibfd
));
2888 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2890 if (filename_cmp (bfd_get_filename (newbfd
),
2891 bfd_get_filename (ibfd
)) == 0)
2896 einfo (_("%X%P: %s(%s): can't find member in archive"),
2897 bfd_get_filename (ibfd
->my_archive
),
2898 bfd_get_filename (ibfd
));
2902 newbfd
->archive_next
= head
;
2907 for (i
= 0; i
< def
->num_exports
; i
++)
2909 /* The import library doesn't know about the internal name. */
2910 char *internal
= def
->exports
[i
].internal_name
;
2913 /* Don't add PRIVATE entries to import lib. */
2914 if (pe_def_file
->exports
[i
].flag_private
)
2917 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2919 /* PR 19803: If a symbol has been discard due to garbage
2920 collection then do not create any exports for it. */
2922 struct coff_link_hash_entry
*h
;
2924 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2925 FALSE
, FALSE
, FALSE
);
2927 /* If the symbol is hidden and undefined then it
2928 has been swept up by garbage collection. */
2929 && h
->symbol_class
== C_HIDDEN
2930 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2933 /* If necessary, check with an underscore prefix as well. */
2934 if (pe_details
->underscored
&& internal
[0] != '@')
2938 name
= xmalloc (strlen (internal
) + 2);
2939 sprintf (name
, "_%s", internal
);
2941 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2942 FALSE
, FALSE
, FALSE
);
2946 /* If the symbol is hidden and undefined then it
2947 has been swept up by garbage collection. */
2948 && h
->symbol_class
== C_HIDDEN
2949 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2954 n
= make_one (def
->exports
+ i
, outarch
,
2955 ! (def
->exports
+ i
)->flag_data
);
2956 n
->archive_next
= head
;
2958 def
->exports
[i
].internal_name
= internal
;
2961 ar_tail
= make_tail (outarch
);
2963 if (ar_head
== NULL
|| ar_tail
== NULL
)
2966 /* Now stick them all into the archive. */
2967 ar_head
->archive_next
= head
;
2968 ar_tail
->archive_next
= ar_head
;
2971 if (! bfd_set_archive_head (outarch
, head
))
2972 einfo ("%X%P: bfd_set_archive_head: %E\n");
2974 if (! bfd_close (outarch
))
2975 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
2977 while (head
!= NULL
)
2979 bfd
*n
= head
->archive_next
;
2985 static int undef_count
= 0;
2993 static struct key_value
*udef_table
;
2995 static int undef_sort_cmp (const void *l1
, const void *r1
)
2997 const struct key_value
*l
= l1
;
2998 const struct key_value
*r
= r1
;
3000 return strcmp (l
->key
, r
->key
);
3003 static struct bfd_link_hash_entry
*
3004 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3006 struct bfd_link_hash_entry
*h
= NULL
;
3007 struct key_value
*kv
;
3008 struct key_value key
;
3009 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3011 strcpy (lname
, name
);
3013 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3018 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3023 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3024 if (h
->type
== bfd_link_hash_undefined
)
3028 if (lname
[0] == '?')
3031 if (at
|| lname
[0] == '@')
3033 if (lname
[0] == '@')
3035 if (pe_details
->underscored
)
3038 strcpy (lname
, lname
+ 1);
3040 kv
= bsearch (&key
, udef_table
, undef_count
,
3041 sizeof (struct key_value
), undef_sort_cmp
);
3044 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3045 if (h
->type
== bfd_link_hash_undefined
)
3050 *strchr (lname
, '@') = 0;
3052 kv
= bsearch (&key
, udef_table
, undef_count
,
3053 sizeof (struct key_value
), undef_sort_cmp
);
3056 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3057 if (h
->type
== bfd_link_hash_undefined
)
3063 strcat (lname
, "@");
3065 kv
= bsearch (&key
, udef_table
, undef_count
,
3066 sizeof (struct key_value
), undef_sort_cmp
);
3070 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3071 if (h
->type
== bfd_link_hash_undefined
)
3075 if (lname
[0] == '_' && pe_details
->underscored
)
3079 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3084 kv
= bsearch (&key
, udef_table
, undef_count
,
3085 sizeof (struct key_value
), undef_sort_cmp
);
3089 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3090 if (h
->type
== bfd_link_hash_undefined
)
3102 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3103 void *inf ATTRIBUTE_UNUSED
)
3105 if (h
->type
== bfd_link_hash_undefined
)
3111 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3113 if (h
->type
== bfd_link_hash_undefined
)
3117 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3118 at
= strchr (udef_table
[undef_count
].key
3119 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3122 udef_table
[undef_count
].oname
= h
->root
.string
;
3129 pe_create_undef_table (void)
3133 /* count undefined symbols */
3135 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3137 /* create and fill the corresponding table */
3138 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3141 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3144 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3148 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3150 lang_input_statement_type
*fake_file
;
3152 fake_file
= lang_add_input_file (name
,
3153 lang_input_file_is_fake_enum
,
3155 fake_file
->the_bfd
= abfd
;
3156 ldlang_add_file (fake_file
);
3158 if (!bfd_link_add_symbols (abfd
, linfo
))
3159 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3163 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3166 def_file_module
*module
;
3167 def_file_import
*imp
;
3169 pe_dll_id_target (bfd_get_target (output_bfd
));
3174 imp
= pe_def_file
->imports
;
3176 pe_create_undef_table ();
3178 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3180 int do_this_dll
= 0;
3182 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3184 if (i
>= pe_def_file
->num_imports
)
3187 dll_filename
= module
->name
;
3188 dll_symname
= xstrdup (module
->name
);
3189 for (j
= 0; dll_symname
[j
]; j
++)
3190 if (!ISALNUM (dll_symname
[j
]))
3191 dll_symname
[j
] = '_';
3193 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3195 def_file_export exp
;
3196 struct bfd_link_hash_entry
*blhe
;
3197 int lead_at
= (*imp
[i
].internal_name
== '@');
3198 /* See if we need this import. */
3199 size_t len
= strlen (imp
[i
].internal_name
);
3200 char *name
= xmalloc (len
+ 2 + 6);
3201 bfd_boolean include_jmp_stub
= FALSE
;
3202 bfd_boolean is_cdecl
= FALSE
;
3203 bfd_boolean is_undef
= FALSE
;
3205 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3209 sprintf (name
, "%s", imp
[i
].internal_name
);
3211 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3213 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3214 FALSE
, FALSE
, FALSE
);
3216 /* Include the jump stub for <sym> only if the <sym>
3218 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3221 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3223 sprintf (name
, "%s%s%s", "__imp_", U (""),
3224 imp
[i
].internal_name
);
3226 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3227 FALSE
, FALSE
, FALSE
);
3229 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3233 include_jmp_stub
= TRUE
;
3234 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3237 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3239 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3240 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3241 include_jmp_stub
= TRUE
;
3243 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3254 bfd
*ar_head
= make_head (output_bfd
);
3255 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
), linfo
);
3258 exp
.internal_name
= imp
[i
].internal_name
;
3259 exp
.name
= imp
[i
].name
;
3260 exp
.its_name
= imp
[i
].its_name
;
3261 exp
.ordinal
= imp
[i
].ordinal
;
3262 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3263 exp
.flag_private
= 0;
3264 exp
.flag_constant
= 0;
3265 exp
.flag_data
= imp
[i
].data
;
3266 exp
.flag_noname
= exp
.name
? 0 : 1;
3267 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3268 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3273 bfd
*ar_tail
= make_tail (output_bfd
);
3274 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3283 free (udef_table
[undef_count
].key
);
3288 /* We were handed a *.DLL file. Parse it and turn it into a set of
3289 IMPORTS directives in the def file. Return TRUE if the file was
3290 handled, FALSE if not. */
3293 pe_get16 (bfd
*abfd
, int where
)
3297 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3298 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3299 return b
[0] + (b
[1] << 8);
3303 pe_get32 (bfd
*abfd
, int where
)
3307 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3308 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3309 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3315 unsigned char *b
= ptr
;
3317 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3321 pe_implied_import_dll (const char *filename
)
3324 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3325 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3326 bfd_vma exp_funcbase
;
3327 unsigned char *expdata
;
3329 bfd_vma name_rvas
, nexp
;
3330 const char *dllname
;
3331 /* Initialization with start > end guarantees that is_data
3332 will not be set by mistake, and avoids compiler warning. */
3333 bfd_vma data_start
= 1;
3334 bfd_vma data_end
= 0;
3335 bfd_vma rdata_start
= 1;
3336 bfd_vma rdata_end
= 0;
3337 bfd_vma bss_start
= 1;
3338 bfd_vma bss_end
= 0;
3341 /* No, I can't use bfd here. kernel32.dll puts its export table in
3342 the middle of the .rdata section. */
3343 dll
= bfd_openr (filename
, pe_details
->target_name
);
3346 einfo (_("%X%P: open %s: %E\n"), filename
);
3350 /* PEI dlls seem to be bfd_objects. */
3351 if (!bfd_check_format (dll
, bfd_object
))
3353 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3357 /* Get pe_header, optional header and numbers of directory entries. */
3358 pe_header_offset
= pe_get32 (dll
, 0x3c);
3359 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3360 #ifdef pe_use_x86_64
3361 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3363 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3366 /* No import or export directory entry. */
3367 if (num_entries
< 1)
3370 #ifdef pe_use_x86_64
3371 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3372 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3374 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3375 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3378 /* No export table - nothing to export. */
3379 if (export_size
== 0)
3382 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3383 secptr
= (pe_header_offset
+ 4 + 20 +
3384 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3387 /* Get the rva and size of the export section. */
3388 for (i
= 0; i
< nsections
; i
++)
3391 bfd_vma secptr1
= secptr
+ 40 * i
;
3392 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3393 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3394 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3396 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3397 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3399 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3401 expptr
= fptr
+ (export_rva
- vaddr
);
3402 if (export_rva
+ export_size
> vaddr
+ vsize
)
3403 export_size
= vsize
- (export_rva
- vaddr
);
3408 /* Scan sections and store the base and size of the
3409 data and bss segments in data/base_start/end. */
3410 for (i
= 0; i
< nsections
; i
++)
3412 bfd_vma secptr1
= secptr
+ 40 * i
;
3413 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3414 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3415 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3419 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3420 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3422 if (strcmp(sec_name
,".data") == 0)
3425 data_end
= vaddr
+ vsize
;
3427 if (pe_dll_extra_pe_debug
)
3428 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3429 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3430 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3432 else if (strcmp(sec_name
,".rdata") == 0)
3434 rdata_start
= vaddr
;
3435 rdata_end
= vaddr
+ vsize
;
3437 if (pe_dll_extra_pe_debug
)
3438 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3439 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3440 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3442 else if (strcmp (sec_name
,".bss") == 0)
3445 bss_end
= vaddr
+ vsize
;
3447 if (pe_dll_extra_pe_debug
)
3448 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3449 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3450 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3454 expdata
= xmalloc (export_size
);
3455 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3456 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3457 erva
= (char *) expdata
- export_rva
;
3459 if (pe_def_file
== 0)
3460 pe_def_file
= def_file_empty ();
3462 nexp
= pe_as32 (expdata
+ 24);
3463 name_rvas
= pe_as32 (expdata
+ 32);
3464 exp_funcbase
= pe_as32 (expdata
+ 28);
3466 /* Use internal dll name instead of filename
3467 to enable symbolic dll linking. */
3468 dllname
= erva
+ pe_as32 (expdata
+ 12);
3470 /* Check to see if the dll has already been added to
3471 the definition list and if so return without error.
3472 This avoids multiple symbol definitions. */
3473 if (def_get_module (pe_def_file
, dllname
))
3475 if (pe_dll_extra_pe_debug
)
3476 printf ("%s is already loaded\n", dllname
);
3480 /* This is an optimized version of the insertion loop, which avoids lots of
3481 calls to realloc and memmove from def_file_add_import. */
3482 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3483 erva
+ pe_as32 (erva
+ name_rvas
),
3484 dllname
, 0, NULL
, NULL
)) >= 0)
3486 for (i
= 0; i
< nexp
; i
++)
3488 /* Pointer to the names vector. */
3489 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3490 def_file_import
*imp
;
3491 /* Pointer to the function address vector. */
3492 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3493 /* is_data is true if the address is in the data, rdata or bss
3496 (func_rva
>= data_start
&& func_rva
< data_end
)
3497 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3498 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3500 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3501 dllname
, i
, NULL
, NULL
);
3502 /* Mark symbol type. */
3503 imp
->data
= is_data
;
3505 if (pe_dll_extra_pe_debug
)
3506 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3507 __FUNCTION__
, dllname
, erva
+ name_rva
,
3508 (unsigned long) func_rva
, is_data
? "(data)" : "");
3514 /* Iterate through the list of symbols. */
3515 for (i
= 0; i
< nexp
; i
++)
3517 /* Pointer to the names vector. */
3518 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3519 def_file_import
*imp
;
3520 /* Pointer to the function address vector. */
3521 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3524 /* Skip unwanted symbols, which are
3525 exported in buggy auto-import releases. */
3526 if (! CONST_STRNEQ (erva
+ name_rva
, "__nm_"))
3529 /* is_data is true if the address is in the data, rdata or bss
3532 (func_rva
>= data_start
&& func_rva
< data_end
)
3533 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3534 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3536 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3537 dllname
, i
, NULL
, NULL
, &is_dup
);
3538 /* Mark symbol type. */
3540 imp
->data
= is_data
;
3542 if (pe_dll_extra_pe_debug
)
3543 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3544 __FUNCTION__
, dllname
, erva
+ name_rva
,
3545 (unsigned long) func_rva
, is_data
? "(data)" : "");
3553 pe_output_file_set_long_section_names (bfd
*abfd
)
3555 if (pe_use_coff_long_section_names
< 0)
3557 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3558 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3561 /* These are the main functions, called from the emulation. The first
3562 is called after the bfds are read, so we can guess at how much space
3563 we need. The second is called after everything is placed, so we
3564 can put the right values in place. */
3567 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3569 pe_dll_id_target (bfd_get_target (abfd
));
3570 pe_output_file_set_long_section_names (abfd
);
3571 process_def_file_and_drectve (abfd
, info
);
3573 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3575 if (pe_dll_enable_reloc_section
)
3577 build_filler_bfd (0);
3578 pe_output_file_set_long_section_names (filler_bfd
);
3583 generate_edata (abfd
, info
);
3584 build_filler_bfd (1);
3585 pe_output_file_set_long_section_names (filler_bfd
);
3589 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3591 pe_dll_id_target (bfd_get_target (abfd
));
3592 pe_output_file_set_long_section_names (abfd
);
3593 build_filler_bfd (0);
3594 pe_output_file_set_long_section_names (filler_bfd
);
3598 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3600 pe_exe_fill_sections (abfd
, info
);
3604 fill_edata (abfd
, info
);
3605 edata_s
->contents
= edata_d
;
3608 if (bfd_link_dll (info
))
3609 pe_data (abfd
)->dll
= 1;
3613 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3615 pe_dll_id_target (bfd_get_target (abfd
));
3616 pe_output_file_set_long_section_names (abfd
);
3617 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3619 generate_reloc (abfd
, info
);
3622 bfd_set_section_size (reloc_s
, reloc_sz
);
3624 /* Resize the sections. */
3625 lang_reset_memory_regions ();
3626 lang_size_sections (NULL
, TRUE
);
3628 /* Redo special stuff. */
3629 ldemul_after_allocation ();
3631 /* Do the assignments again. */
3632 lang_do_assignments (lang_final_phase_enum
);
3634 reloc_s
->contents
= reloc_d
;
3638 pe_bfd_is_dll (bfd
*abfd
)
3640 return (bfd_get_format (abfd
) == bfd_object
3642 && pe_data (abfd
)->dll
);