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
;
895 free (e
[i
].internal_name
);
896 free (e
[i
].its_name
);
905 pe_def_file
->num_exports
= j
; /* == NE */
907 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
908 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
910 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
914 count_exported_byname
= 0;
915 count_with_ordinals
= 0;
917 for (i
= 0; i
< NE
; i
++)
919 char *int_name
= pe_def_file
->exports
[i
].internal_name
;
922 /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
923 lang_add_gc_name (int_name
);
925 name
= xmalloc (strlen (int_name
) + 2);
926 if (pe_details
->underscored
&& int_name
[0] != '@')
929 strcpy (name
+ 1, int_name
);
931 /* PR 19803: The alias must be preserved as well. */
932 lang_add_gc_name (xstrdup (name
));
935 strcpy (name
, int_name
);
937 blhe
= bfd_link_hash_lookup (info
->hash
,
942 && (blhe
->type
== bfd_link_hash_defined
943 || (blhe
->type
== bfd_link_hash_common
)))
946 if (!pe_def_file
->exports
[i
].flag_noname
)
947 count_exported_byname
++;
949 /* Only fill in the sections. The actual offsets are computed
950 in fill_exported_offsets() after common symbols are laid
952 if (blhe
->type
== bfd_link_hash_defined
)
953 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
955 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
957 if (pe_def_file
->exports
[i
].ordinal
!= -1)
959 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
960 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
961 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
962 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
963 count_with_ordinals
++;
966 /* Check for forward exports. These are indicated in DEF files by an
967 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
968 but we must take care not to be fooled when the user wants to export
969 a symbol that actually really has a dot in it, so we only check
970 for them here, after real defined symbols have already been matched. */
971 else if (strchr (int_name
, '.'))
974 if (!pe_def_file
->exports
[i
].flag_noname
)
975 count_exported_byname
++;
977 pe_def_file
->exports
[i
].flag_forward
= 1;
979 if (pe_def_file
->exports
[i
].ordinal
!= -1)
981 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
982 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
983 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
984 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
985 count_with_ordinals
++;
988 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
990 /* xgettext:c-format */
991 einfo (_("%X%P: cannot export %s: symbol not defined\n"),
996 /* xgettext:c-format */
997 einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
999 blhe
->type
, bfd_link_hash_defined
);
1003 /* xgettext:c-format */
1004 einfo (_("%X%P: cannot export %s: symbol not found\n"),
1011 /* Build the bfd that will contain .edata and .reloc sections. */
1014 build_filler_bfd (int include_edata
)
1016 lang_input_statement_type
*filler_file
;
1017 filler_file
= lang_add_input_file ("dll stuff",
1018 lang_input_file_is_fake_enum
,
1020 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
1021 link_info
.output_bfd
);
1022 if (filler_bfd
== NULL
1023 || !bfd_set_arch_mach (filler_bfd
,
1024 bfd_get_arch (link_info
.output_bfd
),
1025 bfd_get_mach (link_info
.output_bfd
)))
1027 einfo (_("%F%P: can not create BFD: %E\n"));
1033 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
1035 || !bfd_set_section_flags (edata_s
, (SEC_HAS_CONTENTS
1041 einfo (_("%X%P: can not create .edata section: %E\n"));
1044 bfd_set_section_size (edata_s
, edata_sz
);
1047 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
1049 || !bfd_set_section_flags (reloc_s
, (SEC_HAS_CONTENTS
1055 einfo (_("%X%P: can not create .reloc section: %E\n"));
1059 bfd_set_section_size (reloc_s
, 0);
1061 ldlang_add_file (filler_file
);
1064 /* Gather all the exported symbols and build the .edata section. */
1067 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1069 int i
, next_ordinal
;
1070 int name_table_size
= 0;
1073 /* First, we need to know how many exported symbols there are,
1074 and what the range of ordinals is. */
1075 if (pe_def_file
->name
)
1076 dll_name
= pe_def_file
->name
;
1079 dll_name
= bfd_get_filename (abfd
);
1081 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1082 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1083 dll_name
= dlnp
+ 1;
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_name
) + 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_name
);
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 bfd_boolean 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
)
1509 /* For .reloc stuff. */
1510 reloc_data_type
*reloc_data
;
1511 int total_relocs
= 0;
1513 bfd_vma sec_page
= (bfd_vma
) -1;
1514 bfd_vma page_ptr
, page_count
;
1517 struct bfd_section
*s
;
1520 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1521 for (s
= b
->sections
; s
; s
= s
->next
)
1522 total_relocs
+= s
->reloc_count
;
1524 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1528 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link
.next
)
1531 int relsize
, nrelocs
;
1533 for (s
= b
->sections
; s
; s
= s
->next
)
1535 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1538 /* If it's not loaded, we don't need to relocate it this way. */
1539 if (!(s
->output_section
->flags
& SEC_LOAD
))
1542 /* I don't know why there would be a reloc for these, but I've
1543 seen it happen - DJ */
1544 if (s
->output_section
== bfd_abs_section_ptr
)
1547 if (s
->output_section
->vma
== 0)
1549 /* Huh? Shouldn't happen, but punt if it does. */
1550 einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1551 s
->output_section
->name
, s
->output_section
->index
,
1552 s
->output_section
->flags
);
1556 if (!bfd_generic_link_read_symbols (b
))
1558 einfo (_("%F%P: %pB: could not read symbols: %E\n"), b
);
1562 symbols
= bfd_get_outsymbols (b
);
1563 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1564 relocs
= xmalloc (relsize
);
1565 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1567 for (i
= 0; i
< nrelocs
; i
++)
1569 if (pe_dll_extra_pe_debug
)
1571 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1572 printf ("rel: %s\n", sym
->name
);
1574 if (!relocs
[i
]->howto
->pc_relative
1575 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1577 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1579 /* Don't create relocs for undefined weak symbols. */
1580 if (sym
->flags
== BSF_WEAK
)
1582 struct bfd_link_hash_entry
*blhe
1583 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1584 FALSE
, FALSE
, FALSE
);
1585 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1587 /* Check aux sym and see if it is defined or not. */
1588 struct coff_link_hash_entry
*h
, *h2
;
1589 h
= (struct coff_link_hash_entry
*)blhe
;
1590 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1592 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1593 [h
->aux
->x_sym
.x_tagndx
.l
];
1594 /* We don't want a base reloc if the aux sym is not
1595 found, undefined, or if it is the constant ABS
1596 zero default value. (We broaden that slightly by
1597 not testing the value, just the section; there's
1598 no reason we'd want a reference to any absolute
1599 address to get relocated during rebasing). */
1600 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1601 || h2
->root
.u
.def
.section
== bfd_abs_section_ptr
)
1604 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1607 /* Nor for Dwarf FDE references to discarded sections. */
1608 else if (bfd_is_abs_section (sym
->section
->output_section
))
1610 /* We only ignore relocs from .eh_frame sections, as
1611 they are discarded by the final link rather than
1612 resolved against the kept section. */
1613 if (!strcmp (s
->name
, ".eh_frame"))
1617 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1618 reloc_data
[total_relocs
].idx
= total_relocs
;
1620 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1622 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1623 relocs
[i
]->howto
->rightshift
)
1625 #ifdef pe_use_x86_64
1626 case BITS_AND_SHIFT (64, 0):
1627 reloc_data
[total_relocs
].type
= 10;
1631 case BITS_AND_SHIFT (32, 0):
1632 reloc_data
[total_relocs
].type
= 3;
1635 case BITS_AND_SHIFT (16, 0):
1636 reloc_data
[total_relocs
].type
= 2;
1639 case BITS_AND_SHIFT (16, 16):
1640 reloc_data
[total_relocs
].type
= 4;
1641 /* FIXME: we can't know the symbol's right value
1642 yet, but we probably can safely assume that
1643 CE will relocate us in 64k blocks, so leaving
1645 reloc_data
[total_relocs
].extra
= 0;
1648 case BITS_AND_SHIFT (26, 2):
1649 reloc_data
[total_relocs
].type
= 5;
1652 case BITS_AND_SHIFT (24, 2):
1653 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1654 Those ARM_xxx definitions should go in proper
1656 if (relocs
[i
]->howto
->type
== 0
1657 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1658 || relocs
[i
]->howto
->type
== 5)
1659 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1660 that has already been fully processed during a
1661 previous link stage, so ignore it here. */
1665 /* xgettext:c-format */
1666 einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1667 relocs
[i
]->howto
->bitsize
);
1673 /* Warning: the allocated symbols are remembered in BFD and
1674 reused later, so don't free them! */
1678 /* At this point, we have total_relocs relocation addresses in
1679 reloc_addresses, which are all suitable for the .reloc section.
1680 We must now create the new sections. */
1681 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1683 for (i
= 0; i
< total_relocs
; i
++)
1685 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1687 if (this_page
!= sec_page
)
1689 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1691 sec_page
= this_page
;
1696 if (reloc_data
[i
].type
== 4)
1700 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1701 reloc_d
= xmalloc (reloc_sz
);
1702 sec_page
= (bfd_vma
) -1;
1704 page_ptr
= (bfd_vma
) -1;
1707 for (i
= 0; i
< total_relocs
; i
++)
1709 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1710 bfd_vma this_page
= (rva
& ~0xfff);
1712 if (this_page
!= sec_page
)
1714 while (reloc_sz
& 3)
1715 reloc_d
[reloc_sz
++] = 0;
1717 if (page_ptr
!= (bfd_vma
) -1)
1718 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1720 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1721 page_ptr
= reloc_sz
;
1723 sec_page
= this_page
;
1727 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1728 reloc_d
+ reloc_sz
);
1731 if (reloc_data
[i
].type
== 4)
1733 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1740 while (reloc_sz
& 3)
1741 reloc_d
[reloc_sz
++] = 0;
1743 if (page_ptr
!= (bfd_vma
) -1)
1744 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1746 while (reloc_sz
< reloc_s
->size
)
1747 reloc_d
[reloc_sz
++] = 0;
1750 /* Given the exiting def_file structure, print out a .DEF file that
1751 corresponds to it. */
1754 quoteput (char *s
, FILE *f
, int needs_quotes
)
1758 for (cp
= s
; *cp
; cp
++)
1773 if (*s
== '"' || *s
== '\\')
1787 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1790 FILE *out
= fopen (pe_out_def_filename
, "w");
1793 /* xgettext:c-format */
1794 einfo (_("%P: can't open output def file %s\n"),
1795 pe_out_def_filename
);
1799 if (pe_def_file
->name
)
1801 if (pe_def_file
->is_dll
)
1802 fprintf (out
, "LIBRARY ");
1804 fprintf (out
, "NAME ");
1806 quoteput (pe_def_file
->name
, out
, 1);
1808 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1810 fprintf (out
, " BASE=0x");
1811 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1813 fprintf (out
, "\n");
1816 if (pe_def_file
->description
)
1818 fprintf (out
, "DESCRIPTION ");
1819 quoteput (pe_def_file
->description
, out
, 1);
1820 fprintf (out
, "\n");
1823 if (pe_def_file
->version_minor
!= -1)
1824 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1825 pe_def_file
->version_minor
);
1826 else if (pe_def_file
->version_major
!= -1)
1827 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1829 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1830 fprintf (out
, "\n");
1832 if (pe_def_file
->stack_commit
!= -1)
1833 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1834 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1835 else if (pe_def_file
->stack_reserve
!= -1)
1836 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1838 if (pe_def_file
->heap_commit
!= -1)
1839 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1840 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1841 else if (pe_def_file
->heap_reserve
!= -1)
1842 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1844 if (pe_def_file
->num_section_defs
> 0)
1846 fprintf (out
, "\nSECTIONS\n\n");
1848 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1851 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1853 if (pe_def_file
->section_defs
[i
].class)
1855 fprintf (out
, " CLASS ");
1856 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1859 if (pe_def_file
->section_defs
[i
].flag_read
)
1860 fprintf (out
, " READ");
1862 if (pe_def_file
->section_defs
[i
].flag_write
)
1863 fprintf (out
, " WRITE");
1865 if (pe_def_file
->section_defs
[i
].flag_execute
)
1866 fprintf (out
, " EXECUTE");
1868 if (pe_def_file
->section_defs
[i
].flag_shared
)
1869 fprintf (out
, " SHARED");
1871 fprintf (out
, "\n");
1875 if (pe_def_file
->num_exports
> 0)
1877 fprintf (out
, "EXPORTS\n");
1879 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1881 def_file_export
*e
= pe_def_file
->exports
+ i
;
1883 quoteput (e
->name
, out
, 0);
1885 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1887 fprintf (out
, " = ");
1888 quoteput (e
->internal_name
, out
, 0);
1891 if (e
->ordinal
!= -1)
1892 fprintf (out
, " @%d", e
->ordinal
);
1894 if (e
->flag_private
)
1895 fprintf (out
, " PRIVATE");
1897 if (e
->flag_constant
)
1898 fprintf (out
, " CONSTANT");
1901 fprintf (out
, " NONAME");
1904 fprintf (out
, " DATA");
1906 fprintf (out
, "\n");
1910 if (pe_def_file
->num_imports
> 0)
1912 fprintf (out
, "\nIMPORTS\n\n");
1914 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1916 def_file_import
*im
= pe_def_file
->imports
+ i
;
1919 if (im
->internal_name
1920 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1922 quoteput (im
->internal_name
, out
, 0);
1923 fprintf (out
, " = ");
1926 quoteput (im
->module
->name
, out
, 0);
1930 quoteput (im
->name
, out
, 0);
1932 fprintf (out
, "%d", im
->ordinal
);
1936 fprintf (out
, " == ");
1937 quoteput (im
->its_name
, out
, 0);
1940 fprintf (out
, "\n");
1945 fprintf (out
, _("; no contents available\n"));
1947 if (fclose (out
) == EOF
)
1948 /* xgettext:c-format */
1949 einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename
);
1952 /* Generate the import library. */
1954 static asymbol
**symtab
;
1957 static const char *dll_filename
;
1958 static char *dll_symname
;
1960 #define UNDSEC bfd_und_section_ptr
1963 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1968 sec
= bfd_make_section_old_way (abfd
, name
);
1969 bfd_set_section_flags (sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1970 bfd_set_section_alignment (sec
, align
);
1971 /* Remember to undo this before trying to link internally! */
1972 sec
->output_section
= sec
;
1974 sym
= bfd_make_empty_symbol (abfd
);
1975 symtab
[symptr
++] = sym
;
1976 sym
->name
= sec
->name
;
1978 sym
->flags
= BSF_LOCAL
;
1985 quick_symbol (bfd
*abfd
,
1994 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1999 sym
= bfd_make_empty_symbol (abfd
);
2004 symtab
[symptr
++] = sym
;
2007 static arelent
*reltab
= 0;
2008 static int relcount
= 0, relsize
= 0;
2011 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
2013 if (relcount
>= relsize
- 1)
2017 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
2019 reltab
= xmalloc (relsize
* sizeof (arelent
));
2021 reltab
[relcount
].address
= address
;
2022 reltab
[relcount
].addend
= 0;
2023 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
2024 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
2029 save_relocs (asection
*sec
)
2033 sec
->relocation
= reltab
;
2034 sec
->reloc_count
= relcount
;
2035 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
2036 for (i
= 0; i
< relcount
; i
++)
2037 sec
->orelocation
[i
] = sec
->relocation
+ i
;
2038 sec
->orelocation
[relcount
] = 0;
2039 sec
->flags
|= SEC_RELOC
;
2041 relcount
= relsize
= 0;
2044 /* .section .idata$2
2045 .global __head_my_dll
2062 make_head (bfd
*parent
)
2064 asection
*id2
, *id5
, *id4
;
2065 unsigned char *d2
, *d5
, *d4
;
2069 oname
= xmalloc (20);
2070 sprintf (oname
, "d%06d.o", tmp_seq
);
2073 abfd
= bfd_create (oname
, parent
);
2074 bfd_find_target (pe_details
->object_target
, abfd
);
2075 bfd_make_writable (abfd
);
2077 bfd_set_format (abfd
, bfd_object
);
2078 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2081 symtab
= xmalloc (6 * sizeof (asymbol
*));
2082 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2083 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2084 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2085 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2086 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2088 /* OK, pay attention here. I got confused myself looking back at
2089 it. We create a four-byte section to mark the beginning of the
2090 list, and we include an offset of 4 in the section, so that the
2091 pointer to the list points to the *end* of this section, which is
2092 the start of the list of sections from other objects. */
2094 bfd_set_section_size (id2
, 20);
2098 if (pe_use_nul_prefixed_import_tables
)
2099 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2100 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2101 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
2102 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
2105 if (pe_use_nul_prefixed_import_tables
)
2106 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2108 bfd_set_section_size (id5
, 0);
2109 d5
= xmalloc (PE_IDATA5_SIZE
);
2111 memset (d5
, 0, PE_IDATA5_SIZE
);
2112 if (pe_use_nul_prefixed_import_tables
)
2113 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2115 bfd_set_section_size (id4
, 0);
2116 d4
= xmalloc (PE_IDATA4_SIZE
);
2118 memset (d4
, 0, PE_IDATA4_SIZE
);
2120 bfd_set_symtab (abfd
, symtab
, symptr
);
2122 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2123 if (pe_use_nul_prefixed_import_tables
)
2125 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2126 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2130 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
2131 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
2134 bfd_make_readable (abfd
);
2138 /* .section .idata$4
2145 .global __my_dll_iname
2150 make_tail (bfd
*parent
)
2152 asection
*id4
, *id5
, *id7
;
2153 unsigned char *d4
, *d5
, *d7
;
2158 oname
= xmalloc (20);
2159 sprintf (oname
, "d%06d.o", tmp_seq
);
2162 abfd
= bfd_create (oname
, parent
);
2163 bfd_find_target (pe_details
->object_target
, abfd
);
2164 bfd_make_writable (abfd
);
2166 bfd_set_format (abfd
, bfd_object
);
2167 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2170 symtab
= xmalloc (5 * sizeof (asymbol
*));
2171 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2172 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2173 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2174 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
2176 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2177 d4
= xmalloc (PE_IDATA4_SIZE
);
2179 memset (d4
, 0, PE_IDATA4_SIZE
);
2181 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2182 d5
= xmalloc (PE_IDATA5_SIZE
);
2184 memset (d5
, 0, PE_IDATA5_SIZE
);
2186 len
= strlen (dll_filename
) + 1;
2189 bfd_set_section_size (id7
, len
);
2192 strcpy ((char *) d7
, dll_filename
);
2193 /* If len was odd, the above
2194 strcpy leaves behind an undefined byte. That is harmless,
2195 but we set it to 0 just so the binary dumps are pretty. */
2198 bfd_set_symtab (abfd
, symtab
, symptr
);
2200 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2201 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2202 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
2204 bfd_make_readable (abfd
);
2210 .global ___imp_function
2211 .global __imp__function
2213 jmp *__imp__function:
2227 .asciz "function" xlate? (add underscore, kill at) */
2229 static const unsigned char jmp_ix86_bytes
[] =
2231 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2239 .dw __imp_function */
2241 static const unsigned char jmp_sh_bytes
[] =
2243 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2247 lui $t0,<high:__imp_function>
2248 lw $t0,<low:__imp_function>
2252 static const unsigned char jmp_mips_bytes
[] =
2254 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2255 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2258 static const unsigned char jmp_arm_bytes
[] =
2260 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2261 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2267 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2269 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2270 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2274 const unsigned char *jmp_bytes
= NULL
;
2275 int jmp_byte_count
= 0;
2277 /* Include the jump stub section only if it is needed. A jump
2278 stub is needed if the symbol being imported <sym> is a function
2279 symbol and there is at least one undefined reference to that
2280 symbol. In other words, if all the import references to <sym> are
2281 explicitly through _declspec(dllimport) then the jump stub is not
2283 if (include_jmp_stub
)
2285 switch (pe_details
->pe_arch
)
2288 jmp_bytes
= jmp_ix86_bytes
;
2289 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2292 jmp_bytes
= jmp_sh_bytes
;
2293 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2296 jmp_bytes
= jmp_mips_bytes
;
2297 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2300 case PE_ARCH_arm_wince
:
2301 jmp_bytes
= jmp_arm_bytes
;
2302 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2309 oname
= xmalloc (20);
2310 sprintf (oname
, "d%06d.o", tmp_seq
);
2313 abfd
= bfd_create (oname
, parent
);
2314 bfd_find_target (pe_details
->object_target
, abfd
);
2315 bfd_make_writable (abfd
);
2317 bfd_set_format (abfd
, bfd_object
);
2318 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2321 symtab
= xmalloc (12 * sizeof (asymbol
*));
2323 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2324 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2325 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2326 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2327 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2329 if (*exp
->internal_name
== '@')
2331 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2333 if (include_jmp_stub
)
2334 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2335 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2337 /* Fastcall applies only to functions,
2338 so no need for auto-import symbol. */
2342 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2344 if (include_jmp_stub
)
2345 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2347 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2349 /* Symbol to reference ord/name of imported
2350 data symbol, used to implement auto-import. */
2352 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2355 if (pe_dll_compat_implib
)
2356 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2359 if (include_jmp_stub
)
2361 bfd_set_section_size (tx
, jmp_byte_count
);
2362 td
= xmalloc (jmp_byte_count
);
2364 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2366 switch (pe_details
->pe_arch
)
2369 #ifdef pe_use_x86_64
2370 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2372 /* Mark this object as SAFESEH compatible. */
2373 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2375 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2379 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2382 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2383 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2384 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2387 case PE_ARCH_arm_wince
:
2388 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2396 bfd_set_section_size (tx
, 0);
2398 bfd_set_section_size (id7
, 4);
2402 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2405 bfd_set_section_size (id5
, PE_IDATA5_SIZE
);
2406 d5
= xmalloc (PE_IDATA5_SIZE
);
2408 memset (d5
, 0, PE_IDATA5_SIZE
);
2410 if (exp
->flag_noname
)
2412 d5
[0] = exp
->ordinal
;
2413 d5
[1] = exp
->ordinal
>> 8;
2414 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2418 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2422 bfd_set_section_size (id4
, PE_IDATA4_SIZE
);
2423 d4
= xmalloc (PE_IDATA4_SIZE
);
2425 memset (d4
, 0, PE_IDATA4_SIZE
);
2427 if (exp
->flag_noname
)
2429 d4
[0] = exp
->ordinal
;
2430 d4
[1] = exp
->ordinal
>> 8;
2431 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2435 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2439 if (exp
->flag_noname
)
2442 bfd_set_section_size (id6
, 0);
2448 /* { short, asciz } */
2450 len
= 2 + strlen (exp
->its_name
) + 1;
2452 len
= 2 + strlen (exp
->name
) + 1;
2455 bfd_set_section_size (id6
, len
);
2458 memset (d6
, 0, len
);
2460 /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
2461 contains an invalid value (-1). */
2462 ord
= (exp
->ordinal
>= 0) ? exp
->ordinal
: exp
->hint
;
2467 strcpy ((char*) d6
+ 2, exp
->its_name
);
2469 strcpy ((char *) d6
+ 2, exp
->name
);
2472 bfd_set_symtab (abfd
, symtab
, symptr
);
2474 if (include_jmp_stub
)
2475 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2476 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2477 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2478 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2479 if (!exp
->flag_noname
)
2480 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2482 bfd_make_readable (abfd
);
2487 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2489 /* Name thunks go to idata$4. */
2495 oname
= xmalloc (20);
2496 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2499 abfd
= bfd_create (oname
, parent
);
2500 bfd_find_target (pe_details
->object_target
, abfd
);
2501 bfd_make_writable (abfd
);
2503 bfd_set_format (abfd
, bfd_object
);
2504 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2507 symtab
= xmalloc (3 * sizeof (asymbol
*));
2508 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2509 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2510 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2512 /* We need space for the real thunk and for the null terminator. */
2513 bfd_set_section_size (id4
, PE_IDATA4_SIZE
* 2);
2514 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2516 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2517 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2520 bfd_set_symtab (abfd
, symtab
, symptr
);
2522 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2524 bfd_make_readable (abfd
);
2529 make_import_fixup_mark (arelent
*rel
, char *name
)
2531 /* We convert reloc to symbol, for later reference. */
2532 static unsigned int counter
;
2533 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2534 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2535 struct bfd_link_hash_entry
*bh
;
2536 char *fixup_name
, buf
[26];
2539 /* "name" buffer has space before the symbol name for prefixes. */
2540 sprintf (buf
, "__fu%d_", counter
++);
2541 prefix_len
= strlen (buf
);
2542 fixup_name
= name
- prefix_len
;
2543 memcpy (fixup_name
, buf
, prefix_len
);
2546 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2547 current_sec
, /* sym->section, */
2548 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2550 return bh
->root
.string
;
2553 /* .section .idata$2
2554 .rva __nm_thnk_SYM (singleton thunk with name of func)
2557 .rva __my_dll_iname (name of dll)
2558 .rva __fuNN_SYM (pointer to reference (address) in text) */
2561 make_import_fixup_entry (const char *name
,
2562 const char *fixup_name
,
2563 const char *symname
,
2571 oname
= xmalloc (20);
2572 sprintf (oname
, "fu%06d.o", tmp_seq
);
2575 abfd
= bfd_create (oname
, parent
);
2576 bfd_find_target (pe_details
->object_target
, abfd
);
2577 bfd_make_writable (abfd
);
2579 bfd_set_format (abfd
, bfd_object
);
2580 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2583 symtab
= xmalloc (6 * sizeof (asymbol
*));
2584 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2586 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2587 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2588 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2590 bfd_set_section_size (id2
, 20);
2595 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2596 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2597 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2600 bfd_set_symtab (abfd
, symtab
, symptr
);
2602 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2604 bfd_make_readable (abfd
);
2608 /* .section .rdata_runtime_pseudo_reloc
2610 .rva __fuNN_SYM (pointer to reference (address) in text) */
2613 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2614 const char *fixup_name
,
2615 bfd_vma addend ATTRIBUTE_UNUSED
,
2620 unsigned char *rt_rel_d
;
2625 oname
= xmalloc (20);
2626 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2629 abfd
= bfd_create (oname
, parent
);
2630 bfd_find_target (pe_details
->object_target
, abfd
);
2631 bfd_make_writable (abfd
);
2633 bfd_set_format (abfd
, bfd_object
);
2634 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2636 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2638 if (runtime_pseudp_reloc_v2_init
)
2639 size
= 3 * sizeof (asymbol
*);
2641 size
= 6 * sizeof (asymbol
*);
2644 size
= 2 * sizeof (asymbol
*);
2647 symtab
= xmalloc (size
);
2650 = quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2652 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2654 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2657 if (!runtime_pseudp_reloc_v2_init
)
2660 runtime_pseudp_reloc_v2_init
= TRUE
;
2663 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2665 bfd_set_section_size (rt_rel
, size
);
2666 rt_rel_d
= xmalloc (size
);
2667 rt_rel
->contents
= rt_rel_d
;
2668 memset (rt_rel_d
, 0, size
);
2669 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2670 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2671 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2673 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2674 save_relocs (rt_rel
);
2676 bfd_set_symtab (abfd
, symtab
, symptr
);
2678 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2682 bfd_set_section_size (rt_rel
, 8);
2683 rt_rel_d
= xmalloc (8);
2684 rt_rel
->contents
= rt_rel_d
;
2685 memset (rt_rel_d
, 0, 8);
2687 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2688 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2690 save_relocs (rt_rel
);
2692 bfd_set_symtab (abfd
, symtab
, symptr
);
2694 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2697 bfd_make_readable (abfd
);
2702 .rva __pei386_runtime_relocator */
2705 pe_create_runtime_relocator_reference (bfd
*parent
)
2707 asection
*extern_rt_rel
;
2708 unsigned char *extern_rt_rel_d
;
2712 oname
= xmalloc (20);
2713 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2716 abfd
= bfd_create (oname
, parent
);
2717 bfd_find_target (pe_details
->object_target
, abfd
);
2718 bfd_make_writable (abfd
);
2720 bfd_set_format (abfd
, bfd_object
);
2721 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2724 symtab
= xmalloc (2 * sizeof (asymbol
*));
2725 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2727 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2730 bfd_set_section_size (extern_rt_rel
, PE_IDATA5_SIZE
);
2731 extern_rt_rel_d
= xcalloc (1, PE_IDATA5_SIZE
);
2732 extern_rt_rel
->contents
= extern_rt_rel_d
;
2734 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2735 save_relocs (extern_rt_rel
);
2737 bfd_set_symtab (abfd
, symtab
, symptr
);
2739 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2741 bfd_make_readable (abfd
);
2746 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
, char *name
,
2747 const char *symname
)
2749 const char *fixup_name
= make_import_fixup_mark (rel
, name
);
2752 /* This is the original implementation of the auto-import feature, which
2753 primarily relied on the OS loader to patch things up with some help
2754 from the pseudo-relocator to overcome the main limitation. See the
2755 comment at the beginning of the file for an overview of the feature. */
2756 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2758 struct bfd_link_hash_entry
*name_thunk_sym
;
2759 /* name buffer is allocated with space at beginning for prefixes. */
2760 char *thname
= name
- (sizeof "__nm_thnk_" - 1);
2761 memcpy (thname
, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2762 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, thname
, 0, 0, 1);
2764 if (!(name_thunk_sym
&& name_thunk_sym
->type
== bfd_link_hash_defined
))
2766 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2767 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2769 /* If we ever use autoimport, we have to cast text section writable. */
2770 config
.text_read_only
= FALSE
;
2771 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2774 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
== 1)
2776 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2777 link_info
.output_bfd
);
2778 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2782 /* In the original implementation, the pseudo-relocator was only used when
2783 the addend was not null. In the new implementation, the OS loader is
2784 completely bypassed and the pseudo-relocator does the entire work. */
2785 if ((addend
!= 0 && link_info
.pei386_runtime_pseudo_reloc
== 1)
2786 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2788 if (pe_dll_extra_pe_debug
)
2789 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2790 fixup_name
, (int) addend
);
2792 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2793 link_info
.output_bfd
);
2794 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2796 if (runtime_pseudo_relocs_created
++ == 0)
2798 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2799 add_bfd_to_link (b
, bfd_get_filename (b
), &link_info
);
2803 else if (addend
!= 0)
2804 einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2805 s
->owner
, s
, rel
->address
, (*rel
->sym_ptr_ptr
)->name
);
2809 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2818 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2819 dll_symname
= xstrdup (dll_filename
);
2820 for (i
= 0; dll_symname
[i
]; i
++)
2821 if (!ISALNUM (dll_symname
[i
]))
2822 dll_symname
[i
] = '_';
2824 unlink_if_ordinary (impfilename
);
2826 outarch
= bfd_openw (impfilename
, 0);
2830 /* xgettext:c-format */
2831 einfo (_("%X%P: can't open .lib file: %s\n"), impfilename
);
2836 /* xgettext:c-format */
2837 info_msg (_("Creating library file: %s\n"), impfilename
);
2839 bfd_set_format (outarch
, bfd_archive
);
2840 outarch
->has_armap
= 1;
2842 /* Work out a reasonable size of things to put onto one line. */
2843 ar_head
= make_head (outarch
);
2845 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2846 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2848 /* Iterate the exclude list. */
2849 struct exclude_list_struct
*ex
;
2851 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2853 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2855 found
= (filename_cmp (ex
->string
, bfd_get_filename (ibfd
)) == 0);
2857 /* If it matched, we must open a fresh BFD for it (the original
2858 input BFD is still needed for the DLL's final link) and add
2859 it into the archive member chain. */
2862 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2863 ? bfd_get_filename (ibfd
->my_archive
)
2864 : bfd_get_filename (ibfd
), NULL
);
2867 einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd
));
2870 if (ibfd
->my_archive
)
2872 /* Must now iterate through archive until we find the
2873 required member. A minor shame that we'll open the
2874 archive once per member that we require from it, and
2875 leak those archive bfds rather than reuse them. */
2876 bfd
*arbfd
= newbfd
;
2877 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2879 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2880 bfd_get_filename (ibfd
->my_archive
),
2881 bfd_get_filename (ibfd
));
2885 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2887 if (filename_cmp (bfd_get_filename (newbfd
),
2888 bfd_get_filename (ibfd
)) == 0)
2893 einfo (_("%X%P: %s(%s): can't find member in archive"),
2894 bfd_get_filename (ibfd
->my_archive
),
2895 bfd_get_filename (ibfd
));
2899 newbfd
->archive_next
= head
;
2904 for (i
= 0; i
< def
->num_exports
; i
++)
2906 /* The import library doesn't know about the internal name. */
2907 char *internal
= def
->exports
[i
].internal_name
;
2910 /* Don't add PRIVATE entries to import lib. */
2911 if (pe_def_file
->exports
[i
].flag_private
)
2914 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2916 /* PR 19803: If a symbol has been discard due to garbage
2917 collection then do not create any exports for it. */
2919 struct coff_link_hash_entry
*h
;
2921 h
= coff_link_hash_lookup (coff_hash_table (info
), internal
,
2922 FALSE
, FALSE
, FALSE
);
2924 /* If the symbol is hidden and undefined then it
2925 has been swept up by garbage collection. */
2926 && h
->symbol_class
== C_HIDDEN
2927 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2930 /* If necessary, check with an underscore prefix as well. */
2931 if (pe_details
->underscored
&& internal
[0] != '@')
2935 name
= xmalloc (strlen (internal
) + 2);
2936 sprintf (name
, "_%s", internal
);
2938 h
= coff_link_hash_lookup (coff_hash_table (info
), name
,
2939 FALSE
, FALSE
, FALSE
);
2943 /* If the symbol is hidden and undefined then it
2944 has been swept up by garbage collection. */
2945 && h
->symbol_class
== C_HIDDEN
2946 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)
2951 n
= make_one (def
->exports
+ i
, outarch
,
2952 ! (def
->exports
+ i
)->flag_data
);
2953 n
->archive_next
= head
;
2955 def
->exports
[i
].internal_name
= internal
;
2958 ar_tail
= make_tail (outarch
);
2960 if (ar_head
== NULL
|| ar_tail
== NULL
)
2963 /* Now stick them all into the archive. */
2964 ar_head
->archive_next
= head
;
2965 ar_tail
->archive_next
= ar_head
;
2968 if (! bfd_set_archive_head (outarch
, head
))
2969 einfo ("%X%P: bfd_set_archive_head: %E\n");
2971 if (! bfd_close (outarch
))
2972 einfo ("%X%P: bfd_close %s: %E\n", impfilename
);
2974 while (head
!= NULL
)
2976 bfd
*n
= head
->archive_next
;
2982 static int undef_count
= 0;
2990 static struct key_value
*udef_table
;
2992 static int undef_sort_cmp (const void *l1
, const void *r1
)
2994 const struct key_value
*l
= l1
;
2995 const struct key_value
*r
= r1
;
2997 return strcmp (l
->key
, r
->key
);
3000 static struct bfd_link_hash_entry
*
3001 pe_find_cdecl_alias_match (struct bfd_link_info
*linfo
, char *name
)
3003 struct bfd_link_hash_entry
*h
= NULL
;
3004 struct key_value
*kv
;
3005 struct key_value key
;
3006 char *at
, *lname
= xmalloc (strlen (name
) + 3);
3008 strcpy (lname
, name
);
3010 at
= strchr (lname
+ (lname
[0] == '@'), '@');
3015 kv
= bsearch (&key
, udef_table
, undef_count
, sizeof (struct key_value
),
3020 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3021 if (h
->type
== bfd_link_hash_undefined
)
3025 if (lname
[0] == '?')
3028 if (at
|| lname
[0] == '@')
3030 if (lname
[0] == '@')
3032 if (pe_details
->underscored
)
3035 strcpy (lname
, lname
+ 1);
3037 kv
= bsearch (&key
, udef_table
, undef_count
,
3038 sizeof (struct key_value
), undef_sort_cmp
);
3041 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3042 if (h
->type
== bfd_link_hash_undefined
)
3047 *strchr (lname
, '@') = 0;
3049 kv
= bsearch (&key
, udef_table
, undef_count
,
3050 sizeof (struct key_value
), undef_sort_cmp
);
3053 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3054 if (h
->type
== bfd_link_hash_undefined
)
3060 strcat (lname
, "@");
3062 kv
= bsearch (&key
, udef_table
, undef_count
,
3063 sizeof (struct key_value
), undef_sort_cmp
);
3067 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3068 if (h
->type
== bfd_link_hash_undefined
)
3072 if (lname
[0] == '_' && pe_details
->underscored
)
3076 memmove (lname
+ 1, lname
, strlen (lname
) + 1);
3081 kv
= bsearch (&key
, udef_table
, undef_count
,
3082 sizeof (struct key_value
), undef_sort_cmp
);
3086 h
= bfd_link_hash_lookup (linfo
->hash
, kv
->oname
, FALSE
, FALSE
, FALSE
);
3087 if (h
->type
== bfd_link_hash_undefined
)
3099 pe_undef_count (struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3100 void *inf ATTRIBUTE_UNUSED
)
3102 if (h
->type
== bfd_link_hash_undefined
)
3108 pe_undef_fill (struct bfd_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
3110 if (h
->type
== bfd_link_hash_undefined
)
3114 udef_table
[undef_count
].key
= xstrdup (h
->root
.string
);
3115 at
= strchr (udef_table
[undef_count
].key
3116 + (udef_table
[undef_count
].key
[0] == '@'), '@');
3119 udef_table
[undef_count
].oname
= h
->root
.string
;
3126 pe_create_undef_table (void)
3130 /* count undefined symbols */
3132 bfd_link_hash_traverse (link_info
.hash
, pe_undef_count
, "");
3134 /* create and fill the corresponding table */
3135 udef_table
= xmalloc (undef_count
* sizeof (struct key_value
));
3138 bfd_link_hash_traverse (link_info
.hash
, pe_undef_fill
, "");
3141 qsort (udef_table
, undef_count
, sizeof (struct key_value
), undef_sort_cmp
);
3145 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
3147 lang_input_statement_type
*fake_file
;
3149 fake_file
= lang_add_input_file (name
,
3150 lang_input_file_is_fake_enum
,
3152 fake_file
->the_bfd
= abfd
;
3153 ldlang_add_file (fake_file
);
3155 if (!bfd_link_add_symbols (abfd
, linfo
))
3156 einfo (_("%X%P: add symbols %s: %E\n"), name
);
3160 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
3163 def_file_module
*module
;
3164 def_file_import
*imp
;
3166 pe_dll_id_target (bfd_get_target (output_bfd
));
3171 imp
= pe_def_file
->imports
;
3173 pe_create_undef_table ();
3175 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
3177 int do_this_dll
= 0;
3179 for (i
= 0; i
< pe_def_file
->num_imports
&& imp
[i
].module
!= module
; i
++)
3181 if (i
>= pe_def_file
->num_imports
)
3184 dll_filename
= module
->name
;
3185 dll_symname
= xstrdup (module
->name
);
3186 for (j
= 0; dll_symname
[j
]; j
++)
3187 if (!ISALNUM (dll_symname
[j
]))
3188 dll_symname
[j
] = '_';
3190 for (; i
< pe_def_file
->num_imports
&& imp
[i
].module
== module
; i
++)
3192 def_file_export exp
;
3193 struct bfd_link_hash_entry
*blhe
;
3194 int lead_at
= (*imp
[i
].internal_name
== '@');
3195 /* See if we need this import. */
3196 size_t len
= strlen (imp
[i
].internal_name
);
3197 char *name
= xmalloc (len
+ 2 + 6);
3198 bfd_boolean include_jmp_stub
= FALSE
;
3199 bfd_boolean is_cdecl
= FALSE
;
3200 bfd_boolean is_undef
= FALSE
;
3202 if (!lead_at
&& strchr (imp
[i
].internal_name
, '@') == NULL
)
3206 sprintf (name
, "%s", imp
[i
].internal_name
);
3208 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3210 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3211 FALSE
, FALSE
, FALSE
);
3213 /* Include the jump stub for <sym> only if the <sym>
3215 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
3218 sprintf (name
, "%s%s", "__imp_", imp
[i
].internal_name
);
3220 sprintf (name
, "%s%s%s", "__imp_", U (""),
3221 imp
[i
].internal_name
);
3223 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
3224 FALSE
, FALSE
, FALSE
);
3226 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3230 include_jmp_stub
= TRUE
;
3231 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3234 if (is_cdecl
&& (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
)))
3236 sprintf (name
, "%s%s",U (""), imp
[i
].internal_name
);
3237 blhe
= pe_find_cdecl_alias_match (linfo
, name
);
3238 include_jmp_stub
= TRUE
;
3240 is_undef
= (blhe
->type
== bfd_link_hash_undefined
);
3251 bfd
*ar_head
= make_head (output_bfd
);
3252 add_bfd_to_link (ar_head
, bfd_get_filename (ar_head
), linfo
);
3255 exp
.internal_name
= imp
[i
].internal_name
;
3256 exp
.name
= imp
[i
].name
;
3257 exp
.its_name
= imp
[i
].its_name
;
3258 exp
.ordinal
= imp
[i
].ordinal
;
3259 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
3260 exp
.flag_private
= 0;
3261 exp
.flag_constant
= 0;
3262 exp
.flag_data
= imp
[i
].data
;
3263 exp
.flag_noname
= exp
.name
? 0 : 1;
3264 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
3265 add_bfd_to_link (one
, bfd_get_filename (one
), linfo
);
3270 bfd
*ar_tail
= make_tail (output_bfd
);
3271 add_bfd_to_link (ar_tail
, bfd_get_filename (ar_tail
), linfo
);
3280 free (udef_table
[undef_count
].key
);
3285 /* We were handed a *.DLL file. Parse it and turn it into a set of
3286 IMPORTS directives in the def file. Return TRUE if the file was
3287 handled, FALSE if not. */
3290 pe_get16 (bfd
*abfd
, int where
)
3294 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3295 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3296 return b
[0] + (b
[1] << 8);
3300 pe_get32 (bfd
*abfd
, int where
)
3304 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
3305 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
3306 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3312 unsigned char *b
= ptr
;
3314 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + ((unsigned) b
[3] << 24);
3318 pe_implied_import_dll (const char *filename
)
3321 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
3322 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
3323 bfd_vma exp_funcbase
;
3324 unsigned char *expdata
;
3326 bfd_vma name_rvas
, nexp
;
3327 const char *dllname
;
3328 /* Initialization with start > end guarantees that is_data
3329 will not be set by mistake, and avoids compiler warning. */
3330 bfd_vma data_start
= 1;
3331 bfd_vma data_end
= 0;
3332 bfd_vma rdata_start
= 1;
3333 bfd_vma rdata_end
= 0;
3334 bfd_vma bss_start
= 1;
3335 bfd_vma bss_end
= 0;
3338 /* No, I can't use bfd here. kernel32.dll puts its export table in
3339 the middle of the .rdata section. */
3340 dll
= bfd_openr (filename
, pe_details
->target_name
);
3343 einfo (_("%X%P: open %s: %E\n"), filename
);
3347 track_dependency_files (filename
);
3349 /* PEI dlls seem to be bfd_objects. */
3350 if (!bfd_check_format (dll
, bfd_object
))
3352 einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename
);
3356 /* Get pe_header, optional header and numbers of directory entries. */
3357 pe_header_offset
= pe_get32 (dll
, 0x3c);
3358 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3359 #ifdef pe_use_x86_64
3360 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3362 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3365 /* No import or export directory entry. */
3366 if (num_entries
< 1)
3369 #ifdef pe_use_x86_64
3370 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3371 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3373 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3374 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3377 /* No export table - nothing to export. */
3378 if (export_size
== 0)
3381 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3382 secptr
= (pe_header_offset
+ 4 + 20 +
3383 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3386 /* Get the rva and size of the export section. */
3387 for (i
= 0; i
< nsections
; i
++)
3390 bfd_vma secptr1
= secptr
+ 40 * i
;
3391 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3392 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3393 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3395 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3396 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3398 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3400 expptr
= fptr
+ (export_rva
- vaddr
);
3401 if (export_rva
+ export_size
> vaddr
+ vsize
)
3402 export_size
= vsize
- (export_rva
- vaddr
);
3407 /* Scan sections and store the base and size of the
3408 data and bss segments in data/base_start/end. */
3409 for (i
= 0; i
< nsections
; i
++)
3411 bfd_vma secptr1
= secptr
+ 40 * i
;
3412 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3413 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3414 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3418 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3419 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3421 if (strcmp(sec_name
,".data") == 0)
3424 data_end
= vaddr
+ vsize
;
3426 if (pe_dll_extra_pe_debug
)
3427 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3428 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3429 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3431 else if (strcmp(sec_name
,".rdata") == 0)
3433 rdata_start
= vaddr
;
3434 rdata_end
= vaddr
+ vsize
;
3436 if (pe_dll_extra_pe_debug
)
3437 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3438 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3439 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3441 else if (strcmp (sec_name
,".bss") == 0)
3444 bss_end
= vaddr
+ vsize
;
3446 if (pe_dll_extra_pe_debug
)
3447 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3448 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3449 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3453 expdata
= xmalloc (export_size
);
3454 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3455 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3456 erva
= (char *) expdata
- export_rva
;
3458 if (pe_def_file
== 0)
3459 pe_def_file
= def_file_empty ();
3461 nexp
= pe_as32 (expdata
+ 24);
3462 name_rvas
= pe_as32 (expdata
+ 32);
3463 exp_funcbase
= pe_as32 (expdata
+ 28);
3465 /* Use internal dll name instead of filename
3466 to enable symbolic dll linking. */
3467 dllname
= erva
+ pe_as32 (expdata
+ 12);
3469 /* Check to see if the dll has already been added to
3470 the definition list and if so return without error.
3471 This avoids multiple symbol definitions. */
3472 if (def_get_module (pe_def_file
, dllname
))
3474 if (pe_dll_extra_pe_debug
)
3475 printf ("%s is already loaded\n", dllname
);
3479 /* This is an optimized version of the insertion loop, which avoids lots of
3480 calls to realloc and memmove from def_file_add_import. */
3481 if ((from
= def_file_add_import_from (pe_def_file
, nexp
,
3482 erva
+ pe_as32 (erva
+ name_rvas
),
3483 dllname
, 0, NULL
, NULL
)) >= 0)
3485 for (i
= 0; i
< nexp
; i
++)
3487 /* Pointer to the names vector. */
3488 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3489 def_file_import
*imp
;
3490 /* Pointer to the function address vector. */
3491 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3492 /* is_data is true if the address is in the data, rdata or bss
3495 (func_rva
>= data_start
&& func_rva
< data_end
)
3496 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3497 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3499 imp
= def_file_add_import_at (pe_def_file
, from
+ i
, erva
+ name_rva
,
3500 dllname
, i
, NULL
, NULL
);
3501 /* Mark symbol type. */
3502 imp
->data
= is_data
;
3504 if (pe_dll_extra_pe_debug
)
3505 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3506 __FUNCTION__
, dllname
, erva
+ name_rva
,
3507 (unsigned long) func_rva
, is_data
? "(data)" : "");
3513 /* Iterate through the list of symbols. */
3514 for (i
= 0; i
< nexp
; i
++)
3516 /* Pointer to the names vector. */
3517 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3518 def_file_import
*imp
;
3519 /* Pointer to the function address vector. */
3520 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3523 /* Skip unwanted symbols, which are
3524 exported in buggy auto-import releases. */
3525 if (! CONST_STRNEQ (erva
+ name_rva
, "__nm_"))
3528 /* is_data is true if the address is in the data, rdata or bss
3531 (func_rva
>= data_start
&& func_rva
< data_end
)
3532 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3533 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3535 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3536 dllname
, i
, NULL
, NULL
, &is_dup
);
3537 /* Mark symbol type. */
3539 imp
->data
= is_data
;
3541 if (pe_dll_extra_pe_debug
)
3542 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3543 __FUNCTION__
, dllname
, erva
+ name_rva
,
3544 (unsigned long) func_rva
, is_data
? "(data)" : "");
3552 pe_output_file_set_long_section_names (bfd
*abfd
)
3554 if (pe_use_coff_long_section_names
< 0)
3556 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3557 einfo (_("%X%P: error: can't use long section names on this arch\n"));
3560 /* These are the main functions, called from the emulation. The first
3561 is called after the bfds are read, so we can guess at how much space
3562 we need. The second is called after everything is placed, so we
3563 can put the right values in place. */
3566 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3568 pe_dll_id_target (bfd_get_target (abfd
));
3569 pe_output_file_set_long_section_names (abfd
);
3570 process_def_file_and_drectve (abfd
, info
);
3572 if (pe_def_file
->num_exports
== 0 && !bfd_link_pic (info
))
3574 if (pe_dll_enable_reloc_section
)
3576 build_filler_bfd (0);
3577 pe_output_file_set_long_section_names (filler_bfd
);
3582 generate_edata (abfd
, info
);
3583 build_filler_bfd (1);
3584 pe_output_file_set_long_section_names (filler_bfd
);
3588 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3590 pe_dll_id_target (bfd_get_target (abfd
));
3591 pe_output_file_set_long_section_names (abfd
);
3592 build_filler_bfd (0);
3593 pe_output_file_set_long_section_names (filler_bfd
);
3597 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3599 pe_exe_fill_sections (abfd
, info
);
3603 fill_edata (abfd
, info
);
3604 edata_s
->contents
= edata_d
;
3607 if (bfd_link_dll (info
))
3608 pe_data (abfd
)->dll
= 1;
3612 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3614 pe_dll_id_target (bfd_get_target (abfd
));
3615 pe_output_file_set_long_section_names (abfd
);
3616 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3618 generate_reloc (abfd
, info
);
3621 bfd_set_section_size (reloc_s
, reloc_sz
);
3623 /* Resize the sections. */
3624 lang_reset_memory_regions ();
3625 lang_size_sections (NULL
, TRUE
);
3627 /* Redo special stuff. */
3628 ldemul_after_allocation ();
3630 /* Do the assignments again. */
3631 lang_do_assignments (lang_final_phase_enum
);
3633 reloc_s
->contents
= reloc_d
;
3637 pe_bfd_is_dll (bfd
*abfd
)
3639 return (bfd_get_format (abfd
) == bfd_object
3641 && pe_data (abfd
)->dll
);