1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010 Free Software Foundation, Inc.
4 Written by DJ Delorie <dj@cygnus.com>
6 This file is part of the GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 #include "libiberty.h"
27 #include "safe-ctype.h"
40 #include "coff/internal.h"
41 #include "../bfd/libcoff.h"
46 #define PE_IDATA4_SIZE 8
47 #define PE_IDATA5_SIZE 8
50 #define AOUTSZ PEPAOUTSZ
51 #define PEAOUTHDR PEPAOUTHDR
59 #ifndef PE_IDATA4_SIZE
60 #define PE_IDATA4_SIZE 4
63 #ifndef PE_IDATA5_SIZE
64 #define PE_IDATA5_SIZE 4
67 /* This file turns a regular Windows PE image into a DLL. Because of
68 the complexity of this operation, it has been broken down into a
69 number of separate modules which are all called by the main function
70 at the end of this file. This function is not re-entrant and is
71 normally only called once, so static variables are used to reduce
72 the number of parameters and return values required.
74 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
76 /* Auto-import feature by Paul Sokolovsky
80 1. With this feature on, DLL clients can import variables from DLL
81 without any concern from their side (for example, without any source
84 2. This is done completely in bounds of the PE specification (to be fair,
85 there's a place where it pokes nose out of, but in practice it works).
86 So, resulting module can be used with any other PE compiler/linker.
88 3. Auto-import is fully compatible with standard import method and they
89 can be mixed together.
91 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
92 reference to it; load time: negligible; virtual/physical memory: should be
93 less than effect of DLL relocation, and I sincerely hope it doesn't affect
94 DLL sharability (too much).
98 The obvious and only way to get rid of dllimport insanity is to make client
99 access variable directly in the DLL, bypassing extra dereference. I.e.,
100 whenever client contains something like
104 address of dll_var in the command should be relocated to point into loaded
105 DLL. The aim is to make OS loader do so, and than make ld help with that.
106 Import section of PE made following way: there's a vector of structures
107 each describing imports from particular DLL. Each such structure points
108 to two other parallel vectors: one holding imported names, and one which
109 will hold address of corresponding imported name. So, the solution is
110 de-vectorize these structures, making import locations be sparse and
111 pointing directly into code. Before continuing, it is worth a note that,
112 while authors strives to make PE act ELF-like, there're some other people
113 make ELF act PE-like: elfvector, ;-) .
117 For each reference of data symbol to be imported from DLL (to set of which
118 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
119 import fixup entry is generated. That entry is of type
120 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
121 fixup entry contains pointer to symbol's address within .text section
122 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
123 (so, DLL name is referenced by multiple entries), and pointer to symbol
124 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
125 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
126 containing imported name. Here comes that "on the edge" problem mentioned
127 above: PE specification rambles that name vector (OriginalFirstThunk)
128 should run in parallel with addresses vector (FirstThunk), i.e. that they
129 should have same number of elements and terminated with zero. We violate
130 this, since FirstThunk points directly into machine code. But in practice,
131 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
132 puts addresses to FirstThunk, not something else. It once again should be
133 noted that dll and symbol name structures are reused across fixup entries
134 and should be there anyway to support standard import stuff, so sustained
135 overhead is 20 bytes per reference. Other question is whether having several
136 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
137 done even by native compiler/linker (libth32's functions are in fact reside
138 in windows9x kernel32.dll, so if you use it, you have two
139 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
140 referencing the same PE structures several times is valid. The answer is why
141 not, prohibiting that (detecting violation) would require more work on
142 behalf of loader than not doing it.
144 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
146 static void add_bfd_to_link (bfd
*, const char *, struct bfd_link_info
*);
148 /* For emultempl/pe.em. */
150 def_file
* pe_def_file
= 0;
151 int pe_dll_export_everything
= 0;
152 int pe_dll_exclude_all_symbols
= 0;
153 int pe_dll_do_default_excludes
= 1;
154 int pe_dll_kill_ats
= 0;
155 int pe_dll_stdcall_aliases
= 0;
156 int pe_dll_warn_dup_exports
= 0;
157 int pe_dll_compat_implib
= 0;
158 int pe_dll_extra_pe_debug
= 0;
159 int pe_use_nul_prefixed_import_tables
= 0;
160 int pe_use_coff_long_section_names
= -1;
161 int pe_leading_underscore
= -1;
163 /* Static variables and types. */
165 static bfd_vma image_base
;
166 static bfd
*filler_bfd
;
167 static struct bfd_section
*edata_s
, *reloc_s
;
168 static unsigned char *edata_d
, *reloc_d
;
169 static size_t edata_sz
, reloc_sz
;
170 static int runtime_pseudo_relocs_created
= 0;
171 static int runtime_pseudp_reloc_v2_init
= 0;
178 autofilter_entry_type
;
182 const char *target_name
;
183 const char *object_target
;
184 unsigned int imagebase_reloc
;
187 bfd_boolean underscored
;
188 const autofilter_entry_type
* autofilter_symbollist
;
192 static const autofilter_entry_type autofilter_symbollist_generic
[] =
194 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
195 /* Entry point symbols. */
196 { STRING_COMMA_LEN ("DllMain") },
197 { STRING_COMMA_LEN ("DllMainCRTStartup") },
198 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
199 /* Runtime pseudo-reloc. */
200 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
201 { STRING_COMMA_LEN ("do_pseudo_reloc") },
205 static const autofilter_entry_type autofilter_symbollist_i386
[] =
207 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
208 /* Entry point symbols, and entry hooks. */
209 { STRING_COMMA_LEN ("cygwin_crt0") },
211 { STRING_COMMA_LEN ("DllMain") },
212 { STRING_COMMA_LEN ("DllEntryPoint") },
213 { STRING_COMMA_LEN ("DllMainCRTStartup") },
214 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
215 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
216 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
218 { STRING_COMMA_LEN ("DllMain@12") },
219 { STRING_COMMA_LEN ("DllEntryPoint@0") },
220 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
221 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
222 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
223 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
224 { STRING_COMMA_LEN ("cygwin_attach_dll") },
226 { STRING_COMMA_LEN ("cygwin_premain0") },
227 { STRING_COMMA_LEN ("cygwin_premain1") },
228 { STRING_COMMA_LEN ("cygwin_premain2") },
229 { STRING_COMMA_LEN ("cygwin_premain3") },
230 /* Runtime pseudo-reloc. */
231 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
232 { STRING_COMMA_LEN ("do_pseudo_reloc") },
233 /* Global vars that should not be exported. */
234 { STRING_COMMA_LEN ("impure_ptr") },
235 { STRING_COMMA_LEN ("_impure_ptr") },
236 { STRING_COMMA_LEN ("_fmode") },
237 { STRING_COMMA_LEN ("environ") },
241 #define PE_ARCH_i386 1
243 #define PE_ARCH_mips 3
244 #define PE_ARCH_arm 4
245 #define PE_ARCH_arm_epoc 5
246 #define PE_ARCH_arm_wince 6
248 /* Don't make it constant as underscore mode gets possibly overriden
249 by target or -(no-)leading-underscore option. */
250 static pe_details_type pe_detail_list
[] =
269 autofilter_symbollist_i386
274 16 /* R_SH_IMAGEBASE */,
278 autofilter_symbollist_generic
287 autofilter_symbollist_generic
296 autofilter_symbollist_generic
299 "epoc-pei-arm-little",
300 "epoc-pe-arm-little",
305 autofilter_symbollist_generic
308 "pei-arm-wince-little",
309 "pe-arm-wince-little",
310 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
314 autofilter_symbollist_generic
316 { NULL
, NULL
, 0, 0, 0, FALSE
, NULL
}
319 static const pe_details_type
*pe_details
;
321 /* Do not specify library suffix explicitly, to allow for dllized versions. */
322 static const autofilter_entry_type autofilter_liblist
[] =
324 { STRING_COMMA_LEN ("libcegcc") },
325 { STRING_COMMA_LEN ("libcygwin") },
326 { STRING_COMMA_LEN ("libgcc") },
327 { STRING_COMMA_LEN ("libgcc_s") },
328 { STRING_COMMA_LEN ("libstdc++") },
329 { STRING_COMMA_LEN ("libmingw32") },
330 { STRING_COMMA_LEN ("libmingwex") },
331 { STRING_COMMA_LEN ("libg2c") },
332 { STRING_COMMA_LEN ("libsupc++") },
333 { STRING_COMMA_LEN ("libobjc") },
334 { STRING_COMMA_LEN ("libgcj") },
338 /* Regardless of the suffix issue mentioned above, we must ensure that
339 we do not falsely match on a leading substring, such as when libtool
340 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
341 This routine ensures that the leading part of the name matches and that
342 it is followed by only an optional version suffix and a file extension,
343 returning zero if so or -1 if not. */
344 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
346 if (strncmp (libname
, afptr
->name
, afptr
->len
))
349 libname
+= afptr
->len
;
351 /* Be liberal in interpreting what counts as a version suffix; we
352 accept anything that has a dash to separate it from the name and
353 begins with a digit. */
354 if (libname
[0] == '-')
356 if (!ISDIGIT (*++libname
))
358 /* Ensure the filename has an extension. */
359 while (*++libname
!= '.')
363 else if (libname
[0] != '.')
369 static const autofilter_entry_type autofilter_objlist
[] =
371 { STRING_COMMA_LEN ("crt0.o") },
372 { STRING_COMMA_LEN ("crt1.o") },
373 { STRING_COMMA_LEN ("crt2.o") },
374 { STRING_COMMA_LEN ("dllcrt1.o") },
375 { STRING_COMMA_LEN ("dllcrt2.o") },
376 { STRING_COMMA_LEN ("gcrt0.o") },
377 { STRING_COMMA_LEN ("gcrt1.o") },
378 { STRING_COMMA_LEN ("gcrt2.o") },
379 { STRING_COMMA_LEN ("crtbegin.o") },
380 { STRING_COMMA_LEN ("crtend.o") },
384 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
386 /* _imp_ is treated specially, as it is always underscored. */
387 /* { STRING_COMMA_LEN ("_imp_") }, */
388 /* Don't export some c++ symbols. */
389 { STRING_COMMA_LEN ("__rtti_") },
390 { STRING_COMMA_LEN ("__builtin_") },
391 /* Don't re-export auto-imported symbols. */
392 { STRING_COMMA_LEN ("__nm_") },
393 /* Don't export symbols specifying internal DLL layout. */
394 { STRING_COMMA_LEN ("_head_") },
395 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
396 /* Don't export section labels or artificial symbols
398 { STRING_COMMA_LEN (".") },
402 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
404 { STRING_COMMA_LEN ("_iname") },
405 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
409 #define U(str) (pe_details->underscored ? "_" str : str)
412 pe_dll_id_target (const char *target
)
416 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
417 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
418 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
420 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
422 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
425 pe_detail_list
[i
].underscored
= (u
!= 0 ? TRUE
: FALSE
);
426 pe_details
= pe_detail_list
+ i
;
427 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
430 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
434 /* Helper functions for qsort. Relocs must be sorted so that we can write
435 them out by pages. */
446 reloc_sort (const void *va
, const void *vb
)
448 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
449 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
451 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
455 pe_export_sort (const void *va
, const void *vb
)
457 const def_file_export
*a
= va
;
458 const def_file_export
*b
= vb
;
466 return strcmp (an
, bn
);
469 /* Read and process the .DEF file. */
471 /* These correspond to the entries in pe_def_file->exports[]. I use
472 exported_symbol_sections[i] to tag whether or not the symbol was
473 defined, since we can't export symbols we don't have. */
475 static bfd_vma
*exported_symbol_offsets
;
476 static struct bfd_section
**exported_symbol_sections
;
477 static int export_table_size
;
478 static int count_exported
;
479 static int count_exported_byname
;
480 static int count_with_ordinals
;
481 static const char *dll_name
;
482 static int min_ordinal
, max_ordinal
;
483 static int *exported_symbols
;
485 typedef struct exclude_list_struct
488 struct exclude_list_struct
*next
;
493 static struct exclude_list_struct
*excludes
= 0;
496 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
499 char *exclude_string
;
501 local_copy
= xstrdup (new_excludes
);
503 exclude_string
= strtok (local_copy
, ",:");
504 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
506 struct exclude_list_struct
*new_exclude
;
508 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
509 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
510 strcpy (new_exclude
->string
, exclude_string
);
511 new_exclude
->type
= type
;
512 new_exclude
->next
= excludes
;
513 excludes
= new_exclude
;
520 is_import (const char* n
)
522 return (CONST_STRNEQ (n
, "__imp_"));
525 /* abfd is a bfd containing n (or NULL)
526 It can be used for contextual checks. */
529 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
532 struct exclude_list_struct
*ex
;
533 const autofilter_entry_type
*afptr
;
534 const char * libname
= 0;
535 if (abfd
&& abfd
->my_archive
)
536 libname
= lbasename (abfd
->my_archive
->filename
);
538 for (i
= 0; i
< d
->num_exports
; i
++)
539 if (strcmp (d
->exports
[i
].name
, n
) == 0)
542 if (pe_dll_do_default_excludes
)
547 if (pe_dll_extra_pe_debug
)
548 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
549 n
, abfd
, abfd
->my_archive
);
551 /* First of all, make context checks:
552 Don't export anything from standard libs. */
555 afptr
= autofilter_liblist
;
559 if (libnamencmp (libname
, afptr
) == 0 )
565 /* Next, exclude symbols from certain startup objects. */
567 if (abfd
&& (p
= lbasename (abfd
->filename
)))
569 afptr
= autofilter_objlist
;
572 if (strcmp (p
, afptr
->name
) == 0)
578 /* Don't try to blindly exclude all symbols
579 that begin with '__'; this was tried and
580 it is too restrictive. Instead we have
581 a target specific list to use: */
582 afptr
= pe_details
->autofilter_symbollist
;
586 if (strcmp (n
, afptr
->name
) == 0)
592 /* Next, exclude symbols starting with ... */
593 afptr
= autofilter_symbolprefixlist
;
596 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
602 /* Finally, exclude symbols ending with ... */
604 afptr
= autofilter_symbolsuffixlist
;
607 if ((len
>= afptr
->len
)
608 /* Add 1 to insure match with trailing '\0'. */
609 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
610 afptr
->len
+ 1) == 0)
617 for (ex
= excludes
; ex
; ex
= ex
->next
)
619 if (ex
->type
== EXCLUDELIBS
)
622 && ((strcmp (libname
, ex
->string
) == 0)
623 || (strcasecmp ("ALL", ex
->string
) == 0)))
626 else if (ex
->type
== EXCLUDEFORIMPLIB
)
628 if (strcmp (abfd
->filename
, ex
->string
) == 0)
631 else if (strcmp (n
, ex
->string
) == 0)
639 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
642 struct bfd_link_hash_entry
*blhe
;
644 struct bfd_section
*s
;
645 def_file_export
*e
= 0;
648 pe_def_file
= def_file_empty ();
650 /* First, run around to all the objects looking for the .drectve
651 sections, and push those into the def file too. */
652 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
654 s
= bfd_get_section_by_name (b
, ".drectve");
658 char *buf
= xmalloc (size
);
660 bfd_get_section_contents (b
, s
, buf
, 0, size
);
661 def_file_add_directive (pe_def_file
, buf
, size
);
666 /* Process aligned common symbol information from the
667 .drectve sections now; common symbol allocation is
668 done before final link, so it will be too late to
669 process them in process_embedded_commands() called
670 from _bfd_coff_link_input_bfd(). */
671 if (pe_def_file
->aligncomms
)
673 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
676 struct coff_link_hash_entry
*sym_hash
;
677 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
678 ac
->symbol_name
, FALSE
, FALSE
, FALSE
);
679 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
680 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
682 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
688 /* If we are building an executable and there is nothing
689 to export, we do not build an export table at all. */
690 if (info
->executable
&& pe_def_file
->num_exports
== 0
691 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
694 /* Now, maybe export everything else the default way. */
695 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
696 && !pe_dll_exclude_all_symbols
)
698 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
703 if (!bfd_generic_link_read_symbols (b
))
705 einfo (_("%B%F: could not read symbols: %E\n"), b
);
709 symbols
= bfd_get_outsymbols (b
);
710 nsyms
= bfd_get_symcount (b
);
712 for (j
= 0; j
< nsyms
; j
++)
714 /* We should export symbols which are either global or not
715 anything at all. (.bss data is the latter)
716 We should not export undefined symbols. */
717 bfd_boolean would_export
= symbols
[j
]->section
!= &bfd_und_section
718 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
719 || (symbols
[j
]->flags
== 0));
720 if (lang_elf_version_info
&& would_export
)
722 bfd_boolean hide
= 0;
723 (void) bfd_find_version_for_sym (lang_elf_version_info
,
724 symbols
[j
]->name
, &hide
);
725 would_export
= !hide
;
729 const char *sn
= symbols
[j
]->name
;
731 /* We should not re-export imported stuff. */
737 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
738 sprintf (name
, "%s%s", "__imp_", sn
);
740 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
741 FALSE
, FALSE
, FALSE
);
744 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
748 if (pe_details
->underscored
&& *sn
== '_')
751 if (auto_export (b
, pe_def_file
, sn
))
754 p
=def_file_add_export (pe_def_file
, sn
, 0, -1, NULL
);
755 /* Fill data flag properly, from dlltool.c. */
756 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
764 #define NE pe_def_file->num_exports
766 /* Don't create an empty export table. */
770 /* Canonicalize the export list. */
773 for (i
= 0; i
< NE
; i
++)
775 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
777 /* This will preserve internal_name, which may have been
778 pointing to the same memory as name, or might not
780 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
781 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
782 char *tmp_at
= strchr (tmp
, '@');
787 einfo (_("%XCannot export %s: invalid export name\n"),
788 pe_def_file
->exports
[i
].name
);
789 pe_def_file
->exports
[i
].name
= tmp
;
794 if (pe_dll_stdcall_aliases
)
796 for (i
= 0; i
< NE
; i
++)
798 if (is_import (pe_def_file
->exports
[i
].name
))
801 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
803 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
804 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
806 *(strchr (tmp
, '@')) = 0;
807 if (auto_export (NULL
, pe_def_file
, tmp
))
808 def_file_add_export (pe_def_file
, tmp
,
809 pe_def_file
->exports
[i
].internal_name
,
817 /* Convenience, but watch out for it changing. */
818 e
= pe_def_file
->exports
;
820 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
821 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
823 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
827 count_exported_byname
= 0;
828 count_with_ordinals
= 0;
830 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
832 for (i
= 0, j
= 0; i
< NE
; i
++)
834 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
836 /* This is a duplicate. */
837 if (e
[j
- 1].ordinal
!= -1
838 && e
[i
].ordinal
!= -1
839 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
841 if (pe_dll_warn_dup_exports
)
842 /* xgettext:c-format */
843 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
844 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
848 if (pe_dll_warn_dup_exports
)
849 /* xgettext:c-format */
850 einfo (_("Warning, duplicate EXPORT: %s\n"),
854 if (e
[i
].ordinal
!= -1)
855 e
[j
- 1].ordinal
= e
[i
].ordinal
;
856 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
857 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
858 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
859 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
868 pe_def_file
->num_exports
= j
; /* == NE */
870 for (i
= 0; i
< NE
; i
++)
873 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
874 if (pe_details
->underscored
875 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
878 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
881 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
883 blhe
= bfd_link_hash_lookup (info
->hash
,
888 && (blhe
->type
== bfd_link_hash_defined
889 || (blhe
->type
== bfd_link_hash_common
)))
892 if (!pe_def_file
->exports
[i
].flag_noname
)
893 count_exported_byname
++;
895 /* Only fill in the sections. The actual offsets are computed
896 in fill_exported_offsets() after common symbols are laid
898 if (blhe
->type
== bfd_link_hash_defined
)
899 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
901 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
903 if (pe_def_file
->exports
[i
].ordinal
!= -1)
905 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
906 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
907 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
908 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
909 count_with_ordinals
++;
912 /* Check for forward exports. These are indicated in DEF files by an
913 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
914 but we must take care not to be fooled when the user wants to export
915 a symbol that actually really has a dot in it, so we only check
916 for them here, after real defined symbols have already been matched. */
917 else if (strchr (pe_def_file
->exports
[i
].internal_name
, '.'))
920 if (!pe_def_file
->exports
[i
].flag_noname
)
921 count_exported_byname
++;
923 pe_def_file
->exports
[i
].flag_forward
= 1;
925 if (pe_def_file
->exports
[i
].ordinal
!= -1)
927 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
928 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
929 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
930 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
931 count_with_ordinals
++;
934 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
936 /* xgettext:c-format */
937 einfo (_("%XCannot export %s: symbol not defined\n"),
938 pe_def_file
->exports
[i
].internal_name
);
942 /* xgettext:c-format */
943 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
944 pe_def_file
->exports
[i
].internal_name
,
945 blhe
->type
, bfd_link_hash_defined
);
949 /* xgettext:c-format */
950 einfo (_("%XCannot export %s: symbol not found\n"),
951 pe_def_file
->exports
[i
].internal_name
);
957 /* Build the bfd that will contain .edata and .reloc sections. */
960 build_filler_bfd (int include_edata
)
962 lang_input_statement_type
*filler_file
;
963 filler_file
= lang_add_input_file ("dll stuff",
964 lang_input_file_is_fake_enum
,
966 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
967 link_info
.output_bfd
);
968 if (filler_bfd
== NULL
969 || !bfd_set_arch_mach (filler_bfd
,
970 bfd_get_arch (link_info
.output_bfd
),
971 bfd_get_mach (link_info
.output_bfd
)))
973 einfo ("%X%P: can not create BFD: %E\n");
979 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
981 || !bfd_set_section_flags (filler_bfd
, edata_s
,
988 einfo ("%X%P: can not create .edata section: %E\n");
991 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
994 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
996 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
1003 einfo ("%X%P: can not create .reloc section: %E\n");
1007 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
1009 ldlang_add_file (filler_file
);
1012 /* Gather all the exported symbols and build the .edata section. */
1015 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1017 int i
, next_ordinal
;
1018 int name_table_size
= 0;
1021 /* First, we need to know how many exported symbols there are,
1022 and what the range of ordinals is. */
1023 if (pe_def_file
->name
)
1024 dll_name
= pe_def_file
->name
;
1027 dll_name
= abfd
->filename
;
1029 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1030 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1031 dll_name
= dlnp
+ 1;
1034 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1036 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1037 min_ordinal
= max_ordinal
- count_exported
+ 1;
1042 max_ordinal
= count_exported
;
1045 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1046 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1047 for (i
= 0; i
< export_table_size
; i
++)
1048 exported_symbols
[i
] = -1;
1050 /* Now we need to assign ordinals to those that don't have them. */
1051 for (i
= 0; i
< NE
; i
++)
1053 if (exported_symbol_sections
[i
] ||
1054 pe_def_file
->exports
[i
].flag_forward
)
1056 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1058 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1059 int pi
= exported_symbols
[ei
];
1063 /* xgettext:c-format */
1064 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1065 pe_def_file
->exports
[i
].ordinal
,
1066 pe_def_file
->exports
[i
].name
,
1067 pe_def_file
->exports
[pi
].name
);
1069 exported_symbols
[ei
] = i
;
1071 if (pe_def_file
->exports
[i
].its_name
)
1072 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1074 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1077 /* Reserve space for the forward name. */
1078 if (pe_def_file
->exports
[i
].flag_forward
)
1080 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1084 next_ordinal
= min_ordinal
;
1085 for (i
= 0; i
< NE
; i
++)
1086 if ((exported_symbol_sections
[i
] ||
1087 pe_def_file
->exports
[i
].flag_forward
) &&
1088 pe_def_file
->exports
[i
].ordinal
== -1)
1090 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1093 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1094 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1097 /* OK, now we can allocate some memory. */
1098 edata_sz
= (40 /* directory */
1099 + 4 * export_table_size
/* addresses */
1100 + 4 * count_exported_byname
/* name ptrs */
1101 + 2 * count_exported_byname
/* ordinals */
1102 + name_table_size
+ strlen (dll_name
) + 1);
1105 /* Fill the exported symbol offsets. The preliminary work has already
1106 been done in process_def_file_and_drectve(). */
1109 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1112 struct bfd_link_hash_entry
*blhe
;
1114 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1118 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1119 if (pe_details
->underscored
1120 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1123 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1126 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1128 blhe
= bfd_link_hash_lookup (info
->hash
,
1130 FALSE
, FALSE
, TRUE
);
1132 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1133 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1140 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1143 unsigned char *edirectory
;
1144 unsigned char *eaddresses
;
1145 unsigned char *enameptrs
;
1146 unsigned char *eordinals
;
1152 edata_d
= xmalloc (edata_sz
);
1154 /* Note use of array pointer math here. */
1155 edirectory
= edata_d
;
1156 eaddresses
= edirectory
+ 40;
1157 enameptrs
= eaddresses
+ 4 * export_table_size
;
1158 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1159 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1161 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1162 + edata_s->output_section->vma - image_base)
1164 memset (edata_d
, 0, edata_sz
);
1165 bfd_put_32 (abfd
, now
, edata_d
+ 4);
1166 if (pe_def_file
->version_major
!= -1)
1168 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1169 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1172 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1173 strcpy (enamestr
, dll_name
);
1174 enamestr
+= strlen (enamestr
) + 1;
1175 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1176 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1177 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1178 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1179 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1180 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1182 fill_exported_offsets (abfd
, info
);
1184 /* Ok, now for the filling in part.
1185 Scan alphabetically - ie the ordering in the exports[] table,
1186 rather than by ordinal - the ordering in the exported_symbol[]
1187 table. See dlltool.c and:
1188 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1189 for more information. */
1191 for (s
= 0; s
< NE
; s
++)
1193 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1194 if (pe_def_file
->exports
[s
].ordinal
!= -1 &&
1195 (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1197 int ord
= pe_def_file
->exports
[s
].ordinal
;
1199 if (pe_def_file
->exports
[s
].flag_forward
)
1201 bfd_put_32 (abfd
, ERVA (enamestr
),
1202 eaddresses
+ 4 * (ord
- min_ordinal
));
1204 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1205 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1209 bfd_vma srva
= (exported_symbol_offsets
[s
]
1210 + ssec
->output_section
->vma
1211 + ssec
->output_offset
);
1213 bfd_put_32 (abfd
, srva
- image_base
,
1214 eaddresses
+ 4 * (ord
- min_ordinal
));
1217 if (!pe_def_file
->exports
[s
].flag_noname
)
1219 char *ename
= pe_def_file
->exports
[s
].name
;
1220 if (pe_def_file
->exports
[s
].its_name
)
1221 ename
= pe_def_file
->exports
[s
].its_name
;
1223 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1225 strcpy (enamestr
, ename
);
1226 enamestr
+= strlen (enamestr
) + 1;
1227 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1229 pe_def_file
->exports
[s
].hint
= hint
++;
1236 static struct bfd_section
*current_sec
;
1239 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1241 int (*cb
) (arelent
*, asection
*))
1246 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1250 if (!bfd_generic_link_read_symbols (b
))
1252 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1256 symbols
= bfd_get_outsymbols (b
);
1258 for (s
= b
->sections
; s
; s
= s
->next
)
1261 int relsize
, nrelocs
, i
;
1262 int flags
= bfd_get_section_flags (b
, s
);
1264 /* Skip discarded linkonce sections. */
1265 if (flags
& SEC_LINK_ONCE
1266 && s
->output_section
== bfd_abs_section_ptr
)
1271 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1272 relocs
= xmalloc (relsize
);
1273 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1275 for (i
= 0; i
< nrelocs
; i
++)
1277 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1279 if (!strcmp (name
, sym
->name
))
1285 /* Warning: the allocated symbols are remembered in BFD and reused
1286 later, so don't free them! */
1287 /* free (symbols); */
1292 /* Gather all the relocations and build the .reloc section. */
1295 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1298 /* For .reloc stuff. */
1299 reloc_data_type
*reloc_data
;
1300 int total_relocs
= 0;
1302 bfd_vma sec_page
= (bfd_vma
) -1;
1303 bfd_vma page_ptr
, page_count
;
1306 struct bfd_section
*s
;
1309 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1310 for (s
= b
->sections
; s
; s
= s
->next
)
1311 total_relocs
+= s
->reloc_count
;
1313 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1317 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1320 int relsize
, nrelocs
;
1322 for (s
= b
->sections
; s
; s
= s
->next
)
1324 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1327 /* If it's not loaded, we don't need to relocate it this way. */
1328 if (!(s
->output_section
->flags
& SEC_LOAD
))
1331 /* I don't know why there would be a reloc for these, but I've
1332 seen it happen - DJ */
1333 if (s
->output_section
== &bfd_abs_section
)
1336 if (s
->output_section
->vma
== 0)
1338 /* Huh? Shouldn't happen, but punt if it does. */
1339 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1340 s
->output_section
->name
, s
->output_section
->index
,
1341 s
->output_section
->flags
);
1345 if (!bfd_generic_link_read_symbols (b
))
1347 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1351 symbols
= bfd_get_outsymbols (b
);
1352 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1353 relocs
= xmalloc (relsize
);
1354 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1356 for (i
= 0; i
< nrelocs
; i
++)
1358 if (pe_dll_extra_pe_debug
)
1360 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1361 printf ("rel: %s\n", sym
->name
);
1363 if (!relocs
[i
]->howto
->pc_relative
1364 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1366 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1368 /* Don't create relocs for undefined weak symbols. */
1369 if (sym
->flags
== BSF_WEAK
)
1371 struct bfd_link_hash_entry
*blhe
1372 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1373 FALSE
, FALSE
, FALSE
);
1374 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1376 /* Check aux sym and see if it is defined or not. */
1377 struct coff_link_hash_entry
*h
, *h2
;
1378 h
= (struct coff_link_hash_entry
*)blhe
;
1379 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1381 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1382 [h
->aux
->x_sym
.x_tagndx
.l
];
1383 /* We don't want a base reloc if the aux sym is not
1384 found, undefined, or if it is the constant ABS
1385 zero default value. (We broaden that slightly by
1386 not testing the value, just the section; there's
1387 no reason we'd want a reference to any absolute
1388 address to get relocated during rebasing). */
1389 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1390 || h2
->root
.u
.def
.section
== &bfd_abs_section
)
1393 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1397 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1399 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1401 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1402 relocs
[i
]->howto
->rightshift
)
1404 #ifdef pe_use_x86_64
1405 case BITS_AND_SHIFT (64, 0):
1406 reloc_data
[total_relocs
].type
= 10;
1410 case BITS_AND_SHIFT (32, 0):
1411 reloc_data
[total_relocs
].type
= 3;
1414 case BITS_AND_SHIFT (16, 0):
1415 reloc_data
[total_relocs
].type
= 2;
1418 case BITS_AND_SHIFT (16, 16):
1419 reloc_data
[total_relocs
].type
= 4;
1420 /* FIXME: we can't know the symbol's right value
1421 yet, but we probably can safely assume that
1422 CE will relocate us in 64k blocks, so leaving
1424 reloc_data
[total_relocs
].extra
= 0;
1427 case BITS_AND_SHIFT (26, 2):
1428 reloc_data
[total_relocs
].type
= 5;
1431 case BITS_AND_SHIFT (24, 2):
1432 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1433 Those ARM_xxx definitions should go in proper
1435 if (relocs
[i
]->howto
->type
== 0
1436 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1437 || relocs
[i
]->howto
->type
== 5)
1438 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1439 that has already been fully processed during a
1440 previous link stage, so ignore it here. */
1444 /* xgettext:c-format */
1445 einfo (_("%XError: %d-bit reloc in dll\n"),
1446 relocs
[i
]->howto
->bitsize
);
1452 /* Warning: the allocated symbols are remembered in BFD and
1453 reused later, so don't free them! */
1457 /* At this point, we have total_relocs relocation addresses in
1458 reloc_addresses, which are all suitable for the .reloc section.
1459 We must now create the new sections. */
1460 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1462 for (i
= 0; i
< total_relocs
; i
++)
1464 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1466 if (this_page
!= sec_page
)
1468 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1470 sec_page
= this_page
;
1475 if (reloc_data
[i
].type
== 4)
1479 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1480 reloc_d
= xmalloc (reloc_sz
);
1481 sec_page
= (bfd_vma
) -1;
1483 page_ptr
= (bfd_vma
) -1;
1486 for (i
= 0; i
< total_relocs
; i
++)
1488 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1489 bfd_vma this_page
= (rva
& ~0xfff);
1491 if (this_page
!= sec_page
)
1493 while (reloc_sz
& 3)
1494 reloc_d
[reloc_sz
++] = 0;
1496 if (page_ptr
!= (bfd_vma
) -1)
1497 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1499 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1500 page_ptr
= reloc_sz
;
1502 sec_page
= this_page
;
1506 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1507 reloc_d
+ reloc_sz
);
1510 if (reloc_data
[i
].type
== 4)
1512 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1519 while (reloc_sz
& 3)
1520 reloc_d
[reloc_sz
++] = 0;
1522 if (page_ptr
!= (bfd_vma
) -1)
1523 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1525 while (reloc_sz
< reloc_s
->size
)
1526 reloc_d
[reloc_sz
++] = 0;
1529 /* Given the exiting def_file structure, print out a .DEF file that
1530 corresponds to it. */
1533 quoteput (char *s
, FILE *f
, int needs_quotes
)
1537 for (cp
= s
; *cp
; cp
++)
1552 if (*s
== '"' || *s
== '\\')
1566 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1569 FILE *out
= fopen (pe_out_def_filename
, "w");
1572 /* xgettext:c-format */
1573 einfo (_("%s: Can't open output def file %s\n"),
1574 program_name
, pe_out_def_filename
);
1578 if (pe_def_file
->name
)
1580 if (pe_def_file
->is_dll
)
1581 fprintf (out
, "LIBRARY ");
1583 fprintf (out
, "NAME ");
1585 quoteput (pe_def_file
->name
, out
, 1);
1587 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1589 fprintf (out
, " BASE=0x");
1590 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1592 fprintf (out
, "\n");
1595 if (pe_def_file
->description
)
1597 fprintf (out
, "DESCRIPTION ");
1598 quoteput (pe_def_file
->description
, out
, 1);
1599 fprintf (out
, "\n");
1602 if (pe_def_file
->version_minor
!= -1)
1603 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1604 pe_def_file
->version_minor
);
1605 else if (pe_def_file
->version_major
!= -1)
1606 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1608 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1609 fprintf (out
, "\n");
1611 if (pe_def_file
->stack_commit
!= -1)
1612 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1613 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1614 else if (pe_def_file
->stack_reserve
!= -1)
1615 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1617 if (pe_def_file
->heap_commit
!= -1)
1618 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1619 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1620 else if (pe_def_file
->heap_reserve
!= -1)
1621 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1623 if (pe_def_file
->num_section_defs
> 0)
1625 fprintf (out
, "\nSECTIONS\n\n");
1627 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1630 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1632 if (pe_def_file
->section_defs
[i
].class)
1634 fprintf (out
, " CLASS ");
1635 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1638 if (pe_def_file
->section_defs
[i
].flag_read
)
1639 fprintf (out
, " READ");
1641 if (pe_def_file
->section_defs
[i
].flag_write
)
1642 fprintf (out
, " WRITE");
1644 if (pe_def_file
->section_defs
[i
].flag_execute
)
1645 fprintf (out
, " EXECUTE");
1647 if (pe_def_file
->section_defs
[i
].flag_shared
)
1648 fprintf (out
, " SHARED");
1650 fprintf (out
, "\n");
1654 if (pe_def_file
->num_exports
> 0)
1656 fprintf (out
, "EXPORTS\n");
1658 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1660 def_file_export
*e
= pe_def_file
->exports
+ i
;
1662 quoteput (e
->name
, out
, 0);
1664 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1666 fprintf (out
, " = ");
1667 quoteput (e
->internal_name
, out
, 0);
1670 if (e
->ordinal
!= -1)
1671 fprintf (out
, " @%d", e
->ordinal
);
1673 if (e
->flag_private
)
1674 fprintf (out
, " PRIVATE");
1676 if (e
->flag_constant
)
1677 fprintf (out
, " CONSTANT");
1680 fprintf (out
, " NONAME");
1683 fprintf (out
, " DATA");
1685 fprintf (out
, "\n");
1689 if (pe_def_file
->num_imports
> 0)
1691 fprintf (out
, "\nIMPORTS\n\n");
1693 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1695 def_file_import
*im
= pe_def_file
->imports
+ i
;
1698 if (im
->internal_name
1699 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1701 quoteput (im
->internal_name
, out
, 0);
1702 fprintf (out
, " = ");
1705 quoteput (im
->module
->name
, out
, 0);
1709 quoteput (im
->name
, out
, 0);
1711 fprintf (out
, "%d", im
->ordinal
);
1715 fprintf (out
, " == ");
1716 quoteput (im
->its_name
, out
, 0);
1719 fprintf (out
, "\n");
1724 fprintf (out
, _("; no contents available\n"));
1726 if (fclose (out
) == EOF
)
1727 /* xgettext:c-format */
1728 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1731 /* Generate the import library. */
1733 static asymbol
**symtab
;
1736 static int tmp_seq2
;
1737 static const char *dll_filename
;
1738 static char *dll_symname
;
1740 #define UNDSEC (asection *) &bfd_und_section
1743 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1748 sec
= bfd_make_section_old_way (abfd
, name
);
1749 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1750 bfd_set_section_alignment (abfd
, sec
, align
);
1751 /* Remember to undo this before trying to link internally! */
1752 sec
->output_section
= sec
;
1754 sym
= bfd_make_empty_symbol (abfd
);
1755 symtab
[symptr
++] = sym
;
1756 sym
->name
= sec
->name
;
1758 sym
->flags
= BSF_LOCAL
;
1765 quick_symbol (bfd
*abfd
,
1774 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1779 sym
= bfd_make_empty_symbol (abfd
);
1784 symtab
[symptr
++] = sym
;
1787 static arelent
*reltab
= 0;
1788 static int relcount
= 0, relsize
= 0;
1791 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1793 if (relcount
>= relsize
- 1)
1797 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1799 reltab
= xmalloc (relsize
* sizeof (arelent
));
1801 reltab
[relcount
].address
= address
;
1802 reltab
[relcount
].addend
= 0;
1803 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1804 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1809 save_relocs (asection
*sec
)
1813 sec
->relocation
= reltab
;
1814 sec
->reloc_count
= relcount
;
1815 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1816 for (i
= 0; i
< relcount
; i
++)
1817 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1818 sec
->orelocation
[relcount
] = 0;
1819 sec
->flags
|= SEC_RELOC
;
1821 relcount
= relsize
= 0;
1824 /* .section .idata$2
1825 .global __head_my_dll
1842 make_head (bfd
*parent
)
1844 asection
*id2
, *id5
, *id4
;
1845 unsigned char *d2
, *d5
, *d4
;
1849 oname
= xmalloc (20);
1850 sprintf (oname
, "d%06d.o", tmp_seq
);
1853 abfd
= bfd_create (oname
, parent
);
1854 bfd_find_target (pe_details
->object_target
, abfd
);
1855 bfd_make_writable (abfd
);
1857 bfd_set_format (abfd
, bfd_object
);
1858 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1861 symtab
= xmalloc (6 * sizeof (asymbol
*));
1862 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1863 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1864 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1865 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1866 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1868 /* OK, pay attention here. I got confused myself looking back at
1869 it. We create a four-byte section to mark the beginning of the
1870 list, and we include an offset of 4 in the section, so that the
1871 pointer to the list points to the *end* of this section, which is
1872 the start of the list of sections from other objects. */
1874 bfd_set_section_size (abfd
, id2
, 20);
1878 if (pe_use_nul_prefixed_import_tables
)
1879 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
1880 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1881 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1882 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1885 if (pe_use_nul_prefixed_import_tables
)
1886 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1888 bfd_set_section_size (abfd
, id5
, 0);
1889 d5
= xmalloc (PE_IDATA5_SIZE
);
1891 memset (d5
, 0, PE_IDATA5_SIZE
);
1892 if (pe_use_nul_prefixed_import_tables
)
1893 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1895 bfd_set_section_size (abfd
, id4
, 0);
1896 d4
= xmalloc (PE_IDATA4_SIZE
);
1898 memset (d4
, 0, PE_IDATA4_SIZE
);
1900 bfd_set_symtab (abfd
, symtab
, symptr
);
1902 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1903 if (pe_use_nul_prefixed_import_tables
)
1905 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1906 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1910 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
1911 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
1914 bfd_make_readable (abfd
);
1918 /* .section .idata$4
1925 .global __my_dll_iname
1930 make_tail (bfd
*parent
)
1932 asection
*id4
, *id5
, *id7
;
1933 unsigned char *d4
, *d5
, *d7
;
1938 oname
= xmalloc (20);
1939 sprintf (oname
, "d%06d.o", tmp_seq
);
1942 abfd
= bfd_create (oname
, parent
);
1943 bfd_find_target (pe_details
->object_target
, abfd
);
1944 bfd_make_writable (abfd
);
1946 bfd_set_format (abfd
, bfd_object
);
1947 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1950 symtab
= xmalloc (5 * sizeof (asymbol
*));
1951 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1952 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1953 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1954 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1956 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1957 d4
= xmalloc (PE_IDATA4_SIZE
);
1959 memset (d4
, 0, PE_IDATA4_SIZE
);
1961 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1962 d5
= xmalloc (PE_IDATA5_SIZE
);
1964 memset (d5
, 0, PE_IDATA5_SIZE
);
1966 len
= strlen (dll_filename
) + 1;
1969 bfd_set_section_size (abfd
, id7
, len
);
1972 strcpy ((char *) d7
, dll_filename
);
1973 /* If len was odd, the above
1974 strcpy leaves behind an undefined byte. That is harmless,
1975 but we set it to 0 just so the binary dumps are pretty. */
1978 bfd_set_symtab (abfd
, symtab
, symptr
);
1980 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1981 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1982 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1984 bfd_make_readable (abfd
);
1990 .global ___imp_function
1991 .global __imp__function
1993 jmp *__imp__function:
2007 .asciz "function" xlate? (add underscore, kill at) */
2009 static const unsigned char jmp_ix86_bytes
[] =
2011 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2019 .dw __imp_function */
2021 static const unsigned char jmp_sh_bytes
[] =
2023 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2027 lui $t0,<high:__imp_function>
2028 lw $t0,<low:__imp_function>
2032 static const unsigned char jmp_mips_bytes
[] =
2034 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2035 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2038 static const unsigned char jmp_arm_bytes
[] =
2040 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2041 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2047 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2049 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2050 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2054 const unsigned char *jmp_bytes
= NULL
;
2055 int jmp_byte_count
= 0;
2057 /* Include the jump stub section only if it is needed. A jump
2058 stub is needed if the symbol being imported <sym> is a function
2059 symbol and there is at least one undefined reference to that
2060 symbol. In other words, if all the import references to <sym> are
2061 explicitly through _declspec(dllimport) then the jump stub is not
2063 if (include_jmp_stub
)
2065 switch (pe_details
->pe_arch
)
2068 jmp_bytes
= jmp_ix86_bytes
;
2069 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2072 jmp_bytes
= jmp_sh_bytes
;
2073 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2076 jmp_bytes
= jmp_mips_bytes
;
2077 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2080 case PE_ARCH_arm_epoc
:
2081 case PE_ARCH_arm_wince
:
2082 jmp_bytes
= jmp_arm_bytes
;
2083 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2090 oname
= xmalloc (20);
2091 sprintf (oname
, "d%06d.o", tmp_seq
);
2094 abfd
= bfd_create (oname
, parent
);
2095 bfd_find_target (pe_details
->object_target
, abfd
);
2096 bfd_make_writable (abfd
);
2098 bfd_set_format (abfd
, bfd_object
);
2099 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2102 symtab
= xmalloc (12 * sizeof (asymbol
*));
2104 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2105 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2106 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2107 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2108 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2110 if (*exp
->internal_name
== '@')
2112 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2114 if (include_jmp_stub
)
2115 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2116 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2118 /* Fastcall applies only to functions,
2119 so no need for auto-import symbol. */
2123 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2125 if (include_jmp_stub
)
2126 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2128 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2130 /* Symbol to reference ord/name of imported
2131 data symbol, used to implement auto-import. */
2133 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2136 if (pe_dll_compat_implib
)
2137 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2140 if (include_jmp_stub
)
2142 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
2143 td
= xmalloc (jmp_byte_count
);
2145 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2147 switch (pe_details
->pe_arch
)
2150 #ifdef pe_use_x86_64
2151 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2153 /* Mark this object as SAFESEH compatible. */
2154 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2156 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2160 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2163 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2164 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2165 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2168 case PE_ARCH_arm_epoc
:
2169 case PE_ARCH_arm_wince
:
2170 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2178 bfd_set_section_size (abfd
, tx
, 0);
2180 bfd_set_section_size (abfd
, id7
, 4);
2184 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2187 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2188 d5
= xmalloc (PE_IDATA5_SIZE
);
2190 memset (d5
, 0, PE_IDATA5_SIZE
);
2192 if (exp
->flag_noname
)
2194 d5
[0] = exp
->ordinal
;
2195 d5
[1] = exp
->ordinal
>> 8;
2196 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2200 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2204 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2205 d4
= xmalloc (PE_IDATA4_SIZE
);
2207 memset (d4
, 0, PE_IDATA4_SIZE
);
2209 if (exp
->flag_noname
)
2211 d4
[0] = exp
->ordinal
;
2212 d4
[1] = exp
->ordinal
>> 8;
2213 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2217 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2221 if (exp
->flag_noname
)
2224 bfd_set_section_size (abfd
, id6
, 0);
2228 /* { short, asciz } */
2230 len
= 2 + strlen (exp
->its_name
) + 1;
2232 len
= 2 + strlen (exp
->name
) + 1;
2235 bfd_set_section_size (abfd
, id6
, len
);
2238 memset (d6
, 0, len
);
2239 d6
[0] = exp
->hint
& 0xff;
2240 d6
[1] = exp
->hint
>> 8;
2242 strcpy ((char*) d6
+ 2, exp
->its_name
);
2244 strcpy ((char *) d6
+ 2, exp
->name
);
2247 bfd_set_symtab (abfd
, symtab
, symptr
);
2249 if (include_jmp_stub
)
2250 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2251 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2252 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2253 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2254 if (!exp
->flag_noname
)
2255 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2257 bfd_make_readable (abfd
);
2262 make_singleton_name_imp (const char *import
, bfd
*parent
)
2264 /* Name thunks go to idata$4. */
2270 oname
= xmalloc (20);
2271 sprintf (oname
, "nmimp%06d.o", tmp_seq2
);
2274 abfd
= bfd_create (oname
, parent
);
2275 bfd_find_target (pe_details
->object_target
, abfd
);
2276 bfd_make_writable (abfd
);
2278 bfd_set_format (abfd
, bfd_object
);
2279 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2282 symtab
= xmalloc (3 * sizeof (asymbol
*));
2283 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2284 quick_symbol (abfd
, "__imp_", import
, "", id5
, BSF_GLOBAL
, 0);
2286 /* We need space for the real thunk and for the null terminator. */
2287 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
* 2);
2288 d5
= xmalloc (PE_IDATA5_SIZE
* 2);
2290 memset (d5
, 0, PE_IDATA5_SIZE
* 2);
2291 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2294 bfd_set_symtab (abfd
, symtab
, symptr
);
2296 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA4_SIZE
* 2);
2298 bfd_make_readable (abfd
);
2303 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2305 /* Name thunks go to idata$4. */
2311 oname
= xmalloc (20);
2312 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2315 abfd
= bfd_create (oname
, parent
);
2316 bfd_find_target (pe_details
->object_target
, abfd
);
2317 bfd_make_writable (abfd
);
2319 bfd_set_format (abfd
, bfd_object
);
2320 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2323 symtab
= xmalloc (3 * sizeof (asymbol
*));
2324 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2325 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2326 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2328 /* We need space for the real thunk and for the null terminator. */
2329 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2330 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2332 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2333 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2336 bfd_set_symtab (abfd
, symtab
, symptr
);
2338 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2340 bfd_make_readable (abfd
);
2345 make_import_fixup_mark (arelent
*rel
)
2347 /* We convert reloc to symbol, for later reference. */
2349 static char *fixup_name
= NULL
;
2350 static size_t buffer_len
= 0;
2352 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2354 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2355 struct bfd_link_hash_entry
*bh
;
2359 fixup_name
= xmalloc (384);
2363 if (strlen (sym
->name
) + 25 > buffer_len
)
2364 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2365 bigger than 20 digits long, we've got worse problems than
2366 overflowing this buffer... */
2369 /* New buffer size is length of symbol, plus 25, but
2370 then rounded up to the nearest multiple of 128. */
2371 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2372 fixup_name
= xmalloc (buffer_len
);
2375 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2378 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2379 current_sec
, /* sym->section, */
2380 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2385 /* .section .idata$2
2386 .rva __nm_thnk_SYM (singleton thunk with name of func)
2389 .rva __my_dll_iname (name of dll)
2390 .rva __fuNN_SYM (pointer to reference (address) in text) */
2393 make_import_fixup_entry (const char *name
,
2394 const char *fixup_name
,
2395 const char *symname
,
2403 oname
= xmalloc (20);
2404 sprintf (oname
, "fu%06d.o", tmp_seq
);
2407 abfd
= bfd_create (oname
, parent
);
2408 bfd_find_target (pe_details
->object_target
, abfd
);
2409 bfd_make_writable (abfd
);
2411 bfd_set_format (abfd
, bfd_object
);
2412 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2415 symtab
= xmalloc (6 * sizeof (asymbol
*));
2416 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2418 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2419 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2420 /* For relocator v2 we have to use the .idata$5 element and not
2422 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2423 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2425 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2427 bfd_set_section_size (abfd
, id2
, 20);
2432 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2433 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2434 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2437 bfd_set_symtab (abfd
, symtab
, symptr
);
2439 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2441 bfd_make_readable (abfd
);
2445 /* .section .rdata_runtime_pseudo_reloc
2447 .rva __fuNN_SYM (pointer to reference (address) in text) */
2450 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2451 const char *fixup_name
,
2452 bfd_vma addend ATTRIBUTE_UNUSED
,
2457 unsigned char *rt_rel_d
;
2460 oname
= xmalloc (20);
2461 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2464 abfd
= bfd_create (oname
, parent
);
2465 bfd_find_target (pe_details
->object_target
, abfd
);
2466 bfd_make_writable (abfd
);
2468 bfd_set_format (abfd
, bfd_object
);
2469 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2472 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2474 symtab
= xmalloc ((runtime_pseudp_reloc_v2_init
? 3 : 6) * sizeof (asymbol
*));
2478 symtab
= xmalloc (2 * sizeof (asymbol
*));
2480 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2481 SEC_HAS_CONTENTS
, 2);
2483 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2485 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2488 if (! runtime_pseudp_reloc_v2_init
)
2491 runtime_pseudp_reloc_v2_init
= 1;
2493 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2495 bfd_set_section_size (abfd
, rt_rel
, size
);
2496 rt_rel_d
= xmalloc (size
);
2497 rt_rel
->contents
= rt_rel_d
;
2498 memset (rt_rel_d
, 0, size
);
2499 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2500 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2501 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2503 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2504 save_relocs (rt_rel
);
2506 bfd_set_symtab (abfd
, symtab
, symptr
);
2508 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2512 bfd_set_section_size (abfd
, rt_rel
, 8);
2513 rt_rel_d
= xmalloc (8);
2514 rt_rel
->contents
= rt_rel_d
;
2515 memset (rt_rel_d
, 0, 8);
2517 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2518 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2520 save_relocs (rt_rel
);
2522 bfd_set_symtab (abfd
, symtab
, symptr
);
2524 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2526 bfd_make_readable (abfd
);
2531 .rva __pei386_runtime_relocator */
2534 pe_create_runtime_relocator_reference (bfd
*parent
)
2536 asection
*extern_rt_rel
;
2537 unsigned char *extern_rt_rel_d
;
2541 oname
= xmalloc (20);
2542 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2545 abfd
= bfd_create (oname
, parent
);
2546 bfd_find_target (pe_details
->object_target
, abfd
);
2547 bfd_make_writable (abfd
);
2549 bfd_set_format (abfd
, bfd_object
);
2550 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2553 symtab
= xmalloc (2 * sizeof (asymbol
*));
2554 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2556 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2559 bfd_set_section_size (abfd
, extern_rt_rel
, PE_IDATA5_SIZE
);
2560 extern_rt_rel_d
= xmalloc (PE_IDATA5_SIZE
);
2561 extern_rt_rel
->contents
= extern_rt_rel_d
;
2563 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2564 save_relocs (extern_rt_rel
);
2566 bfd_set_symtab (abfd
, symtab
, symptr
);
2568 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2570 bfd_make_readable (abfd
);
2575 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
)
2578 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2579 struct bfd_link_hash_entry
*name_thunk_sym
;
2580 struct bfd_link_hash_entry
*name_imp_sym
;
2581 const char *name
= sym
->name
;
2582 char *fixup_name
= make_import_fixup_mark (rel
);
2584 int need_import_table
= 1;
2586 sprintf (buf
, "__imp_%s", name
);
2587 name_imp_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2589 sprintf (buf
, "__nm_thnk_%s", name
);
2591 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2593 /* For version 2 pseudo relocation we don't need to add an import
2594 if the import symbol is already present. */
2595 if (link_info
.pei386_runtime_pseudo_reloc
== 2
2597 && name_imp_sym
->type
== bfd_link_hash_defined
)
2598 need_import_table
= 0;
2600 if (need_import_table
== 1
2601 && (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
))
2603 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2604 add_bfd_to_link (b
, b
->filename
, &link_info
);
2606 /* If we ever use autoimport, we have to cast text section writable.
2607 But not for version 2. */
2608 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2610 config
.text_read_only
= FALSE
;
2611 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2613 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2615 b
= make_singleton_name_imp (name
, link_info
.output_bfd
);
2616 add_bfd_to_link (b
, b
->filename
, &link_info
);
2620 if ((addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2621 && need_import_table
== 1)
2623 extern char * pe_data_import_dll
;
2624 char * symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2626 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2627 link_info
.output_bfd
);
2628 add_bfd_to_link (b
, b
->filename
, &link_info
);
2631 if ((link_info
.pei386_runtime_pseudo_reloc
!= 0 && addend
!= 0)
2632 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2634 if (pe_dll_extra_pe_debug
)
2635 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2636 fixup_name
, (int) addend
);
2638 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2639 link_info
.output_bfd
);
2640 add_bfd_to_link (b
, b
->filename
, &link_info
);
2642 if (runtime_pseudo_relocs_created
== 0)
2644 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2645 add_bfd_to_link (b
, b
->filename
, &link_info
);
2647 runtime_pseudo_relocs_created
++;
2649 else if (addend
!= 0)
2651 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2652 s
->owner
, s
, rel
->address
, sym
->name
);
2659 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2668 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2669 dll_symname
= xstrdup (dll_filename
);
2670 for (i
= 0; dll_symname
[i
]; i
++)
2671 if (!ISALNUM (dll_symname
[i
]))
2672 dll_symname
[i
] = '_';
2674 unlink_if_ordinary (impfilename
);
2676 outarch
= bfd_openw (impfilename
, 0);
2680 /* xgettext:c-format */
2681 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2685 /* xgettext:c-format */
2686 info_msg (_("Creating library file: %s\n"), impfilename
);
2688 bfd_set_format (outarch
, bfd_archive
);
2689 outarch
->has_armap
= 1;
2691 /* Work out a reasonable size of things to put onto one line. */
2692 ar_head
= make_head (outarch
);
2694 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2695 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
2697 /* Iterate the exclude list. */
2698 struct exclude_list_struct
*ex
;
2700 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2702 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2704 found
= (strcmp (ex
->string
, ibfd
->filename
) == 0);
2706 /* If it matched, we must open a fresh BFD for it (the original
2707 input BFD is still needed for the DLL's final link) and add
2708 it into the archive member chain. */
2711 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2712 ? ibfd
->my_archive
->filename
: ibfd
->filename
, NULL
);
2715 einfo (_("%Xbfd_openr %s: %E\n"), ibfd
->filename
);
2718 if (ibfd
->my_archive
)
2720 /* Must now iterate through archive until we find the
2721 required member. A minor shame that we'll open the
2722 archive once per member that we require from it, and
2723 leak those archive bfds rather than reuse them. */
2724 bfd
*arbfd
= newbfd
;
2725 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2727 einfo (_("%X%s(%s): can't find member in non-archive file"),
2728 ibfd
->my_archive
->filename
, ibfd
->filename
);
2732 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2734 if (strcmp (newbfd
->filename
, ibfd
->filename
) == 0)
2739 einfo (_("%X%s(%s): can't find member in archive"),
2740 ibfd
->my_archive
->filename
, ibfd
->filename
);
2744 newbfd
->archive_next
= head
;
2749 for (i
= 0; i
< def
->num_exports
; i
++)
2751 /* The import library doesn't know about the internal name. */
2752 char *internal
= def
->exports
[i
].internal_name
;
2755 /* Don't add PRIVATE entries to import lib. */
2756 if (pe_def_file
->exports
[i
].flag_private
)
2758 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2759 n
= make_one (def
->exports
+ i
, outarch
,
2760 ! (def
->exports
+ i
)->flag_data
);
2761 n
->archive_next
= head
;
2763 def
->exports
[i
].internal_name
= internal
;
2766 ar_tail
= make_tail (outarch
);
2768 if (ar_head
== NULL
|| ar_tail
== NULL
)
2771 /* Now stick them all into the archive. */
2772 ar_head
->archive_next
= head
;
2773 ar_tail
->archive_next
= ar_head
;
2776 if (! bfd_set_archive_head (outarch
, head
))
2777 einfo ("%Xbfd_set_archive_head: %E\n");
2779 if (! bfd_close (outarch
))
2780 einfo ("%Xbfd_close %s: %E\n", impfilename
);
2782 while (head
!= NULL
)
2784 bfd
*n
= head
->archive_next
;
2790 static struct bfd_link_hash_entry
*found_sym
;
2793 pe_undef_alias_cdecl_match (struct bfd_link_hash_entry
*h
, void *inf
)
2797 const char *hs
= h
->root
.string
;
2799 sl
= strlen (string
);
2800 if (h
->type
== bfd_link_hash_undefined
2801 && ((*hs
== '@' && (!pe_details
->underscored
|| *string
== '_')
2802 && strncmp (hs
+ 1, string
+ (pe_details
->underscored
!= 0),
2803 sl
- (pe_details
->underscored
!= 0)) == 0)
2804 || strncmp (hs
, string
, sl
) == 0)
2805 && h
->root
.string
[sl
] == '@')
2813 static struct bfd_link_hash_entry
*
2814 pe_find_cdecl_alias_match (char *name
)
2817 bfd_link_hash_traverse (link_info
.hash
, pe_undef_alias_cdecl_match
,
2823 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
2825 lang_input_statement_type
*fake_file
;
2827 fake_file
= lang_add_input_file (name
,
2828 lang_input_file_is_fake_enum
,
2830 fake_file
->the_bfd
= abfd
;
2831 ldlang_add_file (fake_file
);
2833 if (!bfd_link_add_symbols (abfd
, linfo
))
2834 einfo ("%Xaddsym %s: %E\n", name
);
2838 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
2840 def_file_module
*module
;
2842 pe_dll_id_target (bfd_get_target (output_bfd
));
2847 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2851 dll_filename
= module
->name
;
2852 dll_symname
= xstrdup (module
->name
);
2853 for (i
= 0; dll_symname
[i
]; i
++)
2854 if (!ISALNUM (dll_symname
[i
]))
2855 dll_symname
[i
] = '_';
2859 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2860 if (pe_def_file
->imports
[i
].module
== module
)
2862 def_file_export exp
;
2863 struct bfd_link_hash_entry
*blhe
;
2864 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2865 /* See if we need this import. */
2866 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2867 char *name
= xmalloc (len
+ 2 + 6);
2868 bfd_boolean include_jmp_stub
= FALSE
;
2869 bfd_boolean is_cdecl
= FALSE
;
2870 if (!lead_at
&& strchr (pe_def_file
->imports
[i
].internal_name
, '@') == NULL
)
2874 sprintf (name
, "%s",
2875 pe_def_file
->imports
[i
].internal_name
);
2877 sprintf (name
, "%s%s",U (""),
2878 pe_def_file
->imports
[i
].internal_name
);
2880 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
2881 FALSE
, FALSE
, FALSE
);
2883 /* Include the jump stub for <sym> only if the <sym>
2885 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2888 sprintf (name
, "%s%s", "__imp_",
2889 pe_def_file
->imports
[i
].internal_name
);
2891 sprintf (name
, "%s%s%s", "__imp_", U (""),
2892 pe_def_file
->imports
[i
].internal_name
);
2894 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
2895 FALSE
, FALSE
, FALSE
);
2898 include_jmp_stub
= TRUE
;
2900 if (is_cdecl
&& !blhe
)
2902 sprintf (name
, "%s%s",U (""),
2903 pe_def_file
->imports
[i
].internal_name
);
2904 blhe
= pe_find_cdecl_alias_match (name
);
2905 include_jmp_stub
= TRUE
;
2910 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2916 bfd
*ar_head
= make_head (output_bfd
);
2917 add_bfd_to_link (ar_head
, ar_head
->filename
, linfo
);
2920 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2921 exp
.name
= pe_def_file
->imports
[i
].name
;
2922 exp
.its_name
= pe_def_file
->imports
[i
].its_name
;
2923 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2924 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2925 exp
.flag_private
= 0;
2926 exp
.flag_constant
= 0;
2927 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2928 exp
.flag_noname
= exp
.name
? 0 : 1;
2929 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
2930 add_bfd_to_link (one
, one
->filename
, linfo
);
2935 bfd
*ar_tail
= make_tail (output_bfd
);
2936 add_bfd_to_link (ar_tail
, ar_tail
->filename
, linfo
);
2943 /* We were handed a *.DLL file. Parse it and turn it into a set of
2944 IMPORTS directives in the def file. Return TRUE if the file was
2945 handled, FALSE if not. */
2948 pe_get16 (bfd
*abfd
, int where
)
2952 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2953 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2954 return b
[0] + (b
[1] << 8);
2958 pe_get32 (bfd
*abfd
, int where
)
2962 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2963 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2964 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2970 unsigned char *b
= ptr
;
2972 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2976 pe_implied_import_dll (const char *filename
)
2979 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2980 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
2981 bfd_vma exp_funcbase
;
2982 unsigned char *expdata
;
2984 bfd_vma name_rvas
, nexp
;
2985 const char *dllname
;
2986 /* Initialization with start > end guarantees that is_data
2987 will not be set by mistake, and avoids compiler warning. */
2988 bfd_vma data_start
= 1;
2989 bfd_vma data_end
= 0;
2990 bfd_vma rdata_start
= 1;
2991 bfd_vma rdata_end
= 0;
2992 bfd_vma bss_start
= 1;
2993 bfd_vma bss_end
= 0;
2995 /* No, I can't use bfd here. kernel32.dll puts its export table in
2996 the middle of the .rdata section. */
2997 dll
= bfd_openr (filename
, pe_details
->target_name
);
3000 einfo ("%Xopen %s: %E\n", filename
);
3004 /* PEI dlls seem to be bfd_objects. */
3005 if (!bfd_check_format (dll
, bfd_object
))
3007 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
3011 /* Get pe_header, optional header and numbers of directory entries. */
3012 pe_header_offset
= pe_get32 (dll
, 0x3c);
3013 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3014 #ifdef pe_use_x86_64
3015 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3017 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3020 /* No import or export directory entry. */
3021 if (num_entries
< 1)
3024 #ifdef pe_use_x86_64
3025 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3026 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3028 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3029 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3032 /* No export table - nothing to export. */
3033 if (export_size
== 0)
3036 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3037 secptr
= (pe_header_offset
+ 4 + 20 +
3038 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3041 /* Get the rva and size of the export section. */
3042 for (i
= 0; i
< nsections
; i
++)
3045 bfd_vma secptr1
= secptr
+ 40 * i
;
3046 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3047 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3048 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3050 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3051 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3053 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3055 expptr
= fptr
+ (export_rva
- vaddr
);
3056 if (export_rva
+ export_size
> vaddr
+ vsize
)
3057 export_size
= vsize
- (export_rva
- vaddr
);
3062 /* Scan sections and store the base and size of the
3063 data and bss segments in data/base_start/end. */
3064 for (i
= 0; i
< nsections
; i
++)
3066 bfd_vma secptr1
= secptr
+ 40 * i
;
3067 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3068 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3069 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3073 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3074 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3076 if (strcmp(sec_name
,".data") == 0)
3079 data_end
= vaddr
+ vsize
;
3081 if (pe_dll_extra_pe_debug
)
3082 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3083 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3084 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3086 else if (strcmp(sec_name
,".rdata") == 0)
3088 rdata_start
= vaddr
;
3089 rdata_end
= vaddr
+ vsize
;
3091 if (pe_dll_extra_pe_debug
)
3092 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3093 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3094 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3096 else if (strcmp (sec_name
,".bss") == 0)
3099 bss_end
= vaddr
+ vsize
;
3101 if (pe_dll_extra_pe_debug
)
3102 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3103 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3104 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3108 expdata
= xmalloc (export_size
);
3109 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3110 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3111 erva
= (char *) expdata
- export_rva
;
3113 if (pe_def_file
== 0)
3114 pe_def_file
= def_file_empty ();
3116 nexp
= pe_as32 (expdata
+ 24);
3117 name_rvas
= pe_as32 (expdata
+ 32);
3118 exp_funcbase
= pe_as32 (expdata
+ 28);
3120 /* Use internal dll name instead of filename
3121 to enable symbolic dll linking. */
3122 dllname
= erva
+ pe_as32 (expdata
+ 12);
3124 /* Check to see if the dll has already been added to
3125 the definition list and if so return without error.
3126 This avoids multiple symbol definitions. */
3127 if (def_get_module (pe_def_file
, dllname
))
3129 if (pe_dll_extra_pe_debug
)
3130 printf ("%s is already loaded\n", dllname
);
3134 /* Iterate through the list of symbols. */
3135 for (i
= 0; i
< nexp
; i
++)
3137 /* Pointer to the names vector. */
3138 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3139 def_file_import
*imp
;
3140 /* Pointer to the function address vector. */
3141 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3144 /* Skip unwanted symbols, which are
3145 exported in buggy auto-import releases. */
3146 if (! CONST_STRNEQ (erva
+ name_rva
, "__nm_"))
3148 /* is_data is true if the address is in the data, rdata or bss
3151 (func_rva
>= data_start
&& func_rva
< data_end
)
3152 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3153 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3155 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3156 dllname
, i
, 0, NULL
);
3157 /* Mark symbol type. */
3158 imp
->data
= is_data
;
3160 if (pe_dll_extra_pe_debug
)
3161 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3162 __FUNCTION__
, dllname
, erva
+ name_rva
,
3163 (unsigned long) func_rva
, is_data
? "(data)" : "");
3171 pe_output_file_set_long_section_names (bfd
*abfd
)
3173 if (pe_use_coff_long_section_names
< 0)
3175 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3176 einfo (_("%XError: can't use long section names on this arch\n"));
3179 /* These are the main functions, called from the emulation. The first
3180 is called after the bfds are read, so we can guess at how much space
3181 we need. The second is called after everything is placed, so we
3182 can put the right values in place. */
3185 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3187 pe_dll_id_target (bfd_get_target (abfd
));
3188 pe_output_file_set_long_section_names (abfd
);
3189 process_def_file_and_drectve (abfd
, info
);
3191 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
3194 generate_edata (abfd
, info
);
3195 build_filler_bfd (1);
3196 pe_output_file_set_long_section_names (filler_bfd
);
3200 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3202 pe_dll_id_target (bfd_get_target (abfd
));
3203 pe_output_file_set_long_section_names (abfd
);
3204 build_filler_bfd (0);
3205 pe_output_file_set_long_section_names (filler_bfd
);
3209 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3211 pe_dll_id_target (bfd_get_target (abfd
));
3212 pe_output_file_set_long_section_names (abfd
);
3213 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3215 generate_reloc (abfd
, info
);
3218 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3220 /* Resize the sections. */
3221 lang_reset_memory_regions ();
3222 lang_size_sections (NULL
, TRUE
);
3224 /* Redo special stuff. */
3225 ldemul_after_allocation ();
3227 /* Do the assignments again. */
3228 lang_do_assignments ();
3231 fill_edata (abfd
, info
);
3233 if (info
->shared
&& !info
->pie
)
3234 pe_data (abfd
)->dll
= 1;
3236 edata_s
->contents
= edata_d
;
3237 reloc_s
->contents
= reloc_d
;
3241 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3243 pe_dll_id_target (bfd_get_target (abfd
));
3244 pe_output_file_set_long_section_names (abfd
);
3245 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3247 generate_reloc (abfd
, info
);
3250 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3252 /* Resize the sections. */
3253 lang_reset_memory_regions ();
3254 lang_size_sections (NULL
, TRUE
);
3256 /* Redo special stuff. */
3257 ldemul_after_allocation ();
3259 /* Do the assignments again. */
3260 lang_do_assignments ();
3262 reloc_s
->contents
= reloc_d
;
3266 pe_bfd_is_dll (bfd
*abfd
)
3268 return (bfd_get_format (abfd
) == bfd_object
3270 && pe_data (abfd
)->dll
);