1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008 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"
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_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;
160 /* Static variables and types. */
162 static bfd_vma image_base
;
163 static bfd
*filler_bfd
;
164 static struct bfd_section
*edata_s
, *reloc_s
;
165 static unsigned char *edata_d
, *reloc_d
;
166 static size_t edata_sz
, reloc_sz
;
167 static int runtime_pseudo_relocs_created
= 0;
174 autofilter_entry_type
;
178 const char *target_name
;
179 const char *object_target
;
180 unsigned int imagebase_reloc
;
183 bfd_boolean underscored
;
184 const autofilter_entry_type
* autofilter_symbollist
;
188 static const autofilter_entry_type autofilter_symbollist_generic
[] =
190 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
191 /* Entry point symbols. */
192 { STRING_COMMA_LEN ("DllMain") },
193 { STRING_COMMA_LEN ("DllMainCRTStartup") },
194 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
195 /* Runtime pseudo-reloc. */
196 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
197 { STRING_COMMA_LEN ("do_pseudo_reloc") },
201 static const autofilter_entry_type autofilter_symbollist_i386
[] =
203 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
204 /* Entry point symbols, and entry hooks. */
205 { STRING_COMMA_LEN ("cygwin_crt0") },
207 { STRING_COMMA_LEN ("DllMain") },
208 { STRING_COMMA_LEN ("DllEntryPoint") },
209 { STRING_COMMA_LEN ("DllMainCRTStartup") },
210 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
211 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
212 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
214 { STRING_COMMA_LEN ("DllMain@12") },
215 { STRING_COMMA_LEN ("DllEntryPoint@0") },
216 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
217 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
218 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
219 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
220 { STRING_COMMA_LEN ("cygwin_attach_dll") },
222 { STRING_COMMA_LEN ("cygwin_premain0") },
223 { STRING_COMMA_LEN ("cygwin_premain1") },
224 { STRING_COMMA_LEN ("cygwin_premain2") },
225 { STRING_COMMA_LEN ("cygwin_premain3") },
226 /* Runtime pseudo-reloc. */
227 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
228 { STRING_COMMA_LEN ("do_pseudo_reloc") },
229 /* Global vars that should not be exported. */
230 { STRING_COMMA_LEN ("impure_ptr") },
231 { STRING_COMMA_LEN ("_impure_ptr") },
232 { STRING_COMMA_LEN ("_fmode") },
233 { STRING_COMMA_LEN ("environ") },
237 #define PE_ARCH_i386 1
239 #define PE_ARCH_mips 3
240 #define PE_ARCH_arm 4
241 #define PE_ARCH_arm_epoc 5
242 #define PE_ARCH_arm_wince 6
244 static const pe_details_type pe_detail_list
[] =
259 autofilter_symbollist_i386
264 16 /* R_SH_IMAGEBASE */,
268 autofilter_symbollist_generic
277 autofilter_symbollist_generic
286 autofilter_symbollist_generic
289 "epoc-pei-arm-little",
290 "epoc-pe-arm-little",
295 autofilter_symbollist_generic
298 "pei-arm-wince-little",
299 "pe-arm-wince-little",
300 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
304 autofilter_symbollist_generic
306 { NULL
, NULL
, 0, 0, 0, FALSE
, NULL
}
309 static const pe_details_type
*pe_details
;
311 /* Do not specify library suffix explicitly, to allow for dllized versions. */
312 static const autofilter_entry_type autofilter_liblist
[] =
314 { STRING_COMMA_LEN ("libcegcc") },
315 { STRING_COMMA_LEN ("libcygwin") },
316 { STRING_COMMA_LEN ("libgcc") },
317 { STRING_COMMA_LEN ("libstdc++") },
318 { STRING_COMMA_LEN ("libmingw32") },
319 { STRING_COMMA_LEN ("libmingwex") },
320 { STRING_COMMA_LEN ("libg2c") },
321 { STRING_COMMA_LEN ("libsupc++") },
322 { STRING_COMMA_LEN ("libobjc") },
323 { STRING_COMMA_LEN ("libgcj") },
327 static const autofilter_entry_type autofilter_objlist
[] =
329 { STRING_COMMA_LEN ("crt0.o") },
330 { STRING_COMMA_LEN ("crt1.o") },
331 { STRING_COMMA_LEN ("crt2.o") },
332 { STRING_COMMA_LEN ("dllcrt1.o") },
333 { STRING_COMMA_LEN ("dllcrt2.o") },
334 { STRING_COMMA_LEN ("gcrt0.o") },
335 { STRING_COMMA_LEN ("gcrt1.o") },
336 { STRING_COMMA_LEN ("gcrt2.o") },
337 { STRING_COMMA_LEN ("crtbegin.o") },
338 { STRING_COMMA_LEN ("crtend.o") },
342 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
344 /* _imp_ is treated specially, as it is always underscored. */
345 /* { STRING_COMMA_LEN ("_imp_") }, */
346 /* Don't export some c++ symbols. */
347 { STRING_COMMA_LEN ("__rtti_") },
348 { STRING_COMMA_LEN ("__builtin_") },
349 /* Don't re-export auto-imported symbols. */
350 { STRING_COMMA_LEN ("_nm_") },
351 /* Don't export symbols specifying internal DLL layout. */
352 { STRING_COMMA_LEN ("_head_") },
353 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
354 /* Don't export section labels or artificial symbols
356 { STRING_COMMA_LEN (".") },
360 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
362 { STRING_COMMA_LEN ("_iname") },
363 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
367 #define U(str) (pe_details->underscored ? "_" str : str)
370 pe_dll_id_target (const char *target
)
374 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
375 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
376 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
378 pe_details
= pe_detail_list
+ i
;
381 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
385 /* Helper functions for qsort. Relocs must be sorted so that we can write
386 them out by pages. */
397 reloc_sort (const void *va
, const void *vb
)
399 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
400 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
402 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
406 pe_export_sort (const void *va
, const void *vb
)
408 const def_file_export
*a
= va
;
409 const def_file_export
*b
= vb
;
411 return strcmp (a
->name
, b
->name
);
414 /* Read and process the .DEF file. */
416 /* These correspond to the entries in pe_def_file->exports[]. I use
417 exported_symbol_sections[i] to tag whether or not the symbol was
418 defined, since we can't export symbols we don't have. */
420 static bfd_vma
*exported_symbol_offsets
;
421 static struct bfd_section
**exported_symbol_sections
;
422 static int export_table_size
;
423 static int count_exported
;
424 static int count_exported_byname
;
425 static int count_with_ordinals
;
426 static const char *dll_name
;
427 static int min_ordinal
, max_ordinal
;
428 static int *exported_symbols
;
430 typedef struct exclude_list_struct
433 struct exclude_list_struct
*next
;
438 static struct exclude_list_struct
*excludes
= 0;
441 pe_dll_add_excludes (const char *new_excludes
, const int type
)
444 char *exclude_string
;
446 local_copy
= xstrdup (new_excludes
);
448 exclude_string
= strtok (local_copy
, ",:");
449 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
451 struct exclude_list_struct
*new_exclude
;
453 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
454 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
455 strcpy (new_exclude
->string
, exclude_string
);
456 new_exclude
->type
= type
;
457 new_exclude
->next
= excludes
;
458 excludes
= new_exclude
;
465 is_import (const char* n
)
467 return (CONST_STRNEQ (n
, "__imp_"));
470 /* abfd is a bfd containing n (or NULL)
471 It can be used for contextual checks. */
474 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
477 struct exclude_list_struct
*ex
;
478 const autofilter_entry_type
*afptr
;
479 const char * libname
= 0;
480 if (abfd
&& abfd
->my_archive
)
481 libname
= lbasename (abfd
->my_archive
->filename
);
483 for (i
= 0; i
< d
->num_exports
; i
++)
484 if (strcmp (d
->exports
[i
].name
, n
) == 0)
487 if (pe_dll_do_default_excludes
)
492 if (pe_dll_extra_pe_debug
)
493 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
494 n
, abfd
, abfd
->my_archive
);
496 /* First of all, make context checks:
497 Don't export anything from standard libs. */
500 afptr
= autofilter_liblist
;
504 if (strncmp (libname
, afptr
->name
, afptr
->len
) == 0 )
510 /* Next, exclude symbols from certain startup objects. */
512 if (abfd
&& (p
= lbasename (abfd
->filename
)))
514 afptr
= autofilter_objlist
;
517 if (strcmp (p
, afptr
->name
) == 0)
523 /* Don't try to blindly exclude all symbols
524 that begin with '__'; this was tried and
525 it is too restrictive. Instead we have
526 a target specific list to use: */
527 afptr
= pe_details
->autofilter_symbollist
;
531 if (strcmp (n
, afptr
->name
) == 0)
537 /* Next, exclude symbols starting with ... */
538 afptr
= autofilter_symbolprefixlist
;
541 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
547 /* Finally, exclude symbols ending with ... */
549 afptr
= autofilter_symbolsuffixlist
;
552 if ((len
>= afptr
->len
)
553 /* Add 1 to insure match with trailing '\0'. */
554 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
555 afptr
->len
+ 1) == 0)
562 for (ex
= excludes
; ex
; ex
= ex
->next
)
564 if (ex
->type
== 1) /* exclude-libs */
567 && ((strcmp (libname
, ex
->string
) == 0)
568 || (strcasecmp ("ALL", ex
->string
) == 0)))
571 else if (strcmp (n
, ex
->string
) == 0)
579 process_def_file (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
582 struct bfd_link_hash_entry
*blhe
;
584 struct bfd_section
*s
;
585 def_file_export
*e
= 0;
588 pe_def_file
= def_file_empty ();
590 /* First, run around to all the objects looking for the .drectve
591 sections, and push those into the def file too. */
592 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
594 s
= bfd_get_section_by_name (b
, ".drectve");
598 char *buf
= xmalloc (size
);
600 bfd_get_section_contents (b
, s
, buf
, 0, size
);
601 def_file_add_directive (pe_def_file
, buf
, size
);
606 /* If we are not building a DLL, when there are no exports
607 we do not build an export table at all. */
608 if (!pe_dll_export_everything
&& pe_def_file
->num_exports
== 0
612 /* Now, maybe export everything else the default way. */
613 if (pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
615 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
620 symsize
= bfd_get_symtab_upper_bound (b
);
621 symbols
= xmalloc (symsize
);
622 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
624 for (j
= 0; j
< nsyms
; j
++)
626 /* We should export symbols which are either global or not
627 anything at all. (.bss data is the latter)
628 We should not export undefined symbols. */
629 if (symbols
[j
]->section
!= &bfd_und_section
630 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
631 || (symbols
[j
]->flags
== BFD_FORT_COMM_DEFAULT_VALUE
)))
633 const char *sn
= symbols
[j
]->name
;
635 /* We should not re-export imported stuff. */
641 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
642 sprintf (name
, "%s%s", "__imp_", sn
);
644 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
645 FALSE
, FALSE
, FALSE
);
648 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
652 if (pe_details
->underscored
&& *sn
== '_')
655 if (auto_export (b
, pe_def_file
, sn
))
658 p
=def_file_add_export (pe_def_file
, sn
, 0, -1);
659 /* Fill data flag properly, from dlltool.c. */
660 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
668 #define NE pe_def_file->num_exports
670 /* Canonicalize the export list. */
673 for (i
= 0; i
< NE
; i
++)
675 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
677 /* This will preserve internal_name, which may have been
678 pointing to the same memory as name, or might not
680 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
681 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
682 char *tmp_at
= strchr (tmp
, '@');
687 einfo (_("%XCannot export %s: invalid export name\n"),
688 pe_def_file
->exports
[i
].name
);
689 pe_def_file
->exports
[i
].name
= tmp
;
694 if (pe_dll_stdcall_aliases
)
696 for (i
= 0; i
< NE
; i
++)
698 if (is_import (pe_def_file
->exports
[i
].name
))
701 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
703 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
704 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
706 *(strchr (tmp
, '@')) = 0;
707 if (auto_export (NULL
, pe_def_file
, tmp
))
708 def_file_add_export (pe_def_file
, tmp
,
709 pe_def_file
->exports
[i
].internal_name
,
717 /* Convenience, but watch out for it changing. */
718 e
= pe_def_file
->exports
;
720 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
721 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
723 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
727 count_exported_byname
= 0;
728 count_with_ordinals
= 0;
730 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
732 for (i
= 0, j
= 0; i
< NE
; i
++)
734 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
736 /* This is a duplicate. */
737 if (e
[j
- 1].ordinal
!= -1
738 && e
[i
].ordinal
!= -1
739 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
741 if (pe_dll_warn_dup_exports
)
742 /* xgettext:c-format */
743 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
744 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
748 if (pe_dll_warn_dup_exports
)
749 /* xgettext:c-format */
750 einfo (_("Warning, duplicate EXPORT: %s\n"),
754 if (e
[i
].ordinal
!= -1)
755 e
[j
- 1].ordinal
= e
[i
].ordinal
;
756 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
757 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
758 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
759 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
768 pe_def_file
->num_exports
= j
; /* == NE */
770 for (i
= 0; i
< NE
; i
++)
774 /* Check for forward exports */
775 if (strchr (pe_def_file
->exports
[i
].internal_name
, '.'))
778 if (!pe_def_file
->exports
[i
].flag_noname
)
779 count_exported_byname
++;
781 pe_def_file
->exports
[i
].flag_forward
= 1;
783 if (pe_def_file
->exports
[i
].ordinal
!= -1)
785 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
786 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
787 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
788 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
789 count_with_ordinals
++;
795 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
796 if (pe_details
->underscored
797 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
800 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
803 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
805 blhe
= bfd_link_hash_lookup (info
->hash
,
810 && (blhe
->type
== bfd_link_hash_defined
811 || (blhe
->type
== bfd_link_hash_common
)))
814 if (!pe_def_file
->exports
[i
].flag_noname
)
815 count_exported_byname
++;
817 /* Only fill in the sections. The actual offsets are computed
818 in fill_exported_offsets() after common symbols are laid
820 if (blhe
->type
== bfd_link_hash_defined
)
821 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
823 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
825 if (pe_def_file
->exports
[i
].ordinal
!= -1)
827 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
828 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
829 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
830 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
831 count_with_ordinals
++;
834 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
836 /* xgettext:c-format */
837 einfo (_("%XCannot export %s: symbol not defined\n"),
838 pe_def_file
->exports
[i
].internal_name
);
842 /* xgettext:c-format */
843 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
844 pe_def_file
->exports
[i
].internal_name
,
845 blhe
->type
, bfd_link_hash_defined
);
849 /* xgettext:c-format */
850 einfo (_("%XCannot export %s: symbol not found\n"),
851 pe_def_file
->exports
[i
].internal_name
);
857 /* Build the bfd that will contain .edata and .reloc sections. */
860 build_filler_bfd (int include_edata
)
862 lang_input_statement_type
*filler_file
;
863 filler_file
= lang_add_input_file ("dll stuff",
864 lang_input_file_is_fake_enum
,
866 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
867 link_info
.output_bfd
);
868 if (filler_bfd
== NULL
869 || !bfd_set_arch_mach (filler_bfd
,
870 bfd_get_arch (link_info
.output_bfd
),
871 bfd_get_mach (link_info
.output_bfd
)))
873 einfo ("%X%P: can not create BFD: %E\n");
879 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
881 || !bfd_set_section_flags (filler_bfd
, edata_s
,
888 einfo ("%X%P: can not create .edata section: %E\n");
891 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
894 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
896 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
903 einfo ("%X%P: can not create .reloc section: %E\n");
907 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
909 ldlang_add_file (filler_file
);
912 /* Gather all the exported symbols and build the .edata section. */
915 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
918 int name_table_size
= 0;
921 /* First, we need to know how many exported symbols there are,
922 and what the range of ordinals is. */
923 if (pe_def_file
->name
)
924 dll_name
= pe_def_file
->name
;
927 dll_name
= abfd
->filename
;
929 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
930 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
934 if (count_with_ordinals
&& max_ordinal
> count_exported
)
936 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
937 min_ordinal
= max_ordinal
- count_exported
+ 1;
942 max_ordinal
= count_exported
;
945 export_table_size
= max_ordinal
- min_ordinal
+ 1;
946 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
947 for (i
= 0; i
< export_table_size
; i
++)
948 exported_symbols
[i
] = -1;
950 /* Now we need to assign ordinals to those that don't have them. */
951 for (i
= 0; i
< NE
; i
++)
953 if (exported_symbol_sections
[i
] ||
954 pe_def_file
->exports
[i
].flag_forward
)
956 if (pe_def_file
->exports
[i
].ordinal
!= -1)
958 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
959 int pi
= exported_symbols
[ei
];
963 /* xgettext:c-format */
964 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
965 pe_def_file
->exports
[i
].ordinal
,
966 pe_def_file
->exports
[i
].name
,
967 pe_def_file
->exports
[pi
].name
);
969 exported_symbols
[ei
] = i
;
971 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
974 /* Reserve space for the forward name. */
975 if (pe_def_file
->exports
[i
].flag_forward
)
977 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
981 next_ordinal
= min_ordinal
;
982 for (i
= 0; i
< NE
; i
++)
983 if ((exported_symbol_sections
[i
] ||
984 pe_def_file
->exports
[i
].flag_forward
) &&
985 pe_def_file
->exports
[i
].ordinal
== -1)
987 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
990 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
991 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
994 /* OK, now we can allocate some memory. */
995 edata_sz
= (40 /* directory */
996 + 4 * export_table_size
/* addresses */
997 + 4 * count_exported_byname
/* name ptrs */
998 + 2 * count_exported_byname
/* ordinals */
999 + name_table_size
+ strlen (dll_name
) + 1);
1002 /* Fill the exported symbol offsets. The preliminary work has already
1003 been done in process_def_file(). */
1006 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1009 struct bfd_link_hash_entry
*blhe
;
1011 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1015 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1016 if (pe_details
->underscored
1017 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1020 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1023 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1025 blhe
= bfd_link_hash_lookup (info
->hash
,
1027 FALSE
, FALSE
, TRUE
);
1029 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1030 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1037 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1040 unsigned char *edirectory
;
1041 unsigned char *eaddresses
;
1042 unsigned char *enameptrs
;
1043 unsigned char *eordinals
;
1049 edata_d
= xmalloc (edata_sz
);
1051 /* Note use of array pointer math here. */
1052 edirectory
= edata_d
;
1053 eaddresses
= edata_d
+ 40;
1054 enameptrs
= eaddresses
+ 4 * export_table_size
;
1055 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1056 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1058 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1059 + edata_s->output_section->vma - image_base)
1061 memset (edata_d
, 0, edata_sz
);
1062 bfd_put_32 (abfd
, now
, edata_d
+ 4);
1063 if (pe_def_file
->version_major
!= -1)
1065 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1066 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1069 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1070 strcpy (enamestr
, dll_name
);
1071 enamestr
+= strlen (enamestr
) + 1;
1072 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1073 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1074 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1075 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1076 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1077 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1079 fill_exported_offsets (abfd
, info
);
1081 /* Ok, now for the filling in part.
1082 Scan alphabetically - ie the ordering in the exports[] table,
1083 rather than by ordinal - the ordering in the exported_symbol[]
1084 table. See dlltool.c and:
1085 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1086 for more information. */
1088 for (s
= 0; s
< NE
; s
++)
1090 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1091 if (pe_def_file
->exports
[s
].ordinal
!= -1 &&
1092 (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1094 int ord
= pe_def_file
->exports
[s
].ordinal
;
1096 if (pe_def_file
->exports
[s
].flag_forward
)
1098 bfd_put_32 (abfd
, ERVA (enamestr
),
1099 eaddresses
+ 4 * (ord
- min_ordinal
));
1101 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1102 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1106 bfd_vma srva
= (exported_symbol_offsets
[s
]
1107 + ssec
->output_section
->vma
1108 + ssec
->output_offset
);
1110 bfd_put_32 (abfd
, srva
- image_base
,
1111 eaddresses
+ 4 * (ord
- min_ordinal
));
1114 if (!pe_def_file
->exports
[s
].flag_noname
)
1116 char *ename
= pe_def_file
->exports
[s
].name
;
1118 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1120 strcpy (enamestr
, ename
);
1121 enamestr
+= strlen (enamestr
) + 1;
1122 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1124 pe_def_file
->exports
[s
].hint
= hint
++;
1131 static struct bfd_section
*current_sec
;
1134 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1136 int (*cb
) (arelent
*, asection
*))
1141 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1146 symsize
= bfd_get_symtab_upper_bound (b
);
1147 symbols
= xmalloc (symsize
);
1148 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1150 for (s
= b
->sections
; s
; s
= s
->next
)
1153 int relsize
, nrelocs
, i
;
1154 int flags
= bfd_get_section_flags (b
, s
);
1156 /* Skip discarded linkonce sections. */
1157 if (flags
& SEC_LINK_ONCE
1158 && s
->output_section
== bfd_abs_section_ptr
)
1163 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1164 relocs
= xmalloc (relsize
);
1165 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1167 for (i
= 0; i
< nrelocs
; i
++)
1169 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1171 if (!strcmp (name
, sym
->name
))
1177 /* Warning: the allocated symbols are remembered in BFD and reused
1178 later, so don't free them! */
1179 /* free (symbols); */
1184 /* Gather all the relocations and build the .reloc section. */
1187 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1190 /* For .reloc stuff. */
1191 reloc_data_type
*reloc_data
;
1192 int total_relocs
= 0;
1194 bfd_vma sec_page
= (bfd_vma
) -1;
1195 bfd_vma page_ptr
, page_count
;
1198 struct bfd_section
*s
;
1201 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1202 for (s
= b
->sections
; s
; s
= s
->next
)
1203 total_relocs
+= s
->reloc_count
;
1205 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1209 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1212 int relsize
, nrelocs
, i
;
1214 for (s
= b
->sections
; s
; s
= s
->next
)
1216 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1220 /* If it's not loaded, we don't need to relocate it this way. */
1221 if (!(s
->output_section
->flags
& SEC_LOAD
))
1224 /* I don't know why there would be a reloc for these, but I've
1225 seen it happen - DJ */
1226 if (s
->output_section
== &bfd_abs_section
)
1229 if (s
->output_section
->vma
== 0)
1231 /* Huh? Shouldn't happen, but punt if it does. */
1232 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1233 s
->output_section
->name
, s
->output_section
->index
,
1234 s
->output_section
->flags
);
1238 symsize
= bfd_get_symtab_upper_bound (b
);
1239 symbols
= xmalloc (symsize
);
1240 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1242 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1243 relocs
= xmalloc (relsize
);
1244 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1246 for (i
= 0; i
< nrelocs
; i
++)
1248 if (pe_dll_extra_pe_debug
)
1250 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1251 printf ("rel: %s\n", sym
->name
);
1253 if (!relocs
[i
]->howto
->pc_relative
1254 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1257 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1259 sym_vma
= (relocs
[i
]->addend
1262 + sym
->section
->output_offset
1263 + sym
->section
->output_section
->vma
);
1264 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1266 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1268 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1269 relocs
[i
]->howto
->rightshift
)
1271 #ifdef pe_use_x86_64
1272 case BITS_AND_SHIFT (64, 0):
1273 reloc_data
[total_relocs
].type
= 10;
1277 case BITS_AND_SHIFT (32, 0):
1278 reloc_data
[total_relocs
].type
= 3;
1281 case BITS_AND_SHIFT (16, 0):
1282 reloc_data
[total_relocs
].type
= 2;
1285 case BITS_AND_SHIFT (16, 16):
1286 reloc_data
[total_relocs
].type
= 4;
1287 /* FIXME: we can't know the symbol's right value
1288 yet, but we probably can safely assume that
1289 CE will relocate us in 64k blocks, so leaving
1291 reloc_data
[total_relocs
].extra
= 0;
1294 case BITS_AND_SHIFT (26, 2):
1295 reloc_data
[total_relocs
].type
= 5;
1298 case BITS_AND_SHIFT (24, 2):
1299 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1300 Those ARM_xxx definitions should go in proper
1302 if (relocs
[i
]->howto
->type
== 0
1303 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1304 || relocs
[i
]->howto
->type
== 5)
1305 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1306 that has already been fully processed during a
1307 previous link stage, so ignore it here. */
1311 /* xgettext:c-format */
1312 einfo (_("%XError: %d-bit reloc in dll\n"),
1313 relocs
[i
]->howto
->bitsize
);
1319 /* Warning: the allocated symbols are remembered in BFD and
1320 reused later, so don't free them! */
1324 /* At this point, we have total_relocs relocation addresses in
1325 reloc_addresses, which are all suitable for the .reloc section.
1326 We must now create the new sections. */
1327 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1329 for (i
= 0; i
< total_relocs
; i
++)
1331 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1333 if (this_page
!= sec_page
)
1335 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1337 sec_page
= this_page
;
1342 if (reloc_data
[i
].type
== 4)
1346 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1347 reloc_d
= xmalloc (reloc_sz
);
1348 sec_page
= (bfd_vma
) -1;
1350 page_ptr
= (bfd_vma
) -1;
1353 for (i
= 0; i
< total_relocs
; i
++)
1355 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1356 bfd_vma this_page
= (rva
& ~0xfff);
1358 if (this_page
!= sec_page
)
1360 while (reloc_sz
& 3)
1361 reloc_d
[reloc_sz
++] = 0;
1363 if (page_ptr
!= (bfd_vma
) -1)
1364 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1366 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1367 page_ptr
= reloc_sz
;
1369 sec_page
= this_page
;
1373 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1374 reloc_d
+ reloc_sz
);
1377 if (reloc_data
[i
].type
== 4)
1379 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1386 while (reloc_sz
& 3)
1387 reloc_d
[reloc_sz
++] = 0;
1389 if (page_ptr
!= (bfd_vma
) -1)
1390 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1392 while (reloc_sz
< reloc_s
->size
)
1393 reloc_d
[reloc_sz
++] = 0;
1396 /* Given the exiting def_file structure, print out a .DEF file that
1397 corresponds to it. */
1400 quoteput (char *s
, FILE *f
, int needs_quotes
)
1404 for (cp
= s
; *cp
; cp
++)
1419 if (*s
== '"' || *s
== '\\')
1433 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1436 FILE *out
= fopen (pe_out_def_filename
, "w");
1439 /* xgettext:c-format */
1440 einfo (_("%s: Can't open output def file %s\n"),
1441 program_name
, pe_out_def_filename
);
1445 if (pe_def_file
->name
)
1447 if (pe_def_file
->is_dll
)
1448 fprintf (out
, "LIBRARY ");
1450 fprintf (out
, "NAME ");
1452 quoteput (pe_def_file
->name
, out
, 1);
1454 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1456 fprintf (out
, " BASE=0x");
1457 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1459 fprintf (out
, "\n");
1462 if (pe_def_file
->description
)
1464 fprintf (out
, "DESCRIPTION ");
1465 quoteput (pe_def_file
->description
, out
, 1);
1466 fprintf (out
, "\n");
1469 if (pe_def_file
->version_minor
!= -1)
1470 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1471 pe_def_file
->version_minor
);
1472 else if (pe_def_file
->version_major
!= -1)
1473 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1475 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1476 fprintf (out
, "\n");
1478 if (pe_def_file
->stack_commit
!= -1)
1479 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1480 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1481 else if (pe_def_file
->stack_reserve
!= -1)
1482 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1484 if (pe_def_file
->heap_commit
!= -1)
1485 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1486 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1487 else if (pe_def_file
->heap_reserve
!= -1)
1488 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1490 if (pe_def_file
->num_section_defs
> 0)
1492 fprintf (out
, "\nSECTIONS\n\n");
1494 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1497 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1499 if (pe_def_file
->section_defs
[i
].class)
1501 fprintf (out
, " CLASS ");
1502 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1505 if (pe_def_file
->section_defs
[i
].flag_read
)
1506 fprintf (out
, " READ");
1508 if (pe_def_file
->section_defs
[i
].flag_write
)
1509 fprintf (out
, " WRITE");
1511 if (pe_def_file
->section_defs
[i
].flag_execute
)
1512 fprintf (out
, " EXECUTE");
1514 if (pe_def_file
->section_defs
[i
].flag_shared
)
1515 fprintf (out
, " SHARED");
1517 fprintf (out
, "\n");
1521 if (pe_def_file
->num_exports
> 0)
1523 fprintf (out
, "EXPORTS\n");
1525 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1527 def_file_export
*e
= pe_def_file
->exports
+ i
;
1529 quoteput (e
->name
, out
, 0);
1531 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1533 fprintf (out
, " = ");
1534 quoteput (e
->internal_name
, out
, 0);
1537 if (e
->ordinal
!= -1)
1538 fprintf (out
, " @%d", e
->ordinal
);
1540 if (e
->flag_private
)
1541 fprintf (out
, " PRIVATE");
1543 if (e
->flag_constant
)
1544 fprintf (out
, " CONSTANT");
1547 fprintf (out
, " NONAME");
1550 fprintf (out
, " DATA");
1552 fprintf (out
, "\n");
1556 if (pe_def_file
->num_imports
> 0)
1558 fprintf (out
, "\nIMPORTS\n\n");
1560 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1562 def_file_import
*im
= pe_def_file
->imports
+ i
;
1565 if (im
->internal_name
1566 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1568 quoteput (im
->internal_name
, out
, 0);
1569 fprintf (out
, " = ");
1572 quoteput (im
->module
->name
, out
, 0);
1576 quoteput (im
->name
, out
, 0);
1578 fprintf (out
, "%d", im
->ordinal
);
1580 fprintf (out
, "\n");
1585 fprintf (out
, _("; no contents available\n"));
1587 if (fclose (out
) == EOF
)
1588 /* xgettext:c-format */
1589 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1592 /* Generate the import library. */
1594 static asymbol
**symtab
;
1597 static const char *dll_filename
;
1598 static char *dll_symname
;
1600 #define UNDSEC (asection *) &bfd_und_section
1603 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1608 sec
= bfd_make_section_old_way (abfd
, name
);
1609 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1610 bfd_set_section_alignment (abfd
, sec
, align
);
1611 /* Remember to undo this before trying to link internally! */
1612 sec
->output_section
= sec
;
1614 sym
= bfd_make_empty_symbol (abfd
);
1615 symtab
[symptr
++] = sym
;
1616 sym
->name
= sec
->name
;
1618 sym
->flags
= BSF_LOCAL
;
1625 quick_symbol (bfd
*abfd
,
1634 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1639 sym
= bfd_make_empty_symbol (abfd
);
1644 symtab
[symptr
++] = sym
;
1647 static arelent
*reltab
= 0;
1648 static int relcount
= 0, relsize
= 0;
1651 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1653 if (relcount
>= relsize
- 1)
1657 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1659 reltab
= xmalloc (relsize
* sizeof (arelent
));
1661 reltab
[relcount
].address
= address
;
1662 reltab
[relcount
].addend
= 0;
1663 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1664 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1669 save_relocs (asection
*sec
)
1673 sec
->relocation
= reltab
;
1674 sec
->reloc_count
= relcount
;
1675 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1676 for (i
= 0; i
< relcount
; i
++)
1677 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1678 sec
->orelocation
[relcount
] = 0;
1679 sec
->flags
|= SEC_RELOC
;
1681 relcount
= relsize
= 0;
1684 /* .section .idata$2
1685 .global __head_my_dll
1702 make_head (bfd
*parent
)
1704 asection
*id2
, *id5
, *id4
;
1705 unsigned char *d2
, *d5
, *d4
;
1709 oname
= xmalloc (20);
1710 sprintf (oname
, "d%06d.o", tmp_seq
);
1713 abfd
= bfd_create (oname
, parent
);
1714 bfd_find_target (pe_details
->object_target
, abfd
);
1715 bfd_make_writable (abfd
);
1717 bfd_set_format (abfd
, bfd_object
);
1718 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1721 symtab
= xmalloc (6 * sizeof (asymbol
*));
1722 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1723 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1724 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1725 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1726 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1728 /* OK, pay attention here. I got confused myself looking back at
1729 it. We create a four-byte section to mark the beginning of the
1730 list, and we include an offset of 4 in the section, so that the
1731 pointer to the list points to the *end* of this section, which is
1732 the start of the list of sections from other objects. */
1734 bfd_set_section_size (abfd
, id2
, 20);
1738 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
1739 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1740 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1741 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1744 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1745 d5
= xmalloc (PE_IDATA5_SIZE
);
1747 memset (d5
, 0, PE_IDATA5_SIZE
);
1749 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1750 d4
= xmalloc (PE_IDATA4_SIZE
);
1752 memset (d4
, 0, PE_IDATA4_SIZE
);
1754 bfd_set_symtab (abfd
, symtab
, symptr
);
1756 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1757 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1758 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1760 bfd_make_readable (abfd
);
1764 /* .section .idata$4
1771 .global __my_dll_iname
1776 make_tail (bfd
*parent
)
1778 asection
*id4
, *id5
, *id7
;
1779 unsigned char *d4
, *d5
, *d7
;
1784 oname
= xmalloc (20);
1785 sprintf (oname
, "d%06d.o", tmp_seq
);
1788 abfd
= bfd_create (oname
, parent
);
1789 bfd_find_target (pe_details
->object_target
, abfd
);
1790 bfd_make_writable (abfd
);
1792 bfd_set_format (abfd
, bfd_object
);
1793 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1796 symtab
= xmalloc (5 * sizeof (asymbol
*));
1797 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1798 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1799 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1800 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1802 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1803 d4
= xmalloc (PE_IDATA4_SIZE
);
1805 memset (d4
, 0, PE_IDATA4_SIZE
);
1807 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1808 d5
= xmalloc (PE_IDATA5_SIZE
);
1810 memset (d5
, 0, PE_IDATA5_SIZE
);
1812 len
= strlen (dll_filename
) + 1;
1815 bfd_set_section_size (abfd
, id7
, len
);
1818 strcpy ((char *) d7
, dll_filename
);
1819 /* If len was odd, the above
1820 strcpy leaves behind an undefined byte. That is harmless,
1821 but we set it to 0 just so the binary dumps are pretty. */
1824 bfd_set_symtab (abfd
, symtab
, symptr
);
1826 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1827 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1828 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1830 bfd_make_readable (abfd
);
1836 .global ___imp_function
1837 .global __imp__function
1839 jmp *__imp__function:
1853 .asciz "function" xlate? (add underscore, kill at) */
1855 static const unsigned char jmp_ix86_bytes
[] =
1857 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1865 .dw __imp_function */
1867 static const unsigned char jmp_sh_bytes
[] =
1869 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1873 lui $t0,<high:__imp_function>
1874 lw $t0,<low:__imp_function>
1878 static const unsigned char jmp_mips_bytes
[] =
1880 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1881 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1884 static const unsigned char jmp_arm_bytes
[] =
1886 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1887 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1893 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
1895 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1896 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1900 const unsigned char *jmp_bytes
= NULL
;
1901 int jmp_byte_count
= 0;
1903 /* Include the jump stub section only if it is needed. A jump
1904 stub is needed if the symbol being imported <sym> is a function
1905 symbol and there is at least one undefined reference to that
1906 symbol. In other words, if all the import references to <sym> are
1907 explicitly through _declspec(dllimport) then the jump stub is not
1909 if (include_jmp_stub
)
1911 switch (pe_details
->pe_arch
)
1914 jmp_bytes
= jmp_ix86_bytes
;
1915 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1918 jmp_bytes
= jmp_sh_bytes
;
1919 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1922 jmp_bytes
= jmp_mips_bytes
;
1923 jmp_byte_count
= sizeof (jmp_mips_bytes
);
1926 case PE_ARCH_arm_epoc
:
1927 case PE_ARCH_arm_wince
:
1928 jmp_bytes
= jmp_arm_bytes
;
1929 jmp_byte_count
= sizeof (jmp_arm_bytes
);
1936 oname
= xmalloc (20);
1937 sprintf (oname
, "d%06d.o", tmp_seq
);
1940 abfd
= bfd_create (oname
, parent
);
1941 bfd_find_target (pe_details
->object_target
, abfd
);
1942 bfd_make_writable (abfd
);
1944 bfd_set_format (abfd
, bfd_object
);
1945 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1948 symtab
= xmalloc (11 * sizeof (asymbol
*));
1949 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1950 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1951 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1952 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1953 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1955 if (*exp
->internal_name
== '@')
1957 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1959 if (include_jmp_stub
)
1960 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1961 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
1963 /* Fastcall applies only to functions,
1964 so no need for auto-import symbol. */
1968 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1970 if (include_jmp_stub
)
1971 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
1973 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
1975 /* Symbol to reference ord/name of imported
1976 data symbol, used to implement auto-import. */
1978 quick_symbol (abfd
, U ("_nm_"), U (""), exp
->internal_name
, id6
,
1981 if (pe_dll_compat_implib
)
1982 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "", id5
,
1985 if (include_jmp_stub
)
1987 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
1988 td
= xmalloc (jmp_byte_count
);
1990 memcpy (td
, jmp_bytes
, jmp_byte_count
);
1992 switch (pe_details
->pe_arch
)
1995 #ifdef pe_use_x86_64
1996 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
1998 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2002 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2005 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2006 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2007 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2010 case PE_ARCH_arm_epoc
:
2011 case PE_ARCH_arm_wince
:
2012 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2020 bfd_set_section_size (abfd
, tx
, 0);
2022 bfd_set_section_size (abfd
, id7
, 4);
2026 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2029 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2030 d5
= xmalloc (PE_IDATA5_SIZE
);
2032 memset (d5
, 0, PE_IDATA5_SIZE
);
2034 if (exp
->flag_noname
)
2036 d5
[0] = exp
->ordinal
;
2037 d5
[1] = exp
->ordinal
>> 8;
2038 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2042 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2046 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2047 d4
= xmalloc (PE_IDATA4_SIZE
);
2049 memset (d4
, 0, PE_IDATA4_SIZE
);
2051 if (exp
->flag_noname
)
2053 d4
[0] = exp
->ordinal
;
2054 d4
[1] = exp
->ordinal
>> 8;
2055 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2059 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2063 if (exp
->flag_noname
)
2066 bfd_set_section_size (abfd
, id6
, 0);
2070 /* { short, asciz } */
2071 len
= 2 + strlen (exp
->name
) + 1;
2074 bfd_set_section_size (abfd
, id6
, len
);
2077 memset (d6
, 0, len
);
2078 d6
[0] = exp
->hint
& 0xff;
2079 d6
[1] = exp
->hint
>> 8;
2080 strcpy ((char *) d6
+ 2, exp
->name
);
2083 bfd_set_symtab (abfd
, symtab
, symptr
);
2085 if (include_jmp_stub
)
2086 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2087 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2088 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2089 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2090 if (!exp
->flag_noname
)
2091 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2093 bfd_make_readable (abfd
);
2098 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2100 /* Name thunks go to idata$4. */
2106 oname
= xmalloc (20);
2107 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2110 abfd
= bfd_create (oname
, parent
);
2111 bfd_find_target (pe_details
->object_target
, abfd
);
2112 bfd_make_writable (abfd
);
2114 bfd_set_format (abfd
, bfd_object
);
2115 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2118 symtab
= xmalloc (3 * sizeof (asymbol
*));
2119 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2120 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
2121 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2123 /* We need space for the real thunk and for the null terminator. */
2124 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2125 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2127 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2128 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2131 bfd_set_symtab (abfd
, symtab
, symptr
);
2133 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2135 bfd_make_readable (abfd
);
2140 make_import_fixup_mark (arelent
*rel
)
2142 /* We convert reloc to symbol, for later reference. */
2144 static char *fixup_name
= NULL
;
2145 static size_t buffer_len
= 0;
2147 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2149 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2150 struct bfd_link_hash_entry
*bh
;
2154 fixup_name
= xmalloc (384);
2158 if (strlen (sym
->name
) + 25 > buffer_len
)
2159 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2160 bigger than 20 digits long, we've got worse problems than
2161 overflowing this buffer... */
2164 /* New buffer size is length of symbol, plus 25, but
2165 then rounded up to the nearest multiple of 128. */
2166 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2167 fixup_name
= xmalloc (buffer_len
);
2170 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2173 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2174 current_sec
, /* sym->section, */
2175 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2180 /* .section .idata$2
2181 .rva __nm_thnk_SYM (singleton thunk with name of func)
2184 .rva __my_dll_iname (name of dll)
2185 .rva __fuNN_SYM (pointer to reference (address) in text) */
2188 make_import_fixup_entry (const char *name
,
2189 const char *fixup_name
,
2190 const char *dll_symname
,
2198 oname
= xmalloc (20);
2199 sprintf (oname
, "fu%06d.o", tmp_seq
);
2202 abfd
= bfd_create (oname
, parent
);
2203 bfd_find_target (pe_details
->object_target
, abfd
);
2204 bfd_make_writable (abfd
);
2206 bfd_set_format (abfd
, bfd_object
);
2207 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2210 symtab
= xmalloc (6 * sizeof (asymbol
*));
2211 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2213 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2214 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2215 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2217 bfd_set_section_size (abfd
, id2
, 20);
2222 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2223 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2224 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2227 bfd_set_symtab (abfd
, symtab
, symptr
);
2229 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2231 bfd_make_readable (abfd
);
2235 /* .section .rdata_runtime_pseudo_reloc
2237 .rva __fuNN_SYM (pointer to reference (address) in text) */
2240 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2241 const char *fixup_name
,
2246 unsigned char *rt_rel_d
;
2250 oname
= xmalloc (20);
2251 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2254 abfd
= bfd_create (oname
, parent
);
2255 bfd_find_target (pe_details
->object_target
, abfd
);
2256 bfd_make_writable (abfd
);
2258 bfd_set_format (abfd
, bfd_object
);
2259 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2262 symtab
= xmalloc (2 * sizeof (asymbol
*));
2263 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2264 SEC_HAS_CONTENTS
, 2);
2266 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2268 bfd_set_section_size (abfd
, rt_rel
, 8);
2269 rt_rel_d
= xmalloc (8);
2270 rt_rel
->contents
= rt_rel_d
;
2271 memset (rt_rel_d
, 0, 8);
2272 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2274 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2275 save_relocs (rt_rel
);
2277 bfd_set_symtab (abfd
, symtab
, symptr
);
2279 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2281 bfd_make_readable (abfd
);
2286 .rva __pei386_runtime_relocator */
2289 pe_create_runtime_relocator_reference (bfd
*parent
)
2291 asection
*extern_rt_rel
;
2292 unsigned char *extern_rt_rel_d
;
2296 oname
= xmalloc (20);
2297 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2300 abfd
= bfd_create (oname
, parent
);
2301 bfd_find_target (pe_details
->object_target
, abfd
);
2302 bfd_make_writable (abfd
);
2304 bfd_set_format (abfd
, bfd_object
);
2305 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2308 symtab
= xmalloc (2 * sizeof (asymbol
*));
2309 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2311 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2314 bfd_set_section_size (abfd
, extern_rt_rel
, 4);
2315 extern_rt_rel_d
= xmalloc (4);
2316 extern_rt_rel
->contents
= extern_rt_rel_d
;
2318 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2319 save_relocs (extern_rt_rel
);
2321 bfd_set_symtab (abfd
, symtab
, symptr
);
2323 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, 4);
2325 bfd_make_readable (abfd
);
2330 pe_create_import_fixup (arelent
*rel
, asection
*s
, int addend
)
2333 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2334 struct bfd_link_hash_entry
*name_thunk_sym
;
2335 const char *name
= sym
->name
;
2336 char *fixup_name
= make_import_fixup_mark (rel
);
2339 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2341 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2343 if (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
)
2345 bfd
*b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2346 add_bfd_to_link (b
, b
->filename
, &link_info
);
2348 /* If we ever use autoimport, we have to cast text section writable. */
2349 config
.text_read_only
= FALSE
;
2350 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2353 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2355 extern char * pe_data_import_dll
;
2356 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2358 b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
,
2359 link_info
.output_bfd
);
2360 add_bfd_to_link (b
, b
->filename
, &link_info
);
2365 if (link_info
.pei386_runtime_pseudo_reloc
)
2367 if (pe_dll_extra_pe_debug
)
2368 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2369 fixup_name
, addend
);
2370 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
,
2371 link_info
.output_bfd
);
2372 add_bfd_to_link (b
, b
->filename
, &link_info
);
2374 if (runtime_pseudo_relocs_created
== 0)
2376 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2377 add_bfd_to_link (b
, b
->filename
, &link_info
);
2379 runtime_pseudo_relocs_created
++;
2383 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2384 s
->owner
, s
, rel
->address
, sym
->name
);
2392 pe_dll_generate_implib (def_file
*def
, const char *impfilename
)
2400 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2401 dll_symname
= xstrdup (dll_filename
);
2402 for (i
= 0; dll_symname
[i
]; i
++)
2403 if (!ISALNUM (dll_symname
[i
]))
2404 dll_symname
[i
] = '_';
2406 unlink_if_ordinary (impfilename
);
2408 outarch
= bfd_openw (impfilename
, 0);
2412 /* xgettext:c-format */
2413 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2417 /* xgettext:c-format */
2418 info_msg (_("Creating library file: %s\n"), impfilename
);
2420 bfd_set_format (outarch
, bfd_archive
);
2421 outarch
->has_armap
= 1;
2423 /* Work out a reasonable size of things to put onto one line. */
2424 ar_head
= make_head (outarch
);
2426 for (i
= 0; i
< def
->num_exports
; i
++)
2428 /* The import library doesn't know about the internal name. */
2429 char *internal
= def
->exports
[i
].internal_name
;
2432 /* Don't add PRIVATE entries to import lib. */
2433 if (pe_def_file
->exports
[i
].flag_private
)
2435 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2436 n
= make_one (def
->exports
+ i
, outarch
,
2437 ! (def
->exports
+ i
)->flag_data
);
2438 n
->archive_next
= head
;
2440 def
->exports
[i
].internal_name
= internal
;
2443 ar_tail
= make_tail (outarch
);
2445 if (ar_head
== NULL
|| ar_tail
== NULL
)
2448 /* Now stick them all into the archive. */
2449 ar_head
->archive_next
= head
;
2450 ar_tail
->archive_next
= ar_head
;
2453 if (! bfd_set_archive_head (outarch
, head
))
2454 einfo ("%Xbfd_set_archive_head: %E\n");
2456 if (! bfd_close (outarch
))
2457 einfo ("%Xbfd_close %s: %E\n", impfilename
);
2459 while (head
!= NULL
)
2461 bfd
*n
= head
->archive_next
;
2468 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*link_info
)
2470 lang_input_statement_type
*fake_file
;
2472 fake_file
= lang_add_input_file (name
,
2473 lang_input_file_is_fake_enum
,
2475 fake_file
->the_bfd
= abfd
;
2476 ldlang_add_file (fake_file
);
2478 if (!bfd_link_add_symbols (abfd
, link_info
))
2479 einfo ("%Xaddsym %s: %E\n", name
);
2483 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*link_info
)
2485 def_file_module
*module
;
2487 pe_dll_id_target (bfd_get_target (output_bfd
));
2492 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2496 dll_filename
= module
->name
;
2497 dll_symname
= xstrdup (module
->name
);
2498 for (i
= 0; dll_symname
[i
]; i
++)
2499 if (!ISALNUM (dll_symname
[i
]))
2500 dll_symname
[i
] = '_';
2504 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2505 if (pe_def_file
->imports
[i
].module
== module
)
2507 def_file_export exp
;
2508 struct bfd_link_hash_entry
*blhe
;
2509 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2510 /* See if we need this import. */
2511 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2512 char *name
= xmalloc (len
+ 2 + 6);
2513 bfd_boolean include_jmp_stub
= FALSE
;
2516 sprintf (name
, "%s",
2517 pe_def_file
->imports
[i
].internal_name
);
2519 sprintf (name
, "%s%s",U (""),
2520 pe_def_file
->imports
[i
].internal_name
);
2522 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2523 FALSE
, FALSE
, FALSE
);
2525 /* Include the jump stub for <sym> only if the <sym>
2527 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2530 sprintf (name
, "%s%s", "__imp_",
2531 pe_def_file
->imports
[i
].internal_name
);
2533 sprintf (name
, "%s%s%s", "__imp_", U (""),
2534 pe_def_file
->imports
[i
].internal_name
);
2536 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2537 FALSE
, FALSE
, FALSE
);
2540 include_jmp_stub
= TRUE
;
2544 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2550 bfd
*ar_head
= make_head (output_bfd
);
2551 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2554 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2555 exp
.name
= pe_def_file
->imports
[i
].name
;
2556 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2557 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2558 exp
.flag_private
= 0;
2559 exp
.flag_constant
= 0;
2560 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2561 exp
.flag_noname
= exp
.name
? 0 : 1;
2562 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
2563 add_bfd_to_link (one
, one
->filename
, link_info
);
2568 bfd
*ar_tail
= make_tail (output_bfd
);
2569 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2576 /* We were handed a *.DLL file. Parse it and turn it into a set of
2577 IMPORTS directives in the def file. Return TRUE if the file was
2578 handled, FALSE if not. */
2581 pe_get16 (bfd
*abfd
, int where
)
2585 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2586 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2587 return b
[0] + (b
[1] << 8);
2591 pe_get32 (bfd
*abfd
, int where
)
2595 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2596 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2597 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2603 unsigned char *b
= ptr
;
2605 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2609 pe_implied_import_dll (const char *filename
)
2612 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2613 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
2614 bfd_vma exp_funcbase
;
2615 unsigned char *expdata
;
2617 bfd_vma name_rvas
, ordinals
, nexp
, ordbase
;
2618 const char *dll_name
;
2619 /* Initialization with start > end guarantees that is_data
2620 will not be set by mistake, and avoids compiler warning. */
2621 bfd_vma data_start
= 1;
2622 bfd_vma data_end
= 0;
2623 bfd_vma rdata_start
= 1;
2624 bfd_vma rdata_end
= 0;
2625 bfd_vma bss_start
= 1;
2626 bfd_vma bss_end
= 0;
2628 /* No, I can't use bfd here. kernel32.dll puts its export table in
2629 the middle of the .rdata section. */
2630 dll
= bfd_openr (filename
, pe_details
->target_name
);
2633 einfo ("%Xopen %s: %E\n", filename
);
2637 /* PEI dlls seem to be bfd_objects. */
2638 if (!bfd_check_format (dll
, bfd_object
))
2640 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2644 /* Get pe_header, optional header and numbers of export entries. */
2645 pe_header_offset
= pe_get32 (dll
, 0x3c);
2646 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2647 #ifdef pe_use_x86_64
2648 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2650 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2653 if (num_entries
< 1) /* No exports. */
2656 #ifdef pe_use_x86_64
2657 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
2658 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
2660 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2661 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2664 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2665 secptr
= (pe_header_offset
+ 4 + 20 +
2666 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2669 /* Get the rva and size of the export section. */
2670 for (i
= 0; i
< nsections
; i
++)
2673 bfd_vma secptr1
= secptr
+ 40 * i
;
2674 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2675 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
2676 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
2678 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2679 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2681 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2683 expptr
= fptr
+ (export_rva
- vaddr
);
2684 if (export_rva
+ export_size
> vaddr
+ vsize
)
2685 export_size
= vsize
- (export_rva
- vaddr
);
2690 /* Scan sections and store the base and size of the
2691 data and bss segments in data/base_start/end. */
2692 for (i
= 0; i
< nsections
; i
++)
2694 bfd_vma secptr1
= secptr
+ 40 * i
;
2695 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
2696 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2697 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
2701 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
2702 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
2704 if (strcmp(sec_name
,".data") == 0)
2707 data_end
= vaddr
+ vsize
;
2709 if (pe_dll_extra_pe_debug
)
2710 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2711 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2712 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2714 else if (strcmp(sec_name
,".rdata") == 0)
2716 rdata_start
= vaddr
;
2717 rdata_end
= vaddr
+ vsize
;
2719 if (pe_dll_extra_pe_debug
)
2720 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2721 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2722 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2724 else if (strcmp (sec_name
,".bss") == 0)
2727 bss_end
= vaddr
+ vsize
;
2729 if (pe_dll_extra_pe_debug
)
2730 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2731 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2732 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2736 expdata
= xmalloc (export_size
);
2737 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2738 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2739 erva
= (char *) expdata
- export_rva
;
2741 if (pe_def_file
== 0)
2742 pe_def_file
= def_file_empty ();
2744 nexp
= pe_as32 (expdata
+ 24);
2745 name_rvas
= pe_as32 (expdata
+ 32);
2746 ordinals
= pe_as32 (expdata
+ 36);
2747 ordbase
= pe_as32 (expdata
+ 16);
2748 exp_funcbase
= pe_as32 (expdata
+ 28);
2750 /* Use internal dll name instead of filename
2751 to enable symbolic dll linking. */
2752 dll_name
= erva
+ pe_as32 (expdata
+ 12);
2754 /* Check to see if the dll has already been added to
2755 the definition list and if so return without error.
2756 This avoids multiple symbol definitions. */
2757 if (def_get_module (pe_def_file
, dll_name
))
2759 if (pe_dll_extra_pe_debug
)
2760 printf ("%s is already loaded\n", dll_name
);
2764 /* Iterate through the list of symbols. */
2765 for (i
= 0; i
< nexp
; i
++)
2767 /* Pointer to the names vector. */
2768 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
2769 def_file_import
*imp
;
2770 /* Pointer to the function address vector. */
2771 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
2774 /* Skip unwanted symbols, which are
2775 exported in buggy auto-import releases. */
2776 if (! CONST_STRNEQ (erva
+ name_rva
, "_nm_"))
2778 /* is_data is true if the address is in the data, rdata or bss
2781 (func_rva
>= data_start
&& func_rva
< data_end
)
2782 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
2783 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
2785 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
2787 /* Mark symbol type. */
2788 imp
->data
= is_data
;
2790 if (pe_dll_extra_pe_debug
)
2791 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2792 __FUNCTION__
, dll_name
, erva
+ name_rva
,
2793 (unsigned long) func_rva
, is_data
? "(data)" : "");
2800 /* These are the main functions, called from the emulation. The first
2801 is called after the bfds are read, so we can guess at how much space
2802 we need. The second is called after everything is placed, so we
2803 can put the right values in place. */
2806 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2808 pe_dll_id_target (bfd_get_target (abfd
));
2809 process_def_file (abfd
, info
);
2811 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
2814 generate_edata (abfd
, info
);
2815 build_filler_bfd (1);
2819 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2821 pe_dll_id_target (bfd_get_target (abfd
));
2822 build_filler_bfd (0);
2826 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2828 pe_dll_id_target (bfd_get_target (abfd
));
2829 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2831 generate_reloc (abfd
, info
);
2834 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2836 /* Resize the sections. */
2837 lang_reset_memory_regions ();
2838 lang_size_sections (NULL
, TRUE
);
2840 /* Redo special stuff. */
2841 ldemul_after_allocation ();
2843 /* Do the assignments again. */
2844 lang_do_assignments ();
2847 fill_edata (abfd
, info
);
2849 if (info
->shared
&& !info
->pie
)
2850 pe_data (abfd
)->dll
= 1;
2852 edata_s
->contents
= edata_d
;
2853 reloc_s
->contents
= reloc_d
;
2857 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2859 pe_dll_id_target (bfd_get_target (abfd
));
2860 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2862 generate_reloc (abfd
, info
);
2865 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2867 /* Resize the sections. */
2868 lang_reset_memory_regions ();
2869 lang_size_sections (NULL
, TRUE
);
2871 /* Redo special stuff. */
2872 ldemul_after_allocation ();
2874 /* Do the assignments again. */
2875 lang_do_assignments ();
2877 reloc_s
->contents
= reloc_d
;
2881 pe_bfd_is_dll (bfd
*abfd
)
2883 return (bfd_get_format (abfd
) == bfd_object
2885 && pe_data (abfd
)->dll
);