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, 2011 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 "filenames.h"
28 #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 thru 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;
164 /* Static variables and types. */
166 static bfd_vma image_base
;
167 static bfd
*filler_bfd
;
168 static struct bfd_section
*edata_s
, *reloc_s
;
169 static unsigned char *edata_d
, *reloc_d
;
170 static size_t edata_sz
, reloc_sz
;
171 static int runtime_pseudo_relocs_created
= 0;
172 static int runtime_pseudp_reloc_v2_init
= 0;
179 autofilter_entry_type
;
183 const char *target_name
;
184 const char *object_target
;
185 unsigned int imagebase_reloc
;
188 bfd_boolean underscored
;
189 const autofilter_entry_type
* autofilter_symbollist
;
193 static const autofilter_entry_type autofilter_symbollist_generic
[] =
195 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
196 /* Entry point symbols. */
197 { STRING_COMMA_LEN ("DllMain") },
198 { STRING_COMMA_LEN ("DllMainCRTStartup") },
199 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
200 /* Runtime pseudo-reloc. */
201 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
202 { STRING_COMMA_LEN ("do_pseudo_reloc") },
206 static const autofilter_entry_type autofilter_symbollist_i386
[] =
208 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
209 /* Entry point symbols, and entry hooks. */
210 { STRING_COMMA_LEN ("cygwin_crt0") },
212 { STRING_COMMA_LEN ("DllMain") },
213 { STRING_COMMA_LEN ("DllEntryPoint") },
214 { STRING_COMMA_LEN ("DllMainCRTStartup") },
215 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
216 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
217 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
219 { STRING_COMMA_LEN ("DllMain@12") },
220 { STRING_COMMA_LEN ("DllEntryPoint@0") },
221 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
222 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
223 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
224 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
225 { STRING_COMMA_LEN ("cygwin_attach_dll") },
227 { STRING_COMMA_LEN ("cygwin_premain0") },
228 { STRING_COMMA_LEN ("cygwin_premain1") },
229 { STRING_COMMA_LEN ("cygwin_premain2") },
230 { STRING_COMMA_LEN ("cygwin_premain3") },
231 /* Runtime pseudo-reloc. */
232 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
233 { STRING_COMMA_LEN ("do_pseudo_reloc") },
234 /* Global vars that should not be exported. */
235 { STRING_COMMA_LEN ("impure_ptr") },
236 { STRING_COMMA_LEN ("_impure_ptr") },
237 { STRING_COMMA_LEN ("_fmode") },
238 { STRING_COMMA_LEN ("environ") },
242 #define PE_ARCH_i386 1
244 #define PE_ARCH_mips 3
245 #define PE_ARCH_arm 4
246 #define PE_ARCH_arm_epoc 5
247 #define PE_ARCH_arm_wince 6
249 /* Don't make it constant as underscore mode gets possibly overriden
250 by target or -(no-)leading-underscore option. */
251 static pe_details_type pe_detail_list
[] =
270 autofilter_symbollist_i386
275 16 /* R_SH_IMAGEBASE */,
279 autofilter_symbollist_generic
288 autofilter_symbollist_generic
297 autofilter_symbollist_generic
300 "epoc-pei-arm-little",
301 "epoc-pe-arm-little",
306 autofilter_symbollist_generic
309 "pei-arm-wince-little",
310 "pe-arm-wince-little",
311 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
315 autofilter_symbollist_generic
317 { NULL
, NULL
, 0, 0, 0, FALSE
, NULL
}
320 static const pe_details_type
*pe_details
;
322 /* Do not specify library suffix explicitly, to allow for dllized versions. */
323 static const autofilter_entry_type autofilter_liblist
[] =
325 { STRING_COMMA_LEN ("libcegcc") },
326 { STRING_COMMA_LEN ("libcygwin") },
327 { STRING_COMMA_LEN ("libgcc") },
328 { STRING_COMMA_LEN ("libgcc_s") },
329 { STRING_COMMA_LEN ("libstdc++") },
330 { STRING_COMMA_LEN ("libmingw32") },
331 { STRING_COMMA_LEN ("libmingwex") },
332 { STRING_COMMA_LEN ("libg2c") },
333 { STRING_COMMA_LEN ("libsupc++") },
334 { STRING_COMMA_LEN ("libobjc") },
335 { STRING_COMMA_LEN ("libgcj") },
339 /* Regardless of the suffix issue mentioned above, we must ensure that
340 we do not falsely match on a leading substring, such as when libtool
341 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
342 This routine ensures that the leading part of the name matches and that
343 it is followed by only an optional version suffix and a file extension,
344 returning zero if so or -1 if not. */
345 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
347 if (filename_ncmp (libname
, afptr
->name
, afptr
->len
))
350 libname
+= afptr
->len
;
352 /* Be liberal in interpreting what counts as a version suffix; we
353 accept anything that has a dash to separate it from the name and
354 begins with a digit. */
355 if (libname
[0] == '-')
357 if (!ISDIGIT (*++libname
))
359 /* Ensure the filename has an extension. */
360 while (*++libname
!= '.')
364 else if (libname
[0] != '.')
370 static const autofilter_entry_type autofilter_objlist
[] =
372 { STRING_COMMA_LEN ("crt0.o") },
373 { STRING_COMMA_LEN ("crt1.o") },
374 { STRING_COMMA_LEN ("crt2.o") },
375 { STRING_COMMA_LEN ("dllcrt1.o") },
376 { STRING_COMMA_LEN ("dllcrt2.o") },
377 { STRING_COMMA_LEN ("gcrt0.o") },
378 { STRING_COMMA_LEN ("gcrt1.o") },
379 { STRING_COMMA_LEN ("gcrt2.o") },
380 { STRING_COMMA_LEN ("crtbegin.o") },
381 { STRING_COMMA_LEN ("crtend.o") },
385 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
387 /* _imp_ is treated specially, as it is always underscored. */
388 /* { STRING_COMMA_LEN ("_imp_") }, */
389 /* Don't export some c++ symbols. */
390 { STRING_COMMA_LEN ("__rtti_") },
391 { STRING_COMMA_LEN ("__builtin_") },
392 /* Don't re-export auto-imported symbols. */
393 { STRING_COMMA_LEN ("__nm_") },
394 /* Don't export symbols specifying internal DLL layout. */
395 { STRING_COMMA_LEN ("_head_") },
396 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
397 /* Don't export section labels or artificial symbols
399 { STRING_COMMA_LEN (".") },
403 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
405 { STRING_COMMA_LEN ("_iname") },
406 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
410 #define U(str) (pe_details->underscored ? "_" str : str)
413 pe_dll_id_target (const char *target
)
417 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
418 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
419 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
421 int u
= pe_leading_underscore
; /* Underscoring mode. -1 for use default. */
423 bfd_get_target_info (target
, NULL
, NULL
, &u
, NULL
);
426 pe_detail_list
[i
].underscored
= (u
!= 0 ? TRUE
: FALSE
);
427 pe_details
= pe_detail_list
+ i
;
428 pe_leading_underscore
= (u
!= 0 ? 1 : 0);
431 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
435 /* Helper functions for qsort. Relocs must be sorted so that we can write
436 them out by pages. */
447 reloc_sort (const void *va
, const void *vb
)
449 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
450 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
452 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
456 pe_export_sort (const void *va
, const void *vb
)
458 const def_file_export
*a
= va
;
459 const def_file_export
*b
= vb
;
467 return strcmp (an
, bn
);
470 /* Read and process the .DEF file. */
472 /* These correspond to the entries in pe_def_file->exports[]. I use
473 exported_symbol_sections[i] to tag whether or not the symbol was
474 defined, since we can't export symbols we don't have. */
476 static bfd_vma
*exported_symbol_offsets
;
477 static struct bfd_section
**exported_symbol_sections
;
478 static int export_table_size
;
479 static int count_exported
;
480 static int count_exported_byname
;
481 static int count_with_ordinals
;
482 static const char *dll_name
;
483 static int min_ordinal
, max_ordinal
;
484 static int *exported_symbols
;
486 typedef struct exclude_list_struct
489 struct exclude_list_struct
*next
;
494 static struct exclude_list_struct
*excludes
= 0;
497 pe_dll_add_excludes (const char *new_excludes
, const exclude_type type
)
500 char *exclude_string
;
502 local_copy
= xstrdup (new_excludes
);
504 exclude_string
= strtok (local_copy
, ",:");
505 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
507 struct exclude_list_struct
*new_exclude
;
509 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
510 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
511 strcpy (new_exclude
->string
, exclude_string
);
512 new_exclude
->type
= type
;
513 new_exclude
->next
= excludes
;
514 excludes
= new_exclude
;
521 is_import (const char* n
)
523 return (CONST_STRNEQ (n
, "__imp_"));
526 /* abfd is a bfd containing n (or NULL)
527 It can be used for contextual checks. */
530 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
533 struct exclude_list_struct
*ex
;
534 const autofilter_entry_type
*afptr
;
535 const char * libname
= 0;
536 if (abfd
&& abfd
->my_archive
)
537 libname
= lbasename (abfd
->my_archive
->filename
);
539 for (i
= 0; i
< d
->num_exports
; i
++)
540 if (strcmp (d
->exports
[i
].name
, n
) == 0)
543 if (pe_dll_do_default_excludes
)
548 if (pe_dll_extra_pe_debug
)
549 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
550 n
, abfd
, abfd
->my_archive
);
552 /* First of all, make context checks:
553 Don't export anything from standard libs. */
556 afptr
= autofilter_liblist
;
560 if (libnamencmp (libname
, afptr
) == 0 )
566 /* Next, exclude symbols from certain startup objects. */
568 if (abfd
&& (p
= lbasename (abfd
->filename
)))
570 afptr
= autofilter_objlist
;
573 if (strcmp (p
, afptr
->name
) == 0)
579 /* Don't try to blindly exclude all symbols
580 that begin with '__'; this was tried and
581 it is too restrictive. Instead we have
582 a target specific list to use: */
583 afptr
= pe_details
->autofilter_symbollist
;
587 if (strcmp (n
, afptr
->name
) == 0)
593 /* Next, exclude symbols starting with ... */
594 afptr
= autofilter_symbolprefixlist
;
597 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
603 /* Finally, exclude symbols ending with ... */
605 afptr
= autofilter_symbolsuffixlist
;
608 if ((len
>= afptr
->len
)
609 /* Add 1 to insure match with trailing '\0'. */
610 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
611 afptr
->len
+ 1) == 0)
618 for (ex
= excludes
; ex
; ex
= ex
->next
)
620 if (ex
->type
== EXCLUDELIBS
)
623 && ((filename_cmp (libname
, ex
->string
) == 0)
624 || (strcasecmp ("ALL", ex
->string
) == 0)))
627 else if (ex
->type
== EXCLUDEFORIMPLIB
)
629 if (filename_cmp (abfd
->filename
, ex
->string
) == 0)
632 else if (strcmp (n
, ex
->string
) == 0)
640 process_def_file_and_drectve (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
643 struct bfd_link_hash_entry
*blhe
;
645 struct bfd_section
*s
;
646 def_file_export
*e
= 0;
649 pe_def_file
= def_file_empty ();
651 /* First, run around to all the objects looking for the .drectve
652 sections, and push those into the def file too. */
653 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
655 s
= bfd_get_section_by_name (b
, ".drectve");
659 char *buf
= xmalloc (size
);
661 bfd_get_section_contents (b
, s
, buf
, 0, size
);
662 def_file_add_directive (pe_def_file
, buf
, size
);
667 /* Process aligned common symbol information from the
668 .drectve sections now; common symbol allocation is
669 done before final link, so it will be too late to
670 process them in process_embedded_commands() called
671 from _bfd_coff_link_input_bfd(). */
672 if (pe_def_file
->aligncomms
)
674 def_file_aligncomm
*ac
= pe_def_file
->aligncomms
;
677 struct coff_link_hash_entry
*sym_hash
;
678 sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
679 ac
->symbol_name
, FALSE
, FALSE
, FALSE
);
680 if (sym_hash
&& sym_hash
->root
.type
== bfd_link_hash_common
681 && sym_hash
->root
.u
.c
.p
->alignment_power
< (unsigned) ac
->alignment
)
683 sym_hash
->root
.u
.c
.p
->alignment_power
= (unsigned) ac
->alignment
;
689 /* If we are building an executable and there is nothing
690 to export, we do not build an export table at all. */
691 if (info
->executable
&& pe_def_file
->num_exports
== 0
692 && (!pe_dll_export_everything
|| pe_dll_exclude_all_symbols
))
695 /* Now, maybe export everything else the default way. */
696 if ((pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
697 && !pe_dll_exclude_all_symbols
)
699 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
704 if (!bfd_generic_link_read_symbols (b
))
706 einfo (_("%B%F: could not read symbols: %E\n"), b
);
710 symbols
= bfd_get_outsymbols (b
);
711 nsyms
= bfd_get_symcount (b
);
713 for (j
= 0; j
< nsyms
; j
++)
715 /* We should export symbols which are either global or not
716 anything at all. (.bss data is the latter)
717 We should not export undefined symbols. */
718 bfd_boolean would_export
= symbols
[j
]->section
!= &bfd_und_section
719 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
720 || (symbols
[j
]->flags
== 0));
721 if (link_info
.version_info
&& would_export
)
723 = !bfd_hide_sym_by_version (link_info
.version_info
,
727 const char *sn
= symbols
[j
]->name
;
729 /* We should not re-export imported stuff. */
735 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
736 sprintf (name
, "%s%s", "__imp_", sn
);
738 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
739 FALSE
, FALSE
, FALSE
);
742 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
746 if (pe_details
->underscored
&& *sn
== '_')
749 if (auto_export (b
, pe_def_file
, sn
))
753 p
= def_file_add_export (pe_def_file
, sn
, 0, -1,
755 /* Fill data flag properly, from dlltool.c. */
757 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
765 #define NE pe_def_file->num_exports
767 /* Don't create an empty export table. */
771 /* Canonicalize the export list. */
774 for (i
= 0; i
< NE
; i
++)
776 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
778 /* This will preserve internal_name, which may have been
779 pointing to the same memory as name, or might not
781 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
782 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
783 char *tmp_at
= strchr (tmp
, '@');
788 einfo (_("%XCannot export %s: invalid export name\n"),
789 pe_def_file
->exports
[i
].name
);
790 pe_def_file
->exports
[i
].name
= tmp
;
795 if (pe_dll_stdcall_aliases
)
797 for (i
= 0; i
< NE
; i
++)
799 if (is_import (pe_def_file
->exports
[i
].name
))
802 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
805 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
806 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
808 *(strchr (tmp
, '@')) = 0;
809 if (auto_export (NULL
, pe_def_file
, tmp
))
810 def_file_add_export (pe_def_file
, tmp
,
811 pe_def_file
->exports
[i
].internal_name
,
819 /* Convenience, but watch out for it changing. */
820 e
= pe_def_file
->exports
;
822 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
823 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
825 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
829 count_exported_byname
= 0;
830 count_with_ordinals
= 0;
832 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
834 for (i
= 0, j
= 0; i
< NE
; i
++)
836 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
838 /* This is a duplicate. */
839 if (e
[j
- 1].ordinal
!= -1
840 && e
[i
].ordinal
!= -1
841 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
843 if (pe_dll_warn_dup_exports
)
844 /* xgettext:c-format */
845 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
846 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
850 if (pe_dll_warn_dup_exports
)
851 /* xgettext:c-format */
852 einfo (_("Warning, duplicate EXPORT: %s\n"),
856 if (e
[i
].ordinal
!= -1)
857 e
[j
- 1].ordinal
= e
[i
].ordinal
;
858 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
859 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
860 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
861 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
870 pe_def_file
->num_exports
= j
; /* == NE */
872 for (i
= 0; i
< NE
; i
++)
875 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
876 if (pe_details
->underscored
877 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
880 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
883 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
885 blhe
= bfd_link_hash_lookup (info
->hash
,
890 && (blhe
->type
== bfd_link_hash_defined
891 || (blhe
->type
== bfd_link_hash_common
)))
894 if (!pe_def_file
->exports
[i
].flag_noname
)
895 count_exported_byname
++;
897 /* Only fill in the sections. The actual offsets are computed
898 in fill_exported_offsets() after common symbols are laid
900 if (blhe
->type
== bfd_link_hash_defined
)
901 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
903 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
905 if (pe_def_file
->exports
[i
].ordinal
!= -1)
907 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
908 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
909 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
910 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
911 count_with_ordinals
++;
914 /* Check for forward exports. These are indicated in DEF files by an
915 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
916 but we must take care not to be fooled when the user wants to export
917 a symbol that actually really has a dot in it, so we only check
918 for them here, after real defined symbols have already been matched. */
919 else if (strchr (pe_def_file
->exports
[i
].internal_name
, '.'))
922 if (!pe_def_file
->exports
[i
].flag_noname
)
923 count_exported_byname
++;
925 pe_def_file
->exports
[i
].flag_forward
= 1;
927 if (pe_def_file
->exports
[i
].ordinal
!= -1)
929 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
930 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
931 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
932 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
933 count_with_ordinals
++;
936 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
938 /* xgettext:c-format */
939 einfo (_("%XCannot export %s: symbol not defined\n"),
940 pe_def_file
->exports
[i
].internal_name
);
944 /* xgettext:c-format */
945 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
946 pe_def_file
->exports
[i
].internal_name
,
947 blhe
->type
, bfd_link_hash_defined
);
951 /* xgettext:c-format */
952 einfo (_("%XCannot export %s: symbol not found\n"),
953 pe_def_file
->exports
[i
].internal_name
);
959 /* Build the bfd that will contain .edata and .reloc sections. */
962 build_filler_bfd (int include_edata
)
964 lang_input_statement_type
*filler_file
;
965 filler_file
= lang_add_input_file ("dll stuff",
966 lang_input_file_is_fake_enum
,
968 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
969 link_info
.output_bfd
);
970 if (filler_bfd
== NULL
971 || !bfd_set_arch_mach (filler_bfd
,
972 bfd_get_arch (link_info
.output_bfd
),
973 bfd_get_mach (link_info
.output_bfd
)))
975 einfo ("%X%P: can not create BFD: %E\n");
981 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
983 || !bfd_set_section_flags (filler_bfd
, edata_s
,
990 einfo ("%X%P: can not create .edata section: %E\n");
993 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
996 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
998 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
1005 einfo ("%X%P: can not create .reloc section: %E\n");
1009 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
1011 ldlang_add_file (filler_file
);
1014 /* Gather all the exported symbols and build the .edata section. */
1017 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1019 int i
, next_ordinal
;
1020 int name_table_size
= 0;
1023 /* First, we need to know how many exported symbols there are,
1024 and what the range of ordinals is. */
1025 if (pe_def_file
->name
)
1026 dll_name
= pe_def_file
->name
;
1029 dll_name
= abfd
->filename
;
1031 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
1032 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
1033 dll_name
= dlnp
+ 1;
1036 if (count_with_ordinals
&& max_ordinal
> count_exported
)
1038 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
1039 min_ordinal
= max_ordinal
- count_exported
+ 1;
1044 max_ordinal
= count_exported
;
1047 export_table_size
= max_ordinal
- min_ordinal
+ 1;
1048 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
1049 for (i
= 0; i
< export_table_size
; i
++)
1050 exported_symbols
[i
] = -1;
1052 /* Now we need to assign ordinals to those that don't have them. */
1053 for (i
= 0; i
< NE
; i
++)
1055 if (exported_symbol_sections
[i
] ||
1056 pe_def_file
->exports
[i
].flag_forward
)
1058 if (pe_def_file
->exports
[i
].ordinal
!= -1)
1060 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
1061 int pi
= exported_symbols
[ei
];
1065 /* xgettext:c-format */
1066 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1067 pe_def_file
->exports
[i
].ordinal
,
1068 pe_def_file
->exports
[i
].name
,
1069 pe_def_file
->exports
[pi
].name
);
1071 exported_symbols
[ei
] = i
;
1073 if (pe_def_file
->exports
[i
].its_name
)
1074 name_table_size
+= strlen (pe_def_file
->exports
[i
].its_name
) + 1;
1076 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1079 /* Reserve space for the forward name. */
1080 if (pe_def_file
->exports
[i
].flag_forward
)
1082 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1086 next_ordinal
= min_ordinal
;
1087 for (i
= 0; i
< NE
; i
++)
1088 if ((exported_symbol_sections
[i
] ||
1089 pe_def_file
->exports
[i
].flag_forward
) &&
1090 pe_def_file
->exports
[i
].ordinal
== -1)
1092 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1095 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1096 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1099 /* OK, now we can allocate some memory. */
1100 edata_sz
= (40 /* directory */
1101 + 4 * export_table_size
/* addresses */
1102 + 4 * count_exported_byname
/* name ptrs */
1103 + 2 * count_exported_byname
/* ordinals */
1104 + name_table_size
+ strlen (dll_name
) + 1);
1107 /* Fill the exported symbol offsets. The preliminary work has already
1108 been done in process_def_file_and_drectve(). */
1111 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1114 struct bfd_link_hash_entry
*blhe
;
1116 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1120 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1121 if (pe_details
->underscored
1122 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1125 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1128 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1130 blhe
= bfd_link_hash_lookup (info
->hash
,
1132 FALSE
, FALSE
, TRUE
);
1134 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1135 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1142 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1145 unsigned char *edirectory
;
1146 unsigned char *eaddresses
;
1147 unsigned char *enameptrs
;
1148 unsigned char *eordinals
;
1154 edata_d
= xmalloc (edata_sz
);
1156 /* Note use of array pointer math here. */
1157 edirectory
= edata_d
;
1158 eaddresses
= edirectory
+ 40;
1159 enameptrs
= eaddresses
+ 4 * export_table_size
;
1160 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1161 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1163 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1164 + edata_s->output_section->vma - image_base)
1166 memset (edata_d
, 0, edata_sz
);
1167 bfd_put_32 (abfd
, now
, edata_d
+ 4);
1168 if (pe_def_file
->version_major
!= -1)
1170 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1171 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1174 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1175 strcpy (enamestr
, dll_name
);
1176 enamestr
+= strlen (enamestr
) + 1;
1177 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1178 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1179 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1180 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1181 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1182 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1184 fill_exported_offsets (abfd
, info
);
1186 /* Ok, now for the filling in part.
1187 Scan alphabetically - ie the ordering in the exports[] table,
1188 rather than by ordinal - the ordering in the exported_symbol[]
1189 table. See dlltool.c and:
1190 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1191 for more information. */
1193 for (s
= 0; s
< NE
; s
++)
1195 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1196 if (pe_def_file
->exports
[s
].ordinal
!= -1 &&
1197 (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1199 int ord
= pe_def_file
->exports
[s
].ordinal
;
1201 if (pe_def_file
->exports
[s
].flag_forward
)
1203 bfd_put_32 (abfd
, ERVA (enamestr
),
1204 eaddresses
+ 4 * (ord
- min_ordinal
));
1206 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1207 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1211 bfd_vma srva
= (exported_symbol_offsets
[s
]
1212 + ssec
->output_section
->vma
1213 + ssec
->output_offset
);
1215 bfd_put_32 (abfd
, srva
- image_base
,
1216 eaddresses
+ 4 * (ord
- min_ordinal
));
1219 if (!pe_def_file
->exports
[s
].flag_noname
)
1221 char *ename
= pe_def_file
->exports
[s
].name
;
1222 if (pe_def_file
->exports
[s
].its_name
)
1223 ename
= pe_def_file
->exports
[s
].its_name
;
1225 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1227 strcpy (enamestr
, ename
);
1228 enamestr
+= strlen (enamestr
) + 1;
1229 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1231 pe_def_file
->exports
[s
].hint
= hint
++;
1238 static struct bfd_section
*current_sec
;
1241 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1243 int (*cb
) (arelent
*, asection
*))
1248 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1252 if (!bfd_generic_link_read_symbols (b
))
1254 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1258 symbols
= bfd_get_outsymbols (b
);
1260 for (s
= b
->sections
; s
; s
= s
->next
)
1263 int relsize
, nrelocs
, i
;
1264 int flags
= bfd_get_section_flags (b
, s
);
1266 /* Skip discarded linkonce sections. */
1267 if (flags
& SEC_LINK_ONCE
1268 && s
->output_section
== bfd_abs_section_ptr
)
1273 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1274 relocs
= xmalloc (relsize
);
1275 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1277 for (i
= 0; i
< nrelocs
; i
++)
1279 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1281 if (!strcmp (name
, sym
->name
))
1287 /* Warning: the allocated symbols are remembered in BFD and reused
1288 later, so don't free them! */
1289 /* free (symbols); */
1294 /* Gather all the relocations and build the .reloc section. */
1297 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1300 /* For .reloc stuff. */
1301 reloc_data_type
*reloc_data
;
1302 int total_relocs
= 0;
1304 bfd_vma sec_page
= (bfd_vma
) -1;
1305 bfd_vma page_ptr
, page_count
;
1308 struct bfd_section
*s
;
1311 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1312 for (s
= b
->sections
; s
; s
= s
->next
)
1313 total_relocs
+= s
->reloc_count
;
1315 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1319 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1322 int relsize
, nrelocs
;
1324 for (s
= b
->sections
; s
; s
= s
->next
)
1326 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1329 /* If it's not loaded, we don't need to relocate it this way. */
1330 if (!(s
->output_section
->flags
& SEC_LOAD
))
1333 /* I don't know why there would be a reloc for these, but I've
1334 seen it happen - DJ */
1335 if (s
->output_section
== &bfd_abs_section
)
1338 if (s
->output_section
->vma
== 0)
1340 /* Huh? Shouldn't happen, but punt if it does. */
1341 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1342 s
->output_section
->name
, s
->output_section
->index
,
1343 s
->output_section
->flags
);
1347 if (!bfd_generic_link_read_symbols (b
))
1349 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1353 symbols
= bfd_get_outsymbols (b
);
1354 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1355 relocs
= xmalloc (relsize
);
1356 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1358 for (i
= 0; i
< nrelocs
; i
++)
1360 if (pe_dll_extra_pe_debug
)
1362 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1363 printf ("rel: %s\n", sym
->name
);
1365 if (!relocs
[i
]->howto
->pc_relative
1366 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1368 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1370 /* Don't create relocs for undefined weak symbols. */
1371 if (sym
->flags
== BSF_WEAK
)
1373 struct bfd_link_hash_entry
*blhe
1374 = bfd_wrapped_link_hash_lookup (abfd
, info
, sym
->name
,
1375 FALSE
, FALSE
, FALSE
);
1376 if (blhe
&& blhe
->type
== bfd_link_hash_undefweak
)
1378 /* Check aux sym and see if it is defined or not. */
1379 struct coff_link_hash_entry
*h
, *h2
;
1380 h
= (struct coff_link_hash_entry
*)blhe
;
1381 if (h
->symbol_class
!= C_NT_WEAK
|| h
->numaux
!= 1)
1383 h2
= h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
1384 [h
->aux
->x_sym
.x_tagndx
.l
];
1385 /* We don't want a base reloc if the aux sym is not
1386 found, undefined, or if it is the constant ABS
1387 zero default value. (We broaden that slightly by
1388 not testing the value, just the section; there's
1389 no reason we'd want a reference to any absolute
1390 address to get relocated during rebasing). */
1391 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
1392 || h2
->root
.u
.def
.section
== &bfd_abs_section
)
1395 else if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1399 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1401 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1403 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1404 relocs
[i
]->howto
->rightshift
)
1406 #ifdef pe_use_x86_64
1407 case BITS_AND_SHIFT (64, 0):
1408 reloc_data
[total_relocs
].type
= 10;
1412 case BITS_AND_SHIFT (32, 0):
1413 reloc_data
[total_relocs
].type
= 3;
1416 case BITS_AND_SHIFT (16, 0):
1417 reloc_data
[total_relocs
].type
= 2;
1420 case BITS_AND_SHIFT (16, 16):
1421 reloc_data
[total_relocs
].type
= 4;
1422 /* FIXME: we can't know the symbol's right value
1423 yet, but we probably can safely assume that
1424 CE will relocate us in 64k blocks, so leaving
1426 reloc_data
[total_relocs
].extra
= 0;
1429 case BITS_AND_SHIFT (26, 2):
1430 reloc_data
[total_relocs
].type
= 5;
1433 case BITS_AND_SHIFT (24, 2):
1434 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1435 Those ARM_xxx definitions should go in proper
1437 if (relocs
[i
]->howto
->type
== 0
1438 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1439 || relocs
[i
]->howto
->type
== 5)
1440 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1441 that has already been fully processed during a
1442 previous link stage, so ignore it here. */
1446 /* xgettext:c-format */
1447 einfo (_("%XError: %d-bit reloc in dll\n"),
1448 relocs
[i
]->howto
->bitsize
);
1454 /* Warning: the allocated symbols are remembered in BFD and
1455 reused later, so don't free them! */
1459 /* At this point, we have total_relocs relocation addresses in
1460 reloc_addresses, which are all suitable for the .reloc section.
1461 We must now create the new sections. */
1462 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1464 for (i
= 0; i
< total_relocs
; i
++)
1466 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1468 if (this_page
!= sec_page
)
1470 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1472 sec_page
= this_page
;
1477 if (reloc_data
[i
].type
== 4)
1481 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1482 reloc_d
= xmalloc (reloc_sz
);
1483 sec_page
= (bfd_vma
) -1;
1485 page_ptr
= (bfd_vma
) -1;
1488 for (i
= 0; i
< total_relocs
; i
++)
1490 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1491 bfd_vma this_page
= (rva
& ~0xfff);
1493 if (this_page
!= sec_page
)
1495 while (reloc_sz
& 3)
1496 reloc_d
[reloc_sz
++] = 0;
1498 if (page_ptr
!= (bfd_vma
) -1)
1499 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1501 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1502 page_ptr
= reloc_sz
;
1504 sec_page
= this_page
;
1508 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1509 reloc_d
+ reloc_sz
);
1512 if (reloc_data
[i
].type
== 4)
1514 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1521 while (reloc_sz
& 3)
1522 reloc_d
[reloc_sz
++] = 0;
1524 if (page_ptr
!= (bfd_vma
) -1)
1525 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1527 while (reloc_sz
< reloc_s
->size
)
1528 reloc_d
[reloc_sz
++] = 0;
1531 /* Given the exiting def_file structure, print out a .DEF file that
1532 corresponds to it. */
1535 quoteput (char *s
, FILE *f
, int needs_quotes
)
1539 for (cp
= s
; *cp
; cp
++)
1554 if (*s
== '"' || *s
== '\\')
1568 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1571 FILE *out
= fopen (pe_out_def_filename
, "w");
1574 /* xgettext:c-format */
1575 einfo (_("%s: Can't open output def file %s\n"),
1576 program_name
, pe_out_def_filename
);
1580 if (pe_def_file
->name
)
1582 if (pe_def_file
->is_dll
)
1583 fprintf (out
, "LIBRARY ");
1585 fprintf (out
, "NAME ");
1587 quoteput (pe_def_file
->name
, out
, 1);
1589 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1591 fprintf (out
, " BASE=0x");
1592 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1594 fprintf (out
, "\n");
1597 if (pe_def_file
->description
)
1599 fprintf (out
, "DESCRIPTION ");
1600 quoteput (pe_def_file
->description
, out
, 1);
1601 fprintf (out
, "\n");
1604 if (pe_def_file
->version_minor
!= -1)
1605 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1606 pe_def_file
->version_minor
);
1607 else if (pe_def_file
->version_major
!= -1)
1608 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1610 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1611 fprintf (out
, "\n");
1613 if (pe_def_file
->stack_commit
!= -1)
1614 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1615 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1616 else if (pe_def_file
->stack_reserve
!= -1)
1617 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1619 if (pe_def_file
->heap_commit
!= -1)
1620 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1621 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1622 else if (pe_def_file
->heap_reserve
!= -1)
1623 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1625 if (pe_def_file
->num_section_defs
> 0)
1627 fprintf (out
, "\nSECTIONS\n\n");
1629 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1632 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1634 if (pe_def_file
->section_defs
[i
].class)
1636 fprintf (out
, " CLASS ");
1637 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1640 if (pe_def_file
->section_defs
[i
].flag_read
)
1641 fprintf (out
, " READ");
1643 if (pe_def_file
->section_defs
[i
].flag_write
)
1644 fprintf (out
, " WRITE");
1646 if (pe_def_file
->section_defs
[i
].flag_execute
)
1647 fprintf (out
, " EXECUTE");
1649 if (pe_def_file
->section_defs
[i
].flag_shared
)
1650 fprintf (out
, " SHARED");
1652 fprintf (out
, "\n");
1656 if (pe_def_file
->num_exports
> 0)
1658 fprintf (out
, "EXPORTS\n");
1660 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1662 def_file_export
*e
= pe_def_file
->exports
+ i
;
1664 quoteput (e
->name
, out
, 0);
1666 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1668 fprintf (out
, " = ");
1669 quoteput (e
->internal_name
, out
, 0);
1672 if (e
->ordinal
!= -1)
1673 fprintf (out
, " @%d", e
->ordinal
);
1675 if (e
->flag_private
)
1676 fprintf (out
, " PRIVATE");
1678 if (e
->flag_constant
)
1679 fprintf (out
, " CONSTANT");
1682 fprintf (out
, " NONAME");
1685 fprintf (out
, " DATA");
1687 fprintf (out
, "\n");
1691 if (pe_def_file
->num_imports
> 0)
1693 fprintf (out
, "\nIMPORTS\n\n");
1695 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1697 def_file_import
*im
= pe_def_file
->imports
+ i
;
1700 if (im
->internal_name
1701 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1703 quoteput (im
->internal_name
, out
, 0);
1704 fprintf (out
, " = ");
1707 quoteput (im
->module
->name
, out
, 0);
1711 quoteput (im
->name
, out
, 0);
1713 fprintf (out
, "%d", im
->ordinal
);
1717 fprintf (out
, " == ");
1718 quoteput (im
->its_name
, out
, 0);
1721 fprintf (out
, "\n");
1726 fprintf (out
, _("; no contents available\n"));
1728 if (fclose (out
) == EOF
)
1729 /* xgettext:c-format */
1730 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1733 /* Generate the import library. */
1735 static asymbol
**symtab
;
1738 static int tmp_seq2
;
1739 static const char *dll_filename
;
1740 static char *dll_symname
;
1742 #define UNDSEC (asection *) &bfd_und_section
1745 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1750 sec
= bfd_make_section_old_way (abfd
, name
);
1751 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1752 bfd_set_section_alignment (abfd
, sec
, align
);
1753 /* Remember to undo this before trying to link internally! */
1754 sec
->output_section
= sec
;
1756 sym
= bfd_make_empty_symbol (abfd
);
1757 symtab
[symptr
++] = sym
;
1758 sym
->name
= sec
->name
;
1760 sym
->flags
= BSF_LOCAL
;
1767 quick_symbol (bfd
*abfd
,
1776 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1781 sym
= bfd_make_empty_symbol (abfd
);
1786 symtab
[symptr
++] = sym
;
1789 static arelent
*reltab
= 0;
1790 static int relcount
= 0, relsize
= 0;
1793 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1795 if (relcount
>= relsize
- 1)
1799 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1801 reltab
= xmalloc (relsize
* sizeof (arelent
));
1803 reltab
[relcount
].address
= address
;
1804 reltab
[relcount
].addend
= 0;
1805 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1806 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1811 save_relocs (asection
*sec
)
1815 sec
->relocation
= reltab
;
1816 sec
->reloc_count
= relcount
;
1817 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1818 for (i
= 0; i
< relcount
; i
++)
1819 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1820 sec
->orelocation
[relcount
] = 0;
1821 sec
->flags
|= SEC_RELOC
;
1823 relcount
= relsize
= 0;
1826 /* .section .idata$2
1827 .global __head_my_dll
1844 make_head (bfd
*parent
)
1846 asection
*id2
, *id5
, *id4
;
1847 unsigned char *d2
, *d5
, *d4
;
1851 oname
= xmalloc (20);
1852 sprintf (oname
, "d%06d.o", tmp_seq
);
1855 abfd
= bfd_create (oname
, parent
);
1856 bfd_find_target (pe_details
->object_target
, abfd
);
1857 bfd_make_writable (abfd
);
1859 bfd_set_format (abfd
, bfd_object
);
1860 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1863 symtab
= xmalloc (6 * sizeof (asymbol
*));
1864 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1865 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1866 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1867 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1868 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1870 /* OK, pay attention here. I got confused myself looking back at
1871 it. We create a four-byte section to mark the beginning of the
1872 list, and we include an offset of 4 in the section, so that the
1873 pointer to the list points to the *end* of this section, which is
1874 the start of the list of sections from other objects. */
1876 bfd_set_section_size (abfd
, id2
, 20);
1880 if (pe_use_nul_prefixed_import_tables
)
1881 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
1882 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1883 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1884 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1887 if (pe_use_nul_prefixed_import_tables
)
1888 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1890 bfd_set_section_size (abfd
, id5
, 0);
1891 d5
= xmalloc (PE_IDATA5_SIZE
);
1893 memset (d5
, 0, PE_IDATA5_SIZE
);
1894 if (pe_use_nul_prefixed_import_tables
)
1895 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1897 bfd_set_section_size (abfd
, id4
, 0);
1898 d4
= xmalloc (PE_IDATA4_SIZE
);
1900 memset (d4
, 0, PE_IDATA4_SIZE
);
1902 bfd_set_symtab (abfd
, symtab
, symptr
);
1904 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1905 if (pe_use_nul_prefixed_import_tables
)
1907 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1908 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1912 bfd_set_section_contents (abfd
, id5
, d5
, 0, 0);
1913 bfd_set_section_contents (abfd
, id4
, d4
, 0, 0);
1916 bfd_make_readable (abfd
);
1920 /* .section .idata$4
1927 .global __my_dll_iname
1932 make_tail (bfd
*parent
)
1934 asection
*id4
, *id5
, *id7
;
1935 unsigned char *d4
, *d5
, *d7
;
1940 oname
= xmalloc (20);
1941 sprintf (oname
, "d%06d.o", tmp_seq
);
1944 abfd
= bfd_create (oname
, parent
);
1945 bfd_find_target (pe_details
->object_target
, abfd
);
1946 bfd_make_writable (abfd
);
1948 bfd_set_format (abfd
, bfd_object
);
1949 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1952 symtab
= xmalloc (5 * sizeof (asymbol
*));
1953 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1954 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1955 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1956 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1958 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1959 d4
= xmalloc (PE_IDATA4_SIZE
);
1961 memset (d4
, 0, PE_IDATA4_SIZE
);
1963 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1964 d5
= xmalloc (PE_IDATA5_SIZE
);
1966 memset (d5
, 0, PE_IDATA5_SIZE
);
1968 len
= strlen (dll_filename
) + 1;
1971 bfd_set_section_size (abfd
, id7
, len
);
1974 strcpy ((char *) d7
, dll_filename
);
1975 /* If len was odd, the above
1976 strcpy leaves behind an undefined byte. That is harmless,
1977 but we set it to 0 just so the binary dumps are pretty. */
1980 bfd_set_symtab (abfd
, symtab
, symptr
);
1982 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1983 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1984 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1986 bfd_make_readable (abfd
);
1992 .global ___imp_function
1993 .global __imp__function
1995 jmp *__imp__function:
2009 .asciz "function" xlate? (add underscore, kill at) */
2011 static const unsigned char jmp_ix86_bytes
[] =
2013 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2021 .dw __imp_function */
2023 static const unsigned char jmp_sh_bytes
[] =
2025 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2029 lui $t0,<high:__imp_function>
2030 lw $t0,<low:__imp_function>
2034 static const unsigned char jmp_mips_bytes
[] =
2036 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2037 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2040 static const unsigned char jmp_arm_bytes
[] =
2042 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2043 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2049 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
2051 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
2052 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
2056 const unsigned char *jmp_bytes
= NULL
;
2057 int jmp_byte_count
= 0;
2059 /* Include the jump stub section only if it is needed. A jump
2060 stub is needed if the symbol being imported <sym> is a function
2061 symbol and there is at least one undefined reference to that
2062 symbol. In other words, if all the import references to <sym> are
2063 explicitly through _declspec(dllimport) then the jump stub is not
2065 if (include_jmp_stub
)
2067 switch (pe_details
->pe_arch
)
2070 jmp_bytes
= jmp_ix86_bytes
;
2071 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
2074 jmp_bytes
= jmp_sh_bytes
;
2075 jmp_byte_count
= sizeof (jmp_sh_bytes
);
2078 jmp_bytes
= jmp_mips_bytes
;
2079 jmp_byte_count
= sizeof (jmp_mips_bytes
);
2082 case PE_ARCH_arm_epoc
:
2083 case PE_ARCH_arm_wince
:
2084 jmp_bytes
= jmp_arm_bytes
;
2085 jmp_byte_count
= sizeof (jmp_arm_bytes
);
2092 oname
= xmalloc (20);
2093 sprintf (oname
, "d%06d.o", tmp_seq
);
2096 abfd
= bfd_create (oname
, parent
);
2097 bfd_find_target (pe_details
->object_target
, abfd
);
2098 bfd_make_writable (abfd
);
2100 bfd_set_format (abfd
, bfd_object
);
2101 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2104 symtab
= xmalloc (12 * sizeof (asymbol
*));
2106 tx
= quick_section (abfd
, ".text", SEC_CODE
| SEC_HAS_CONTENTS
| SEC_READONLY
, 2);
2107 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2108 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2109 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2110 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2112 if (*exp
->internal_name
== '@')
2114 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2116 if (include_jmp_stub
)
2117 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2118 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2120 /* Fastcall applies only to functions,
2121 so no need for auto-import symbol. */
2125 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2127 if (include_jmp_stub
)
2128 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2130 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2132 /* Symbol to reference ord/name of imported
2133 data symbol, used to implement auto-import. */
2135 quick_symbol (abfd
, "__nm_", U (""), exp
->internal_name
, id6
,
2138 if (pe_dll_compat_implib
)
2139 quick_symbol (abfd
, "___imp_", exp
->internal_name
, "", id5
,
2142 if (include_jmp_stub
)
2144 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
2145 td
= xmalloc (jmp_byte_count
);
2147 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2149 switch (pe_details
->pe_arch
)
2152 #ifdef pe_use_x86_64
2153 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2155 /* Mark this object as SAFESEH compatible. */
2156 quick_symbol (abfd
, "", "@feat.00", "", bfd_abs_section_ptr
,
2158 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2162 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2165 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2166 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2167 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2170 case PE_ARCH_arm_epoc
:
2171 case PE_ARCH_arm_wince
:
2172 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2180 bfd_set_section_size (abfd
, tx
, 0);
2182 bfd_set_section_size (abfd
, id7
, 4);
2186 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2189 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2190 d5
= xmalloc (PE_IDATA5_SIZE
);
2192 memset (d5
, 0, PE_IDATA5_SIZE
);
2194 if (exp
->flag_noname
)
2196 d5
[0] = exp
->ordinal
;
2197 d5
[1] = exp
->ordinal
>> 8;
2198 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2202 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2206 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2207 d4
= xmalloc (PE_IDATA4_SIZE
);
2209 memset (d4
, 0, PE_IDATA4_SIZE
);
2211 if (exp
->flag_noname
)
2213 d4
[0] = exp
->ordinal
;
2214 d4
[1] = exp
->ordinal
>> 8;
2215 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2219 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2223 if (exp
->flag_noname
)
2226 bfd_set_section_size (abfd
, id6
, 0);
2230 /* { short, asciz } */
2232 len
= 2 + strlen (exp
->its_name
) + 1;
2234 len
= 2 + strlen (exp
->name
) + 1;
2237 bfd_set_section_size (abfd
, id6
, len
);
2240 memset (d6
, 0, len
);
2241 d6
[0] = exp
->hint
& 0xff;
2242 d6
[1] = exp
->hint
>> 8;
2244 strcpy ((char*) d6
+ 2, exp
->its_name
);
2246 strcpy ((char *) d6
+ 2, exp
->name
);
2249 bfd_set_symtab (abfd
, symtab
, symptr
);
2251 if (include_jmp_stub
)
2252 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2253 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2254 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2255 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2256 if (!exp
->flag_noname
)
2257 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2259 bfd_make_readable (abfd
);
2264 make_singleton_name_imp (const char *import
, bfd
*parent
)
2266 /* Name thunks go to idata$4. */
2272 oname
= xmalloc (20);
2273 sprintf (oname
, "nmimp%06d.o", tmp_seq2
);
2276 abfd
= bfd_create (oname
, parent
);
2277 bfd_find_target (pe_details
->object_target
, abfd
);
2278 bfd_make_writable (abfd
);
2280 bfd_set_format (abfd
, bfd_object
);
2281 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2284 symtab
= xmalloc (3 * sizeof (asymbol
*));
2285 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2286 quick_symbol (abfd
, "__imp_", import
, "", id5
, BSF_GLOBAL
, 0);
2288 /* We need space for the real thunk and for the null terminator. */
2289 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
* 2);
2290 d5
= xmalloc (PE_IDATA5_SIZE
* 2);
2292 memset (d5
, 0, PE_IDATA5_SIZE
* 2);
2293 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2296 bfd_set_symtab (abfd
, symtab
, symptr
);
2298 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA4_SIZE
* 2);
2300 bfd_make_readable (abfd
);
2305 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2307 /* Name thunks go to idata$4. */
2313 oname
= xmalloc (20);
2314 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2317 abfd
= bfd_create (oname
, parent
);
2318 bfd_find_target (pe_details
->object_target
, abfd
);
2319 bfd_make_writable (abfd
);
2321 bfd_set_format (abfd
, bfd_object
);
2322 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2325 symtab
= xmalloc (3 * sizeof (asymbol
*));
2326 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2327 quick_symbol (abfd
, "__nm_thnk_", import
, "", id4
, BSF_GLOBAL
, 0);
2328 quick_symbol (abfd
, "__nm_", import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2330 /* We need space for the real thunk and for the null terminator. */
2331 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2332 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2334 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2335 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2338 bfd_set_symtab (abfd
, symtab
, symptr
);
2340 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2342 bfd_make_readable (abfd
);
2347 make_import_fixup_mark (arelent
*rel
)
2349 /* We convert reloc to symbol, for later reference. */
2351 static char *fixup_name
= NULL
;
2352 static size_t buffer_len
= 0;
2354 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2356 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2357 struct bfd_link_hash_entry
*bh
;
2361 fixup_name
= xmalloc (384);
2365 if (strlen (sym
->name
) + 25 > buffer_len
)
2366 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2367 bigger than 20 digits long, we've got worse problems than
2368 overflowing this buffer... */
2371 /* New buffer size is length of symbol, plus 25, but
2372 then rounded up to the nearest multiple of 128. */
2373 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2374 fixup_name
= xmalloc (buffer_len
);
2377 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2380 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2381 current_sec
, /* sym->section, */
2382 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2387 /* .section .idata$2
2388 .rva __nm_thnk_SYM (singleton thunk with name of func)
2391 .rva __my_dll_iname (name of dll)
2392 .rva __fuNN_SYM (pointer to reference (address) in text) */
2395 make_import_fixup_entry (const char *name
,
2396 const char *fixup_name
,
2397 const char *symname
,
2405 oname
= xmalloc (20);
2406 sprintf (oname
, "fu%06d.o", tmp_seq
);
2409 abfd
= bfd_create (oname
, parent
);
2410 bfd_find_target (pe_details
->object_target
, abfd
);
2411 bfd_make_writable (abfd
);
2413 bfd_set_format (abfd
, bfd_object
);
2414 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2417 symtab
= xmalloc (6 * sizeof (asymbol
*));
2418 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2420 quick_symbol (abfd
, "__nm_thnk_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2421 quick_symbol (abfd
, U (""), symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2422 /* For relocator v2 we have to use the .idata$5 element and not
2424 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2425 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2427 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2429 bfd_set_section_size (abfd
, id2
, 20);
2434 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2435 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2436 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2439 bfd_set_symtab (abfd
, symtab
, symptr
);
2441 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2443 bfd_make_readable (abfd
);
2447 /* .section .rdata_runtime_pseudo_reloc
2449 .rva __fuNN_SYM (pointer to reference (address) in text) */
2452 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2453 const char *fixup_name
,
2454 bfd_vma addend ATTRIBUTE_UNUSED
,
2459 unsigned char *rt_rel_d
;
2462 oname
= xmalloc (20);
2463 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2466 abfd
= bfd_create (oname
, parent
);
2467 bfd_find_target (pe_details
->object_target
, abfd
);
2468 bfd_make_writable (abfd
);
2470 bfd_set_format (abfd
, bfd_object
);
2471 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2474 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2476 symtab
= xmalloc ((runtime_pseudp_reloc_v2_init
? 3 : 6) * sizeof (asymbol
*));
2480 symtab
= xmalloc (2 * sizeof (asymbol
*));
2482 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2483 SEC_HAS_CONTENTS
, 2);
2485 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2487 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2490 if (! runtime_pseudp_reloc_v2_init
)
2493 runtime_pseudp_reloc_v2_init
= 1;
2495 quick_symbol (abfd
, "__imp_", name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2497 bfd_set_section_size (abfd
, rt_rel
, size
);
2498 rt_rel_d
= xmalloc (size
);
2499 rt_rel
->contents
= rt_rel_d
;
2500 memset (rt_rel_d
, 0, size
);
2501 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2502 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2503 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2505 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2506 save_relocs (rt_rel
);
2508 bfd_set_symtab (abfd
, symtab
, symptr
);
2510 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2514 bfd_set_section_size (abfd
, rt_rel
, 8);
2515 rt_rel_d
= xmalloc (8);
2516 rt_rel
->contents
= rt_rel_d
;
2517 memset (rt_rel_d
, 0, 8);
2519 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2520 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2522 save_relocs (rt_rel
);
2524 bfd_set_symtab (abfd
, symtab
, symptr
);
2526 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2528 bfd_make_readable (abfd
);
2533 .rva __pei386_runtime_relocator */
2536 pe_create_runtime_relocator_reference (bfd
*parent
)
2538 asection
*extern_rt_rel
;
2539 unsigned char *extern_rt_rel_d
;
2543 oname
= xmalloc (20);
2544 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2547 abfd
= bfd_create (oname
, parent
);
2548 bfd_find_target (pe_details
->object_target
, abfd
);
2549 bfd_make_writable (abfd
);
2551 bfd_set_format (abfd
, bfd_object
);
2552 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2555 symtab
= xmalloc (2 * sizeof (asymbol
*));
2556 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2558 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2561 bfd_set_section_size (abfd
, extern_rt_rel
, PE_IDATA5_SIZE
);
2562 extern_rt_rel_d
= xmalloc (PE_IDATA5_SIZE
);
2563 extern_rt_rel
->contents
= extern_rt_rel_d
;
2565 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2566 save_relocs (extern_rt_rel
);
2568 bfd_set_symtab (abfd
, symtab
, symptr
);
2570 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, PE_IDATA5_SIZE
);
2572 bfd_make_readable (abfd
);
2577 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
)
2580 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2581 struct bfd_link_hash_entry
*name_thunk_sym
;
2582 struct bfd_link_hash_entry
*name_imp_sym
;
2583 const char *name
= sym
->name
;
2584 char *fixup_name
= make_import_fixup_mark (rel
);
2586 int need_import_table
= 1;
2588 sprintf (buf
, "__imp_%s", name
);
2589 name_imp_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2591 sprintf (buf
, "__nm_thnk_%s", name
);
2593 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2595 /* For version 2 pseudo relocation we don't need to add an import
2596 if the import symbol is already present. */
2597 if (link_info
.pei386_runtime_pseudo_reloc
== 2
2599 && name_imp_sym
->type
== bfd_link_hash_defined
)
2600 need_import_table
= 0;
2602 if (need_import_table
== 1
2603 && (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
))
2605 b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2606 add_bfd_to_link (b
, b
->filename
, &link_info
);
2608 /* If we ever use autoimport, we have to cast text section writable.
2609 But not for version 2. */
2610 if (link_info
.pei386_runtime_pseudo_reloc
!= 2)
2612 config
.text_read_only
= FALSE
;
2613 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2615 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2617 b
= make_singleton_name_imp (name
, link_info
.output_bfd
);
2618 add_bfd_to_link (b
, b
->filename
, &link_info
);
2622 if ((addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2623 && need_import_table
== 1)
2625 extern char * pe_data_import_dll
;
2626 char * symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2628 b
= make_import_fixup_entry (name
, fixup_name
, symname
,
2629 link_info
.output_bfd
);
2630 add_bfd_to_link (b
, b
->filename
, &link_info
);
2633 if ((link_info
.pei386_runtime_pseudo_reloc
!= 0 && addend
!= 0)
2634 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2636 if (pe_dll_extra_pe_debug
)
2637 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2638 fixup_name
, (int) addend
);
2640 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2641 link_info
.output_bfd
);
2642 add_bfd_to_link (b
, b
->filename
, &link_info
);
2644 if (runtime_pseudo_relocs_created
== 0)
2646 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2647 add_bfd_to_link (b
, b
->filename
, &link_info
);
2649 runtime_pseudo_relocs_created
++;
2651 else if (addend
!= 0)
2653 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2654 s
->owner
, s
, rel
->address
, sym
->name
);
2661 pe_dll_generate_implib (def_file
*def
, const char *impfilename
, struct bfd_link_info
*info
)
2670 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2671 dll_symname
= xstrdup (dll_filename
);
2672 for (i
= 0; dll_symname
[i
]; i
++)
2673 if (!ISALNUM (dll_symname
[i
]))
2674 dll_symname
[i
] = '_';
2676 unlink_if_ordinary (impfilename
);
2678 outarch
= bfd_openw (impfilename
, 0);
2682 /* xgettext:c-format */
2683 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2687 /* xgettext:c-format */
2688 info_msg (_("Creating library file: %s\n"), impfilename
);
2690 bfd_set_format (outarch
, bfd_archive
);
2691 outarch
->has_armap
= 1;
2693 /* Work out a reasonable size of things to put onto one line. */
2694 ar_head
= make_head (outarch
);
2696 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2697 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
2699 /* Iterate the exclude list. */
2700 struct exclude_list_struct
*ex
;
2702 for (ex
= excludes
, found
= 0; ex
&& !found
; ex
= ex
->next
)
2704 if (ex
->type
!= EXCLUDEFORIMPLIB
)
2706 found
= (filename_cmp (ex
->string
, ibfd
->filename
) == 0);
2708 /* If it matched, we must open a fresh BFD for it (the original
2709 input BFD is still needed for the DLL's final link) and add
2710 it into the archive member chain. */
2713 bfd
*newbfd
= bfd_openr (ibfd
->my_archive
2714 ? ibfd
->my_archive
->filename
: ibfd
->filename
, NULL
);
2717 einfo (_("%Xbfd_openr %s: %E\n"), ibfd
->filename
);
2720 if (ibfd
->my_archive
)
2722 /* Must now iterate through archive until we find the
2723 required member. A minor shame that we'll open the
2724 archive once per member that we require from it, and
2725 leak those archive bfds rather than reuse them. */
2726 bfd
*arbfd
= newbfd
;
2727 if (!bfd_check_format_matches (arbfd
, bfd_archive
, NULL
))
2729 einfo (_("%X%s(%s): can't find member in non-archive file"),
2730 ibfd
->my_archive
->filename
, ibfd
->filename
);
2734 while ((newbfd
= bfd_openr_next_archived_file (arbfd
, newbfd
)) != 0)
2736 if (filename_cmp (newbfd
->filename
, ibfd
->filename
) == 0)
2741 einfo (_("%X%s(%s): can't find member in archive"),
2742 ibfd
->my_archive
->filename
, ibfd
->filename
);
2746 newbfd
->archive_next
= head
;
2751 for (i
= 0; i
< def
->num_exports
; i
++)
2753 /* The import library doesn't know about the internal name. */
2754 char *internal
= def
->exports
[i
].internal_name
;
2757 /* Don't add PRIVATE entries to import lib. */
2758 if (pe_def_file
->exports
[i
].flag_private
)
2760 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2761 n
= make_one (def
->exports
+ i
, outarch
,
2762 ! (def
->exports
+ i
)->flag_data
);
2763 n
->archive_next
= head
;
2765 def
->exports
[i
].internal_name
= internal
;
2768 ar_tail
= make_tail (outarch
);
2770 if (ar_head
== NULL
|| ar_tail
== NULL
)
2773 /* Now stick them all into the archive. */
2774 ar_head
->archive_next
= head
;
2775 ar_tail
->archive_next
= ar_head
;
2778 if (! bfd_set_archive_head (outarch
, head
))
2779 einfo ("%Xbfd_set_archive_head: %E\n");
2781 if (! bfd_close (outarch
))
2782 einfo ("%Xbfd_close %s: %E\n", impfilename
);
2784 while (head
!= NULL
)
2786 bfd
*n
= head
->archive_next
;
2792 static struct bfd_link_hash_entry
*found_sym
;
2795 pe_undef_alias_cdecl_match (struct bfd_link_hash_entry
*h
, void *inf
)
2799 const char *hs
= h
->root
.string
;
2801 sl
= strlen (string
);
2802 if (h
->type
== bfd_link_hash_undefined
2803 && ((*hs
== '@' && (!pe_details
->underscored
|| *string
== '_')
2804 && strncmp (hs
+ 1, string
+ (pe_details
->underscored
!= 0),
2805 sl
- (pe_details
->underscored
!= 0)) == 0)
2806 || strncmp (hs
, string
, sl
) == 0)
2807 && h
->root
.string
[sl
] == '@')
2815 static struct bfd_link_hash_entry
*
2816 pe_find_cdecl_alias_match (char *name
)
2819 bfd_link_hash_traverse (link_info
.hash
, pe_undef_alias_cdecl_match
,
2825 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*linfo
)
2827 lang_input_statement_type
*fake_file
;
2829 fake_file
= lang_add_input_file (name
,
2830 lang_input_file_is_fake_enum
,
2832 fake_file
->the_bfd
= abfd
;
2833 ldlang_add_file (fake_file
);
2835 if (!bfd_link_add_symbols (abfd
, linfo
))
2836 einfo ("%Xaddsym %s: %E\n", name
);
2840 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*linfo
)
2842 def_file_module
*module
;
2844 pe_dll_id_target (bfd_get_target (output_bfd
));
2849 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2853 dll_filename
= module
->name
;
2854 dll_symname
= xstrdup (module
->name
);
2855 for (i
= 0; dll_symname
[i
]; i
++)
2856 if (!ISALNUM (dll_symname
[i
]))
2857 dll_symname
[i
] = '_';
2861 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2862 if (pe_def_file
->imports
[i
].module
== module
)
2864 def_file_export exp
;
2865 struct bfd_link_hash_entry
*blhe
;
2866 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2867 /* See if we need this import. */
2868 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2869 char *name
= xmalloc (len
+ 2 + 6);
2870 bfd_boolean include_jmp_stub
= FALSE
;
2871 bfd_boolean is_cdecl
= FALSE
;
2872 if (!lead_at
&& strchr (pe_def_file
->imports
[i
].internal_name
, '@') == NULL
)
2876 sprintf (name
, "%s",
2877 pe_def_file
->imports
[i
].internal_name
);
2879 sprintf (name
, "%s%s",U (""),
2880 pe_def_file
->imports
[i
].internal_name
);
2882 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
2883 FALSE
, FALSE
, FALSE
);
2885 /* Include the jump stub for <sym> only if the <sym>
2887 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2890 sprintf (name
, "%s%s", "__imp_",
2891 pe_def_file
->imports
[i
].internal_name
);
2893 sprintf (name
, "%s%s%s", "__imp_", U (""),
2894 pe_def_file
->imports
[i
].internal_name
);
2896 blhe
= bfd_link_hash_lookup (linfo
->hash
, name
,
2897 FALSE
, FALSE
, FALSE
);
2900 include_jmp_stub
= TRUE
;
2902 if (is_cdecl
&& !blhe
)
2904 sprintf (name
, "%s%s",U (""),
2905 pe_def_file
->imports
[i
].internal_name
);
2906 blhe
= pe_find_cdecl_alias_match (name
);
2907 include_jmp_stub
= TRUE
;
2912 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2918 bfd
*ar_head
= make_head (output_bfd
);
2919 add_bfd_to_link (ar_head
, ar_head
->filename
, linfo
);
2922 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2923 exp
.name
= pe_def_file
->imports
[i
].name
;
2924 exp
.its_name
= pe_def_file
->imports
[i
].its_name
;
2925 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2926 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2927 exp
.flag_private
= 0;
2928 exp
.flag_constant
= 0;
2929 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2930 exp
.flag_noname
= exp
.name
? 0 : 1;
2931 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
2932 add_bfd_to_link (one
, one
->filename
, linfo
);
2937 bfd
*ar_tail
= make_tail (output_bfd
);
2938 add_bfd_to_link (ar_tail
, ar_tail
->filename
, linfo
);
2945 /* We were handed a *.DLL file. Parse it and turn it into a set of
2946 IMPORTS directives in the def file. Return TRUE if the file was
2947 handled, FALSE if not. */
2950 pe_get16 (bfd
*abfd
, int where
)
2954 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2955 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2956 return b
[0] + (b
[1] << 8);
2960 pe_get32 (bfd
*abfd
, int where
)
2964 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2965 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2966 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2972 unsigned char *b
= ptr
;
2974 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2978 pe_implied_import_dll (const char *filename
)
2981 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2982 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
2983 bfd_vma exp_funcbase
;
2984 unsigned char *expdata
;
2986 bfd_vma name_rvas
, nexp
;
2987 const char *dllname
;
2988 /* Initialization with start > end guarantees that is_data
2989 will not be set by mistake, and avoids compiler warning. */
2990 bfd_vma data_start
= 1;
2991 bfd_vma data_end
= 0;
2992 bfd_vma rdata_start
= 1;
2993 bfd_vma rdata_end
= 0;
2994 bfd_vma bss_start
= 1;
2995 bfd_vma bss_end
= 0;
2997 /* No, I can't use bfd here. kernel32.dll puts its export table in
2998 the middle of the .rdata section. */
2999 dll
= bfd_openr (filename
, pe_details
->target_name
);
3002 einfo ("%Xopen %s: %E\n", filename
);
3006 /* PEI dlls seem to be bfd_objects. */
3007 if (!bfd_check_format (dll
, bfd_object
))
3009 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
3013 /* Get pe_header, optional header and numbers of directory entries. */
3014 pe_header_offset
= pe_get32 (dll
, 0x3c);
3015 opthdr_ofs
= pe_header_offset
+ 4 + 20;
3016 #ifdef pe_use_x86_64
3017 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3019 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
3022 /* No import or export directory entry. */
3023 if (num_entries
< 1)
3026 #ifdef pe_use_x86_64
3027 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
3028 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
3030 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
3031 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
3034 /* No export table - nothing to export. */
3035 if (export_size
== 0)
3038 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
3039 secptr
= (pe_header_offset
+ 4 + 20 +
3040 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
3043 /* Get the rva and size of the export section. */
3044 for (i
= 0; i
< nsections
; i
++)
3047 bfd_vma secptr1
= secptr
+ 40 * i
;
3048 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3049 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
3050 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
3052 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
3053 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
3055 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
3057 expptr
= fptr
+ (export_rva
- vaddr
);
3058 if (export_rva
+ export_size
> vaddr
+ vsize
)
3059 export_size
= vsize
- (export_rva
- vaddr
);
3064 /* Scan sections and store the base and size of the
3065 data and bss segments in data/base_start/end. */
3066 for (i
= 0; i
< nsections
; i
++)
3068 bfd_vma secptr1
= secptr
+ 40 * i
;
3069 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
3070 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
3071 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
3075 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
3076 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
3078 if (strcmp(sec_name
,".data") == 0)
3081 data_end
= vaddr
+ vsize
;
3083 if (pe_dll_extra_pe_debug
)
3084 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3085 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3086 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3088 else if (strcmp(sec_name
,".rdata") == 0)
3090 rdata_start
= vaddr
;
3091 rdata_end
= vaddr
+ vsize
;
3093 if (pe_dll_extra_pe_debug
)
3094 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3095 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3096 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3098 else if (strcmp (sec_name
,".bss") == 0)
3101 bss_end
= vaddr
+ vsize
;
3103 if (pe_dll_extra_pe_debug
)
3104 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3105 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
3106 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
3110 expdata
= xmalloc (export_size
);
3111 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
3112 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
3113 erva
= (char *) expdata
- export_rva
;
3115 if (pe_def_file
== 0)
3116 pe_def_file
= def_file_empty ();
3118 nexp
= pe_as32 (expdata
+ 24);
3119 name_rvas
= pe_as32 (expdata
+ 32);
3120 exp_funcbase
= pe_as32 (expdata
+ 28);
3122 /* Use internal dll name instead of filename
3123 to enable symbolic dll linking. */
3124 dllname
= erva
+ pe_as32 (expdata
+ 12);
3126 /* Check to see if the dll has already been added to
3127 the definition list and if so return without error.
3128 This avoids multiple symbol definitions. */
3129 if (def_get_module (pe_def_file
, dllname
))
3131 if (pe_dll_extra_pe_debug
)
3132 printf ("%s is already loaded\n", dllname
);
3136 /* Iterate through the list of symbols. */
3137 for (i
= 0; i
< nexp
; i
++)
3139 /* Pointer to the names vector. */
3140 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
3141 def_file_import
*imp
;
3142 /* Pointer to the function address vector. */
3143 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
3146 /* Skip unwanted symbols, which are
3147 exported in buggy auto-import releases. */
3148 if (! CONST_STRNEQ (erva
+ name_rva
, "__nm_"))
3151 /* is_data is true if the address is in the data, rdata or bss
3154 (func_rva
>= data_start
&& func_rva
< data_end
)
3155 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
3156 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
3158 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
3159 dllname
, i
, 0, NULL
, &is_dup
);
3160 /* Mark symbol type. */
3162 imp
->data
= is_data
;
3164 if (pe_dll_extra_pe_debug
)
3165 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3166 __FUNCTION__
, dllname
, erva
+ name_rva
,
3167 (unsigned long) func_rva
, is_data
? "(data)" : "");
3175 pe_output_file_set_long_section_names (bfd
*abfd
)
3177 if (pe_use_coff_long_section_names
< 0)
3179 if (!bfd_coff_set_long_section_names (abfd
, pe_use_coff_long_section_names
))
3180 einfo (_("%XError: can't use long section names on this arch\n"));
3183 /* These are the main functions, called from the emulation. The first
3184 is called after the bfds are read, so we can guess at how much space
3185 we need. The second is called after everything is placed, so we
3186 can put the right values in place. */
3189 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3191 pe_dll_id_target (bfd_get_target (abfd
));
3192 pe_output_file_set_long_section_names (abfd
);
3193 process_def_file_and_drectve (abfd
, info
);
3195 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
3198 generate_edata (abfd
, info
);
3199 build_filler_bfd (1);
3200 pe_output_file_set_long_section_names (filler_bfd
);
3204 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3206 pe_dll_id_target (bfd_get_target (abfd
));
3207 pe_output_file_set_long_section_names (abfd
);
3208 build_filler_bfd (0);
3209 pe_output_file_set_long_section_names (filler_bfd
);
3213 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3215 pe_dll_id_target (bfd_get_target (abfd
));
3216 pe_output_file_set_long_section_names (abfd
);
3217 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3219 generate_reloc (abfd
, info
);
3222 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3224 /* Resize the sections. */
3225 lang_reset_memory_regions ();
3226 lang_size_sections (NULL
, TRUE
);
3228 /* Redo special stuff. */
3229 ldemul_after_allocation ();
3231 /* Do the assignments again. */
3232 lang_do_assignments (lang_final_phase_enum
);
3235 fill_edata (abfd
, info
);
3237 if (info
->shared
&& !info
->pie
)
3238 pe_data (abfd
)->dll
= 1;
3240 edata_s
->contents
= edata_d
;
3241 reloc_s
->contents
= reloc_d
;
3245 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3247 pe_dll_id_target (bfd_get_target (abfd
));
3248 pe_output_file_set_long_section_names (abfd
);
3249 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
3251 generate_reloc (abfd
, info
);
3254 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
3256 /* Resize the sections. */
3257 lang_reset_memory_regions ();
3258 lang_size_sections (NULL
, TRUE
);
3260 /* Redo special stuff. */
3261 ldemul_after_allocation ();
3263 /* Do the assignments again. */
3264 lang_do_assignments (lang_final_phase_enum
);
3266 reloc_s
->contents
= reloc_d
;
3270 pe_bfd_is_dll (bfd
*abfd
)
3272 return (bfd_get_format (abfd
) == bfd_object
3274 && pe_data (abfd
)->dll
);