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 /* Don't create relocs for undefined weak symbols. */
1260 if (sym
->flags
== BSF_WEAK
)
1262 struct bfd_link_hash_entry
*blhe
1263 = bfd_link_hash_lookup (info
->hash
, sym
->name
,
1264 FALSE
, FALSE
, FALSE
);
1265 if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1269 sym_vma
= (relocs
[i
]->addend
1272 + sym
->section
->output_offset
1273 + sym
->section
->output_section
->vma
);
1274 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1276 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1278 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1279 relocs
[i
]->howto
->rightshift
)
1281 #ifdef pe_use_x86_64
1282 case BITS_AND_SHIFT (64, 0):
1283 reloc_data
[total_relocs
].type
= 10;
1287 case BITS_AND_SHIFT (32, 0):
1288 reloc_data
[total_relocs
].type
= 3;
1291 case BITS_AND_SHIFT (16, 0):
1292 reloc_data
[total_relocs
].type
= 2;
1295 case BITS_AND_SHIFT (16, 16):
1296 reloc_data
[total_relocs
].type
= 4;
1297 /* FIXME: we can't know the symbol's right value
1298 yet, but we probably can safely assume that
1299 CE will relocate us in 64k blocks, so leaving
1301 reloc_data
[total_relocs
].extra
= 0;
1304 case BITS_AND_SHIFT (26, 2):
1305 reloc_data
[total_relocs
].type
= 5;
1308 case BITS_AND_SHIFT (24, 2):
1309 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1310 Those ARM_xxx definitions should go in proper
1312 if (relocs
[i
]->howto
->type
== 0
1313 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1314 || relocs
[i
]->howto
->type
== 5)
1315 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1316 that has already been fully processed during a
1317 previous link stage, so ignore it here. */
1321 /* xgettext:c-format */
1322 einfo (_("%XError: %d-bit reloc in dll\n"),
1323 relocs
[i
]->howto
->bitsize
);
1329 /* Warning: the allocated symbols are remembered in BFD and
1330 reused later, so don't free them! */
1334 /* At this point, we have total_relocs relocation addresses in
1335 reloc_addresses, which are all suitable for the .reloc section.
1336 We must now create the new sections. */
1337 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1339 for (i
= 0; i
< total_relocs
; i
++)
1341 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1343 if (this_page
!= sec_page
)
1345 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1347 sec_page
= this_page
;
1352 if (reloc_data
[i
].type
== 4)
1356 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1357 reloc_d
= xmalloc (reloc_sz
);
1358 sec_page
= (bfd_vma
) -1;
1360 page_ptr
= (bfd_vma
) -1;
1363 for (i
= 0; i
< total_relocs
; i
++)
1365 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1366 bfd_vma this_page
= (rva
& ~0xfff);
1368 if (this_page
!= sec_page
)
1370 while (reloc_sz
& 3)
1371 reloc_d
[reloc_sz
++] = 0;
1373 if (page_ptr
!= (bfd_vma
) -1)
1374 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1376 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1377 page_ptr
= reloc_sz
;
1379 sec_page
= this_page
;
1383 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1384 reloc_d
+ reloc_sz
);
1387 if (reloc_data
[i
].type
== 4)
1389 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1396 while (reloc_sz
& 3)
1397 reloc_d
[reloc_sz
++] = 0;
1399 if (page_ptr
!= (bfd_vma
) -1)
1400 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1402 while (reloc_sz
< reloc_s
->size
)
1403 reloc_d
[reloc_sz
++] = 0;
1406 /* Given the exiting def_file structure, print out a .DEF file that
1407 corresponds to it. */
1410 quoteput (char *s
, FILE *f
, int needs_quotes
)
1414 for (cp
= s
; *cp
; cp
++)
1429 if (*s
== '"' || *s
== '\\')
1443 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1446 FILE *out
= fopen (pe_out_def_filename
, "w");
1449 /* xgettext:c-format */
1450 einfo (_("%s: Can't open output def file %s\n"),
1451 program_name
, pe_out_def_filename
);
1455 if (pe_def_file
->name
)
1457 if (pe_def_file
->is_dll
)
1458 fprintf (out
, "LIBRARY ");
1460 fprintf (out
, "NAME ");
1462 quoteput (pe_def_file
->name
, out
, 1);
1464 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1466 fprintf (out
, " BASE=0x");
1467 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1469 fprintf (out
, "\n");
1472 if (pe_def_file
->description
)
1474 fprintf (out
, "DESCRIPTION ");
1475 quoteput (pe_def_file
->description
, out
, 1);
1476 fprintf (out
, "\n");
1479 if (pe_def_file
->version_minor
!= -1)
1480 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1481 pe_def_file
->version_minor
);
1482 else if (pe_def_file
->version_major
!= -1)
1483 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1485 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1486 fprintf (out
, "\n");
1488 if (pe_def_file
->stack_commit
!= -1)
1489 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1490 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1491 else if (pe_def_file
->stack_reserve
!= -1)
1492 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1494 if (pe_def_file
->heap_commit
!= -1)
1495 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1496 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1497 else if (pe_def_file
->heap_reserve
!= -1)
1498 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1500 if (pe_def_file
->num_section_defs
> 0)
1502 fprintf (out
, "\nSECTIONS\n\n");
1504 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1507 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1509 if (pe_def_file
->section_defs
[i
].class)
1511 fprintf (out
, " CLASS ");
1512 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1515 if (pe_def_file
->section_defs
[i
].flag_read
)
1516 fprintf (out
, " READ");
1518 if (pe_def_file
->section_defs
[i
].flag_write
)
1519 fprintf (out
, " WRITE");
1521 if (pe_def_file
->section_defs
[i
].flag_execute
)
1522 fprintf (out
, " EXECUTE");
1524 if (pe_def_file
->section_defs
[i
].flag_shared
)
1525 fprintf (out
, " SHARED");
1527 fprintf (out
, "\n");
1531 if (pe_def_file
->num_exports
> 0)
1533 fprintf (out
, "EXPORTS\n");
1535 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1537 def_file_export
*e
= pe_def_file
->exports
+ i
;
1539 quoteput (e
->name
, out
, 0);
1541 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1543 fprintf (out
, " = ");
1544 quoteput (e
->internal_name
, out
, 0);
1547 if (e
->ordinal
!= -1)
1548 fprintf (out
, " @%d", e
->ordinal
);
1550 if (e
->flag_private
)
1551 fprintf (out
, " PRIVATE");
1553 if (e
->flag_constant
)
1554 fprintf (out
, " CONSTANT");
1557 fprintf (out
, " NONAME");
1560 fprintf (out
, " DATA");
1562 fprintf (out
, "\n");
1566 if (pe_def_file
->num_imports
> 0)
1568 fprintf (out
, "\nIMPORTS\n\n");
1570 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1572 def_file_import
*im
= pe_def_file
->imports
+ i
;
1575 if (im
->internal_name
1576 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1578 quoteput (im
->internal_name
, out
, 0);
1579 fprintf (out
, " = ");
1582 quoteput (im
->module
->name
, out
, 0);
1586 quoteput (im
->name
, out
, 0);
1588 fprintf (out
, "%d", im
->ordinal
);
1590 fprintf (out
, "\n");
1595 fprintf (out
, _("; no contents available\n"));
1597 if (fclose (out
) == EOF
)
1598 /* xgettext:c-format */
1599 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1602 /* Generate the import library. */
1604 static asymbol
**symtab
;
1607 static const char *dll_filename
;
1608 static char *dll_symname
;
1610 #define UNDSEC (asection *) &bfd_und_section
1613 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1618 sec
= bfd_make_section_old_way (abfd
, name
);
1619 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1620 bfd_set_section_alignment (abfd
, sec
, align
);
1621 /* Remember to undo this before trying to link internally! */
1622 sec
->output_section
= sec
;
1624 sym
= bfd_make_empty_symbol (abfd
);
1625 symtab
[symptr
++] = sym
;
1626 sym
->name
= sec
->name
;
1628 sym
->flags
= BSF_LOCAL
;
1635 quick_symbol (bfd
*abfd
,
1644 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1649 sym
= bfd_make_empty_symbol (abfd
);
1654 symtab
[symptr
++] = sym
;
1657 static arelent
*reltab
= 0;
1658 static int relcount
= 0, relsize
= 0;
1661 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1663 if (relcount
>= relsize
- 1)
1667 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1669 reltab
= xmalloc (relsize
* sizeof (arelent
));
1671 reltab
[relcount
].address
= address
;
1672 reltab
[relcount
].addend
= 0;
1673 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1674 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1679 save_relocs (asection
*sec
)
1683 sec
->relocation
= reltab
;
1684 sec
->reloc_count
= relcount
;
1685 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1686 for (i
= 0; i
< relcount
; i
++)
1687 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1688 sec
->orelocation
[relcount
] = 0;
1689 sec
->flags
|= SEC_RELOC
;
1691 relcount
= relsize
= 0;
1694 /* .section .idata$2
1695 .global __head_my_dll
1712 make_head (bfd
*parent
)
1714 asection
*id2
, *id5
, *id4
;
1715 unsigned char *d2
, *d5
, *d4
;
1719 oname
= xmalloc (20);
1720 sprintf (oname
, "d%06d.o", tmp_seq
);
1723 abfd
= bfd_create (oname
, parent
);
1724 bfd_find_target (pe_details
->object_target
, abfd
);
1725 bfd_make_writable (abfd
);
1727 bfd_set_format (abfd
, bfd_object
);
1728 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1731 symtab
= xmalloc (6 * sizeof (asymbol
*));
1732 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1733 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1734 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1735 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1736 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1738 /* OK, pay attention here. I got confused myself looking back at
1739 it. We create a four-byte section to mark the beginning of the
1740 list, and we include an offset of 4 in the section, so that the
1741 pointer to the list points to the *end* of this section, which is
1742 the start of the list of sections from other objects. */
1744 bfd_set_section_size (abfd
, id2
, 20);
1748 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
1749 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1750 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1751 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1754 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1755 d5
= xmalloc (PE_IDATA5_SIZE
);
1757 memset (d5
, 0, PE_IDATA5_SIZE
);
1759 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1760 d4
= xmalloc (PE_IDATA4_SIZE
);
1762 memset (d4
, 0, PE_IDATA4_SIZE
);
1764 bfd_set_symtab (abfd
, symtab
, symptr
);
1766 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1767 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1768 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1770 bfd_make_readable (abfd
);
1774 /* .section .idata$4
1781 .global __my_dll_iname
1786 make_tail (bfd
*parent
)
1788 asection
*id4
, *id5
, *id7
;
1789 unsigned char *d4
, *d5
, *d7
;
1794 oname
= xmalloc (20);
1795 sprintf (oname
, "d%06d.o", tmp_seq
);
1798 abfd
= bfd_create (oname
, parent
);
1799 bfd_find_target (pe_details
->object_target
, abfd
);
1800 bfd_make_writable (abfd
);
1802 bfd_set_format (abfd
, bfd_object
);
1803 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1806 symtab
= xmalloc (5 * sizeof (asymbol
*));
1807 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1808 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1809 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1810 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1812 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1813 d4
= xmalloc (PE_IDATA4_SIZE
);
1815 memset (d4
, 0, PE_IDATA4_SIZE
);
1817 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1818 d5
= xmalloc (PE_IDATA5_SIZE
);
1820 memset (d5
, 0, PE_IDATA5_SIZE
);
1822 len
= strlen (dll_filename
) + 1;
1825 bfd_set_section_size (abfd
, id7
, len
);
1828 strcpy ((char *) d7
, dll_filename
);
1829 /* If len was odd, the above
1830 strcpy leaves behind an undefined byte. That is harmless,
1831 but we set it to 0 just so the binary dumps are pretty. */
1834 bfd_set_symtab (abfd
, symtab
, symptr
);
1836 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1837 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1838 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1840 bfd_make_readable (abfd
);
1846 .global ___imp_function
1847 .global __imp__function
1849 jmp *__imp__function:
1863 .asciz "function" xlate? (add underscore, kill at) */
1865 static const unsigned char jmp_ix86_bytes
[] =
1867 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1875 .dw __imp_function */
1877 static const unsigned char jmp_sh_bytes
[] =
1879 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1883 lui $t0,<high:__imp_function>
1884 lw $t0,<low:__imp_function>
1888 static const unsigned char jmp_mips_bytes
[] =
1890 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1891 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1894 static const unsigned char jmp_arm_bytes
[] =
1896 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1897 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1903 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
1905 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1906 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1910 const unsigned char *jmp_bytes
= NULL
;
1911 int jmp_byte_count
= 0;
1913 /* Include the jump stub section only if it is needed. A jump
1914 stub is needed if the symbol being imported <sym> is a function
1915 symbol and there is at least one undefined reference to that
1916 symbol. In other words, if all the import references to <sym> are
1917 explicitly through _declspec(dllimport) then the jump stub is not
1919 if (include_jmp_stub
)
1921 switch (pe_details
->pe_arch
)
1924 jmp_bytes
= jmp_ix86_bytes
;
1925 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1928 jmp_bytes
= jmp_sh_bytes
;
1929 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1932 jmp_bytes
= jmp_mips_bytes
;
1933 jmp_byte_count
= sizeof (jmp_mips_bytes
);
1936 case PE_ARCH_arm_epoc
:
1937 case PE_ARCH_arm_wince
:
1938 jmp_bytes
= jmp_arm_bytes
;
1939 jmp_byte_count
= sizeof (jmp_arm_bytes
);
1946 oname
= xmalloc (20);
1947 sprintf (oname
, "d%06d.o", tmp_seq
);
1950 abfd
= bfd_create (oname
, parent
);
1951 bfd_find_target (pe_details
->object_target
, abfd
);
1952 bfd_make_writable (abfd
);
1954 bfd_set_format (abfd
, bfd_object
);
1955 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1958 symtab
= xmalloc (11 * sizeof (asymbol
*));
1959 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1960 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1961 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1962 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1963 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1965 if (*exp
->internal_name
== '@')
1967 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1969 if (include_jmp_stub
)
1970 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1971 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
1973 /* Fastcall applies only to functions,
1974 so no need for auto-import symbol. */
1978 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1980 if (include_jmp_stub
)
1981 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
1983 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
1985 /* Symbol to reference ord/name of imported
1986 data symbol, used to implement auto-import. */
1988 quick_symbol (abfd
, U ("_nm_"), U (""), exp
->internal_name
, id6
,
1991 if (pe_dll_compat_implib
)
1992 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "", id5
,
1995 if (include_jmp_stub
)
1997 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
1998 td
= xmalloc (jmp_byte_count
);
2000 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2002 switch (pe_details
->pe_arch
)
2005 #ifdef pe_use_x86_64
2006 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2008 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2012 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2015 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2016 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2017 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2020 case PE_ARCH_arm_epoc
:
2021 case PE_ARCH_arm_wince
:
2022 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2030 bfd_set_section_size (abfd
, tx
, 0);
2032 bfd_set_section_size (abfd
, id7
, 4);
2036 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2039 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2040 d5
= xmalloc (PE_IDATA5_SIZE
);
2042 memset (d5
, 0, PE_IDATA5_SIZE
);
2044 if (exp
->flag_noname
)
2046 d5
[0] = exp
->ordinal
;
2047 d5
[1] = exp
->ordinal
>> 8;
2048 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2052 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2056 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2057 d4
= xmalloc (PE_IDATA4_SIZE
);
2059 memset (d4
, 0, PE_IDATA4_SIZE
);
2061 if (exp
->flag_noname
)
2063 d4
[0] = exp
->ordinal
;
2064 d4
[1] = exp
->ordinal
>> 8;
2065 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2069 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2073 if (exp
->flag_noname
)
2076 bfd_set_section_size (abfd
, id6
, 0);
2080 /* { short, asciz } */
2081 len
= 2 + strlen (exp
->name
) + 1;
2084 bfd_set_section_size (abfd
, id6
, len
);
2087 memset (d6
, 0, len
);
2088 d6
[0] = exp
->hint
& 0xff;
2089 d6
[1] = exp
->hint
>> 8;
2090 strcpy ((char *) d6
+ 2, exp
->name
);
2093 bfd_set_symtab (abfd
, symtab
, symptr
);
2095 if (include_jmp_stub
)
2096 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2097 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2098 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2099 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2100 if (!exp
->flag_noname
)
2101 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2103 bfd_make_readable (abfd
);
2108 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2110 /* Name thunks go to idata$4. */
2116 oname
= xmalloc (20);
2117 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2120 abfd
= bfd_create (oname
, parent
);
2121 bfd_find_target (pe_details
->object_target
, abfd
);
2122 bfd_make_writable (abfd
);
2124 bfd_set_format (abfd
, bfd_object
);
2125 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2128 symtab
= xmalloc (3 * sizeof (asymbol
*));
2129 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2130 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
2131 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2133 /* We need space for the real thunk and for the null terminator. */
2134 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2135 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2137 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2138 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2141 bfd_set_symtab (abfd
, symtab
, symptr
);
2143 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2145 bfd_make_readable (abfd
);
2150 make_import_fixup_mark (arelent
*rel
)
2152 /* We convert reloc to symbol, for later reference. */
2154 static char *fixup_name
= NULL
;
2155 static size_t buffer_len
= 0;
2157 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2159 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2160 struct bfd_link_hash_entry
*bh
;
2164 fixup_name
= xmalloc (384);
2168 if (strlen (sym
->name
) + 25 > buffer_len
)
2169 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2170 bigger than 20 digits long, we've got worse problems than
2171 overflowing this buffer... */
2174 /* New buffer size is length of symbol, plus 25, but
2175 then rounded up to the nearest multiple of 128. */
2176 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2177 fixup_name
= xmalloc (buffer_len
);
2180 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2183 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2184 current_sec
, /* sym->section, */
2185 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2190 /* .section .idata$2
2191 .rva __nm_thnk_SYM (singleton thunk with name of func)
2194 .rva __my_dll_iname (name of dll)
2195 .rva __fuNN_SYM (pointer to reference (address) in text) */
2198 make_import_fixup_entry (const char *name
,
2199 const char *fixup_name
,
2200 const char *dll_symname
,
2208 oname
= xmalloc (20);
2209 sprintf (oname
, "fu%06d.o", tmp_seq
);
2212 abfd
= bfd_create (oname
, parent
);
2213 bfd_find_target (pe_details
->object_target
, abfd
);
2214 bfd_make_writable (abfd
);
2216 bfd_set_format (abfd
, bfd_object
);
2217 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2220 symtab
= xmalloc (6 * sizeof (asymbol
*));
2221 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2223 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2224 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2225 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2227 bfd_set_section_size (abfd
, id2
, 20);
2232 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2233 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2234 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2237 bfd_set_symtab (abfd
, symtab
, symptr
);
2239 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2241 bfd_make_readable (abfd
);
2245 /* .section .rdata_runtime_pseudo_reloc
2247 .rva __fuNN_SYM (pointer to reference (address) in text) */
2250 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2251 const char *fixup_name
,
2256 unsigned char *rt_rel_d
;
2260 oname
= xmalloc (20);
2261 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2264 abfd
= bfd_create (oname
, parent
);
2265 bfd_find_target (pe_details
->object_target
, abfd
);
2266 bfd_make_writable (abfd
);
2268 bfd_set_format (abfd
, bfd_object
);
2269 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2272 symtab
= xmalloc (2 * sizeof (asymbol
*));
2273 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2274 SEC_HAS_CONTENTS
, 2);
2276 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2278 bfd_set_section_size (abfd
, rt_rel
, 8);
2279 rt_rel_d
= xmalloc (8);
2280 rt_rel
->contents
= rt_rel_d
;
2281 memset (rt_rel_d
, 0, 8);
2282 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2284 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2285 save_relocs (rt_rel
);
2287 bfd_set_symtab (abfd
, symtab
, symptr
);
2289 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2291 bfd_make_readable (abfd
);
2296 .rva __pei386_runtime_relocator */
2299 pe_create_runtime_relocator_reference (bfd
*parent
)
2301 asection
*extern_rt_rel
;
2302 unsigned char *extern_rt_rel_d
;
2306 oname
= xmalloc (20);
2307 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2310 abfd
= bfd_create (oname
, parent
);
2311 bfd_find_target (pe_details
->object_target
, abfd
);
2312 bfd_make_writable (abfd
);
2314 bfd_set_format (abfd
, bfd_object
);
2315 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2318 symtab
= xmalloc (2 * sizeof (asymbol
*));
2319 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2321 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2324 bfd_set_section_size (abfd
, extern_rt_rel
, 4);
2325 extern_rt_rel_d
= xmalloc (4);
2326 extern_rt_rel
->contents
= extern_rt_rel_d
;
2328 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2329 save_relocs (extern_rt_rel
);
2331 bfd_set_symtab (abfd
, symtab
, symptr
);
2333 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, 4);
2335 bfd_make_readable (abfd
);
2340 pe_create_import_fixup (arelent
*rel
, asection
*s
, int addend
)
2343 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2344 struct bfd_link_hash_entry
*name_thunk_sym
;
2345 const char *name
= sym
->name
;
2346 char *fixup_name
= make_import_fixup_mark (rel
);
2349 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2351 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2353 if (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
)
2355 bfd
*b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2356 add_bfd_to_link (b
, b
->filename
, &link_info
);
2358 /* If we ever use autoimport, we have to cast text section writable. */
2359 config
.text_read_only
= FALSE
;
2360 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2363 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2365 extern char * pe_data_import_dll
;
2366 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2368 b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
,
2369 link_info
.output_bfd
);
2370 add_bfd_to_link (b
, b
->filename
, &link_info
);
2375 if (link_info
.pei386_runtime_pseudo_reloc
)
2377 if (pe_dll_extra_pe_debug
)
2378 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2379 fixup_name
, addend
);
2380 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
,
2381 link_info
.output_bfd
);
2382 add_bfd_to_link (b
, b
->filename
, &link_info
);
2384 if (runtime_pseudo_relocs_created
== 0)
2386 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2387 add_bfd_to_link (b
, b
->filename
, &link_info
);
2389 runtime_pseudo_relocs_created
++;
2393 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2394 s
->owner
, s
, rel
->address
, sym
->name
);
2402 pe_dll_generate_implib (def_file
*def
, const char *impfilename
)
2410 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2411 dll_symname
= xstrdup (dll_filename
);
2412 for (i
= 0; dll_symname
[i
]; i
++)
2413 if (!ISALNUM (dll_symname
[i
]))
2414 dll_symname
[i
] = '_';
2416 unlink_if_ordinary (impfilename
);
2418 outarch
= bfd_openw (impfilename
, 0);
2422 /* xgettext:c-format */
2423 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2427 /* xgettext:c-format */
2428 info_msg (_("Creating library file: %s\n"), impfilename
);
2430 bfd_set_format (outarch
, bfd_archive
);
2431 outarch
->has_armap
= 1;
2433 /* Work out a reasonable size of things to put onto one line. */
2434 ar_head
= make_head (outarch
);
2436 for (i
= 0; i
< def
->num_exports
; i
++)
2438 /* The import library doesn't know about the internal name. */
2439 char *internal
= def
->exports
[i
].internal_name
;
2442 /* Don't add PRIVATE entries to import lib. */
2443 if (pe_def_file
->exports
[i
].flag_private
)
2445 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2446 n
= make_one (def
->exports
+ i
, outarch
,
2447 ! (def
->exports
+ i
)->flag_data
);
2448 n
->archive_next
= head
;
2450 def
->exports
[i
].internal_name
= internal
;
2453 ar_tail
= make_tail (outarch
);
2455 if (ar_head
== NULL
|| ar_tail
== NULL
)
2458 /* Now stick them all into the archive. */
2459 ar_head
->archive_next
= head
;
2460 ar_tail
->archive_next
= ar_head
;
2463 if (! bfd_set_archive_head (outarch
, head
))
2464 einfo ("%Xbfd_set_archive_head: %E\n");
2466 if (! bfd_close (outarch
))
2467 einfo ("%Xbfd_close %s: %E\n", impfilename
);
2469 while (head
!= NULL
)
2471 bfd
*n
= head
->archive_next
;
2478 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*link_info
)
2480 lang_input_statement_type
*fake_file
;
2482 fake_file
= lang_add_input_file (name
,
2483 lang_input_file_is_fake_enum
,
2485 fake_file
->the_bfd
= abfd
;
2486 ldlang_add_file (fake_file
);
2488 if (!bfd_link_add_symbols (abfd
, link_info
))
2489 einfo ("%Xaddsym %s: %E\n", name
);
2493 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*link_info
)
2495 def_file_module
*module
;
2497 pe_dll_id_target (bfd_get_target (output_bfd
));
2502 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2506 dll_filename
= module
->name
;
2507 dll_symname
= xstrdup (module
->name
);
2508 for (i
= 0; dll_symname
[i
]; i
++)
2509 if (!ISALNUM (dll_symname
[i
]))
2510 dll_symname
[i
] = '_';
2514 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2515 if (pe_def_file
->imports
[i
].module
== module
)
2517 def_file_export exp
;
2518 struct bfd_link_hash_entry
*blhe
;
2519 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2520 /* See if we need this import. */
2521 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2522 char *name
= xmalloc (len
+ 2 + 6);
2523 bfd_boolean include_jmp_stub
= FALSE
;
2526 sprintf (name
, "%s",
2527 pe_def_file
->imports
[i
].internal_name
);
2529 sprintf (name
, "%s%s",U (""),
2530 pe_def_file
->imports
[i
].internal_name
);
2532 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2533 FALSE
, FALSE
, FALSE
);
2535 /* Include the jump stub for <sym> only if the <sym>
2537 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2540 sprintf (name
, "%s%s", "__imp_",
2541 pe_def_file
->imports
[i
].internal_name
);
2543 sprintf (name
, "%s%s%s", "__imp_", U (""),
2544 pe_def_file
->imports
[i
].internal_name
);
2546 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2547 FALSE
, FALSE
, FALSE
);
2550 include_jmp_stub
= TRUE
;
2554 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2560 bfd
*ar_head
= make_head (output_bfd
);
2561 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2564 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2565 exp
.name
= pe_def_file
->imports
[i
].name
;
2566 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2567 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2568 exp
.flag_private
= 0;
2569 exp
.flag_constant
= 0;
2570 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2571 exp
.flag_noname
= exp
.name
? 0 : 1;
2572 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
2573 add_bfd_to_link (one
, one
->filename
, link_info
);
2578 bfd
*ar_tail
= make_tail (output_bfd
);
2579 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2586 /* We were handed a *.DLL file. Parse it and turn it into a set of
2587 IMPORTS directives in the def file. Return TRUE if the file was
2588 handled, FALSE if not. */
2591 pe_get16 (bfd
*abfd
, int where
)
2595 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2596 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2597 return b
[0] + (b
[1] << 8);
2601 pe_get32 (bfd
*abfd
, int where
)
2605 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2606 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2607 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2613 unsigned char *b
= ptr
;
2615 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2619 pe_implied_import_dll (const char *filename
)
2622 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2623 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
2624 bfd_vma exp_funcbase
;
2625 unsigned char *expdata
;
2627 bfd_vma name_rvas
, ordinals
, nexp
, ordbase
;
2628 const char *dll_name
;
2629 /* Initialization with start > end guarantees that is_data
2630 will not be set by mistake, and avoids compiler warning. */
2631 bfd_vma data_start
= 1;
2632 bfd_vma data_end
= 0;
2633 bfd_vma rdata_start
= 1;
2634 bfd_vma rdata_end
= 0;
2635 bfd_vma bss_start
= 1;
2636 bfd_vma bss_end
= 0;
2638 /* No, I can't use bfd here. kernel32.dll puts its export table in
2639 the middle of the .rdata section. */
2640 dll
= bfd_openr (filename
, pe_details
->target_name
);
2643 einfo ("%Xopen %s: %E\n", filename
);
2647 /* PEI dlls seem to be bfd_objects. */
2648 if (!bfd_check_format (dll
, bfd_object
))
2650 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2654 /* Get pe_header, optional header and numbers of export entries. */
2655 pe_header_offset
= pe_get32 (dll
, 0x3c);
2656 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2657 #ifdef pe_use_x86_64
2658 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2660 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2663 if (num_entries
< 1) /* No exports. */
2666 #ifdef pe_use_x86_64
2667 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
2668 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
2670 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2671 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2674 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2675 secptr
= (pe_header_offset
+ 4 + 20 +
2676 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2679 /* Get the rva and size of the export section. */
2680 for (i
= 0; i
< nsections
; i
++)
2683 bfd_vma secptr1
= secptr
+ 40 * i
;
2684 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2685 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
2686 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
2688 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2689 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2691 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2693 expptr
= fptr
+ (export_rva
- vaddr
);
2694 if (export_rva
+ export_size
> vaddr
+ vsize
)
2695 export_size
= vsize
- (export_rva
- vaddr
);
2700 /* Scan sections and store the base and size of the
2701 data and bss segments in data/base_start/end. */
2702 for (i
= 0; i
< nsections
; i
++)
2704 bfd_vma secptr1
= secptr
+ 40 * i
;
2705 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
2706 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2707 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
2711 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
2712 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
2714 if (strcmp(sec_name
,".data") == 0)
2717 data_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
,".rdata") == 0)
2726 rdata_start
= vaddr
;
2727 rdata_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
);
2734 else if (strcmp (sec_name
,".bss") == 0)
2737 bss_end
= vaddr
+ vsize
;
2739 if (pe_dll_extra_pe_debug
)
2740 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2741 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2742 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2746 expdata
= xmalloc (export_size
);
2747 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2748 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2749 erva
= (char *) expdata
- export_rva
;
2751 if (pe_def_file
== 0)
2752 pe_def_file
= def_file_empty ();
2754 nexp
= pe_as32 (expdata
+ 24);
2755 name_rvas
= pe_as32 (expdata
+ 32);
2756 ordinals
= pe_as32 (expdata
+ 36);
2757 ordbase
= pe_as32 (expdata
+ 16);
2758 exp_funcbase
= pe_as32 (expdata
+ 28);
2760 /* Use internal dll name instead of filename
2761 to enable symbolic dll linking. */
2762 dll_name
= erva
+ pe_as32 (expdata
+ 12);
2764 /* Check to see if the dll has already been added to
2765 the definition list and if so return without error.
2766 This avoids multiple symbol definitions. */
2767 if (def_get_module (pe_def_file
, dll_name
))
2769 if (pe_dll_extra_pe_debug
)
2770 printf ("%s is already loaded\n", dll_name
);
2774 /* Iterate through the list of symbols. */
2775 for (i
= 0; i
< nexp
; i
++)
2777 /* Pointer to the names vector. */
2778 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
2779 def_file_import
*imp
;
2780 /* Pointer to the function address vector. */
2781 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
2784 /* Skip unwanted symbols, which are
2785 exported in buggy auto-import releases. */
2786 if (! CONST_STRNEQ (erva
+ name_rva
, "_nm_"))
2788 /* is_data is true if the address is in the data, rdata or bss
2791 (func_rva
>= data_start
&& func_rva
< data_end
)
2792 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
2793 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
2795 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
2797 /* Mark symbol type. */
2798 imp
->data
= is_data
;
2800 if (pe_dll_extra_pe_debug
)
2801 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2802 __FUNCTION__
, dll_name
, erva
+ name_rva
,
2803 (unsigned long) func_rva
, is_data
? "(data)" : "");
2810 /* These are the main functions, called from the emulation. The first
2811 is called after the bfds are read, so we can guess at how much space
2812 we need. The second is called after everything is placed, so we
2813 can put the right values in place. */
2816 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2818 pe_dll_id_target (bfd_get_target (abfd
));
2819 process_def_file (abfd
, info
);
2821 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
2824 generate_edata (abfd
, info
);
2825 build_filler_bfd (1);
2829 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2831 pe_dll_id_target (bfd_get_target (abfd
));
2832 build_filler_bfd (0);
2836 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2838 pe_dll_id_target (bfd_get_target (abfd
));
2839 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2841 generate_reloc (abfd
, info
);
2844 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2846 /* Resize the sections. */
2847 lang_reset_memory_regions ();
2848 lang_size_sections (NULL
, TRUE
);
2850 /* Redo special stuff. */
2851 ldemul_after_allocation ();
2853 /* Do the assignments again. */
2854 lang_do_assignments ();
2857 fill_edata (abfd
, info
);
2859 if (info
->shared
&& !info
->pie
)
2860 pe_data (abfd
)->dll
= 1;
2862 edata_s
->contents
= edata_d
;
2863 reloc_s
->contents
= reloc_d
;
2867 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2869 pe_dll_id_target (bfd_get_target (abfd
));
2870 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2872 generate_reloc (abfd
, info
);
2875 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2877 /* Resize the sections. */
2878 lang_reset_memory_regions ();
2879 lang_size_sections (NULL
, TRUE
);
2881 /* Redo special stuff. */
2882 ldemul_after_allocation ();
2884 /* Do the assignments again. */
2885 lang_do_assignments ();
2887 reloc_s
->contents
= reloc_d
;
2891 pe_bfd_is_dll (bfd
*abfd
)
2893 return (bfd_get_format (abfd
) == bfd_object
2895 && pe_data (abfd
)->dll
);