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 if (!bfd_generic_link_read_symbols (b
))
622 einfo (_("%B%F: could not read symbols: %E\n"), b
);
626 symbols
= bfd_get_outsymbols (b
);
627 nsyms
= bfd_get_symcount (b
);
629 for (j
= 0; j
< nsyms
; j
++)
631 /* We should export symbols which are either global or not
632 anything at all. (.bss data is the latter)
633 We should not export undefined symbols. */
634 if (symbols
[j
]->section
!= &bfd_und_section
635 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
636 || (symbols
[j
]->flags
== BFD_FORT_COMM_DEFAULT_VALUE
)))
638 const char *sn
= symbols
[j
]->name
;
640 /* We should not re-export imported stuff. */
646 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
647 sprintf (name
, "%s%s", "__imp_", sn
);
649 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
650 FALSE
, FALSE
, FALSE
);
653 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
657 if (pe_details
->underscored
&& *sn
== '_')
660 if (auto_export (b
, pe_def_file
, sn
))
663 p
=def_file_add_export (pe_def_file
, sn
, 0, -1);
664 /* Fill data flag properly, from dlltool.c. */
665 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
673 #define NE pe_def_file->num_exports
675 /* Canonicalize the export list. */
678 for (i
= 0; i
< NE
; i
++)
680 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
682 /* This will preserve internal_name, which may have been
683 pointing to the same memory as name, or might not
685 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
686 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
687 char *tmp_at
= strchr (tmp
, '@');
692 einfo (_("%XCannot export %s: invalid export name\n"),
693 pe_def_file
->exports
[i
].name
);
694 pe_def_file
->exports
[i
].name
= tmp
;
699 if (pe_dll_stdcall_aliases
)
701 for (i
= 0; i
< NE
; i
++)
703 if (is_import (pe_def_file
->exports
[i
].name
))
706 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
708 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
709 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
711 *(strchr (tmp
, '@')) = 0;
712 if (auto_export (NULL
, pe_def_file
, tmp
))
713 def_file_add_export (pe_def_file
, tmp
,
714 pe_def_file
->exports
[i
].internal_name
,
722 /* Convenience, but watch out for it changing. */
723 e
= pe_def_file
->exports
;
725 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
726 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
728 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
732 count_exported_byname
= 0;
733 count_with_ordinals
= 0;
735 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
737 for (i
= 0, j
= 0; i
< NE
; i
++)
739 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
741 /* This is a duplicate. */
742 if (e
[j
- 1].ordinal
!= -1
743 && e
[i
].ordinal
!= -1
744 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
746 if (pe_dll_warn_dup_exports
)
747 /* xgettext:c-format */
748 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
749 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
753 if (pe_dll_warn_dup_exports
)
754 /* xgettext:c-format */
755 einfo (_("Warning, duplicate EXPORT: %s\n"),
759 if (e
[i
].ordinal
!= -1)
760 e
[j
- 1].ordinal
= e
[i
].ordinal
;
761 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
762 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
763 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
764 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
773 pe_def_file
->num_exports
= j
; /* == NE */
775 for (i
= 0; i
< NE
; i
++)
779 /* Check for forward exports */
780 if (strchr (pe_def_file
->exports
[i
].internal_name
, '.'))
783 if (!pe_def_file
->exports
[i
].flag_noname
)
784 count_exported_byname
++;
786 pe_def_file
->exports
[i
].flag_forward
= 1;
788 if (pe_def_file
->exports
[i
].ordinal
!= -1)
790 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
791 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
792 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
793 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
794 count_with_ordinals
++;
800 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
801 if (pe_details
->underscored
802 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
805 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
808 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
810 blhe
= bfd_link_hash_lookup (info
->hash
,
815 && (blhe
->type
== bfd_link_hash_defined
816 || (blhe
->type
== bfd_link_hash_common
)))
819 if (!pe_def_file
->exports
[i
].flag_noname
)
820 count_exported_byname
++;
822 /* Only fill in the sections. The actual offsets are computed
823 in fill_exported_offsets() after common symbols are laid
825 if (blhe
->type
== bfd_link_hash_defined
)
826 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
828 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
830 if (pe_def_file
->exports
[i
].ordinal
!= -1)
832 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
833 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
834 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
835 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
836 count_with_ordinals
++;
839 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
841 /* xgettext:c-format */
842 einfo (_("%XCannot export %s: symbol not defined\n"),
843 pe_def_file
->exports
[i
].internal_name
);
847 /* xgettext:c-format */
848 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
849 pe_def_file
->exports
[i
].internal_name
,
850 blhe
->type
, bfd_link_hash_defined
);
854 /* xgettext:c-format */
855 einfo (_("%XCannot export %s: symbol not found\n"),
856 pe_def_file
->exports
[i
].internal_name
);
862 /* Build the bfd that will contain .edata and .reloc sections. */
865 build_filler_bfd (int include_edata
)
867 lang_input_statement_type
*filler_file
;
868 filler_file
= lang_add_input_file ("dll stuff",
869 lang_input_file_is_fake_enum
,
871 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
872 link_info
.output_bfd
);
873 if (filler_bfd
== NULL
874 || !bfd_set_arch_mach (filler_bfd
,
875 bfd_get_arch (link_info
.output_bfd
),
876 bfd_get_mach (link_info
.output_bfd
)))
878 einfo ("%X%P: can not create BFD: %E\n");
884 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
886 || !bfd_set_section_flags (filler_bfd
, edata_s
,
893 einfo ("%X%P: can not create .edata section: %E\n");
896 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
899 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
901 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
908 einfo ("%X%P: can not create .reloc section: %E\n");
912 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
914 ldlang_add_file (filler_file
);
917 /* Gather all the exported symbols and build the .edata section. */
920 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
923 int name_table_size
= 0;
926 /* First, we need to know how many exported symbols there are,
927 and what the range of ordinals is. */
928 if (pe_def_file
->name
)
929 dll_name
= pe_def_file
->name
;
932 dll_name
= abfd
->filename
;
934 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
935 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
939 if (count_with_ordinals
&& max_ordinal
> count_exported
)
941 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
942 min_ordinal
= max_ordinal
- count_exported
+ 1;
947 max_ordinal
= count_exported
;
950 export_table_size
= max_ordinal
- min_ordinal
+ 1;
951 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
952 for (i
= 0; i
< export_table_size
; i
++)
953 exported_symbols
[i
] = -1;
955 /* Now we need to assign ordinals to those that don't have them. */
956 for (i
= 0; i
< NE
; i
++)
958 if (exported_symbol_sections
[i
] ||
959 pe_def_file
->exports
[i
].flag_forward
)
961 if (pe_def_file
->exports
[i
].ordinal
!= -1)
963 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
964 int pi
= exported_symbols
[ei
];
968 /* xgettext:c-format */
969 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
970 pe_def_file
->exports
[i
].ordinal
,
971 pe_def_file
->exports
[i
].name
,
972 pe_def_file
->exports
[pi
].name
);
974 exported_symbols
[ei
] = i
;
976 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
979 /* Reserve space for the forward name. */
980 if (pe_def_file
->exports
[i
].flag_forward
)
982 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
986 next_ordinal
= min_ordinal
;
987 for (i
= 0; i
< NE
; i
++)
988 if ((exported_symbol_sections
[i
] ||
989 pe_def_file
->exports
[i
].flag_forward
) &&
990 pe_def_file
->exports
[i
].ordinal
== -1)
992 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
995 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
996 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
999 /* OK, now we can allocate some memory. */
1000 edata_sz
= (40 /* directory */
1001 + 4 * export_table_size
/* addresses */
1002 + 4 * count_exported_byname
/* name ptrs */
1003 + 2 * count_exported_byname
/* ordinals */
1004 + name_table_size
+ strlen (dll_name
) + 1);
1007 /* Fill the exported symbol offsets. The preliminary work has already
1008 been done in process_def_file(). */
1011 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1014 struct bfd_link_hash_entry
*blhe
;
1016 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1020 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1021 if (pe_details
->underscored
1022 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1025 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1028 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1030 blhe
= bfd_link_hash_lookup (info
->hash
,
1032 FALSE
, FALSE
, TRUE
);
1034 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1035 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1042 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1045 unsigned char *edirectory
;
1046 unsigned char *eaddresses
;
1047 unsigned char *enameptrs
;
1048 unsigned char *eordinals
;
1054 edata_d
= xmalloc (edata_sz
);
1056 /* Note use of array pointer math here. */
1057 edirectory
= edata_d
;
1058 eaddresses
= edata_d
+ 40;
1059 enameptrs
= eaddresses
+ 4 * export_table_size
;
1060 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1061 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1063 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1064 + edata_s->output_section->vma - image_base)
1066 memset (edata_d
, 0, edata_sz
);
1067 bfd_put_32 (abfd
, now
, edata_d
+ 4);
1068 if (pe_def_file
->version_major
!= -1)
1070 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1071 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1074 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1075 strcpy (enamestr
, dll_name
);
1076 enamestr
+= strlen (enamestr
) + 1;
1077 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1078 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1079 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1080 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1081 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1082 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1084 fill_exported_offsets (abfd
, info
);
1086 /* Ok, now for the filling in part.
1087 Scan alphabetically - ie the ordering in the exports[] table,
1088 rather than by ordinal - the ordering in the exported_symbol[]
1089 table. See dlltool.c and:
1090 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1091 for more information. */
1093 for (s
= 0; s
< NE
; s
++)
1095 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1096 if (pe_def_file
->exports
[s
].ordinal
!= -1 &&
1097 (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1099 int ord
= pe_def_file
->exports
[s
].ordinal
;
1101 if (pe_def_file
->exports
[s
].flag_forward
)
1103 bfd_put_32 (abfd
, ERVA (enamestr
),
1104 eaddresses
+ 4 * (ord
- min_ordinal
));
1106 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1107 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1111 bfd_vma srva
= (exported_symbol_offsets
[s
]
1112 + ssec
->output_section
->vma
1113 + ssec
->output_offset
);
1115 bfd_put_32 (abfd
, srva
- image_base
,
1116 eaddresses
+ 4 * (ord
- min_ordinal
));
1119 if (!pe_def_file
->exports
[s
].flag_noname
)
1121 char *ename
= pe_def_file
->exports
[s
].name
;
1123 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1125 strcpy (enamestr
, ename
);
1126 enamestr
+= strlen (enamestr
) + 1;
1127 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1129 pe_def_file
->exports
[s
].hint
= hint
++;
1136 static struct bfd_section
*current_sec
;
1139 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1141 int (*cb
) (arelent
*, asection
*))
1146 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1151 if (!bfd_generic_link_read_symbols (b
))
1153 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1157 symbols
= bfd_get_outsymbols (b
);
1158 nsyms
= bfd_get_symcount (b
);
1160 for (s
= b
->sections
; s
; s
= s
->next
)
1163 int relsize
, nrelocs
, i
;
1164 int flags
= bfd_get_section_flags (b
, s
);
1166 /* Skip discarded linkonce sections. */
1167 if (flags
& SEC_LINK_ONCE
1168 && s
->output_section
== bfd_abs_section_ptr
)
1173 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1174 relocs
= xmalloc (relsize
);
1175 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1177 for (i
= 0; i
< nrelocs
; i
++)
1179 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1181 if (!strcmp (name
, sym
->name
))
1187 /* Warning: the allocated symbols are remembered in BFD and reused
1188 later, so don't free them! */
1189 /* free (symbols); */
1194 /* Gather all the relocations and build the .reloc section. */
1197 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1200 /* For .reloc stuff. */
1201 reloc_data_type
*reloc_data
;
1202 int total_relocs
= 0;
1204 bfd_vma sec_page
= (bfd_vma
) -1;
1205 bfd_vma page_ptr
, page_count
;
1208 struct bfd_section
*s
;
1211 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1212 for (s
= b
->sections
; s
; s
= s
->next
)
1213 total_relocs
+= s
->reloc_count
;
1215 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1219 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1222 int relsize
, nrelocs
, i
;
1224 for (s
= b
->sections
; s
; s
= s
->next
)
1226 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1230 /* If it's not loaded, we don't need to relocate it this way. */
1231 if (!(s
->output_section
->flags
& SEC_LOAD
))
1234 /* I don't know why there would be a reloc for these, but I've
1235 seen it happen - DJ */
1236 if (s
->output_section
== &bfd_abs_section
)
1239 if (s
->output_section
->vma
== 0)
1241 /* Huh? Shouldn't happen, but punt if it does. */
1242 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1243 s
->output_section
->name
, s
->output_section
->index
,
1244 s
->output_section
->flags
);
1248 if (!bfd_generic_link_read_symbols (b
))
1250 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1254 symbols
= bfd_get_outsymbols (b
);
1255 nsyms
= bfd_get_symcount (b
);
1256 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1257 relocs
= xmalloc (relsize
);
1258 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1260 for (i
= 0; i
< nrelocs
; i
++)
1262 if (pe_dll_extra_pe_debug
)
1264 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1265 printf ("rel: %s\n", sym
->name
);
1267 if (!relocs
[i
]->howto
->pc_relative
1268 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1271 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1273 /* Don't create relocs for undefined weak symbols. */
1274 if (sym
->flags
== BSF_WEAK
)
1276 struct bfd_link_hash_entry
*blhe
1277 = bfd_link_hash_lookup (info
->hash
, sym
->name
,
1278 FALSE
, FALSE
, FALSE
);
1279 if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1283 sym_vma
= (relocs
[i
]->addend
1286 + sym
->section
->output_offset
1287 + sym
->section
->output_section
->vma
);
1288 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1290 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1292 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1293 relocs
[i
]->howto
->rightshift
)
1295 #ifdef pe_use_x86_64
1296 case BITS_AND_SHIFT (64, 0):
1297 reloc_data
[total_relocs
].type
= 10;
1301 case BITS_AND_SHIFT (32, 0):
1302 reloc_data
[total_relocs
].type
= 3;
1305 case BITS_AND_SHIFT (16, 0):
1306 reloc_data
[total_relocs
].type
= 2;
1309 case BITS_AND_SHIFT (16, 16):
1310 reloc_data
[total_relocs
].type
= 4;
1311 /* FIXME: we can't know the symbol's right value
1312 yet, but we probably can safely assume that
1313 CE will relocate us in 64k blocks, so leaving
1315 reloc_data
[total_relocs
].extra
= 0;
1318 case BITS_AND_SHIFT (26, 2):
1319 reloc_data
[total_relocs
].type
= 5;
1322 case BITS_AND_SHIFT (24, 2):
1323 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1324 Those ARM_xxx definitions should go in proper
1326 if (relocs
[i
]->howto
->type
== 0
1327 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1328 || relocs
[i
]->howto
->type
== 5)
1329 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1330 that has already been fully processed during a
1331 previous link stage, so ignore it here. */
1335 /* xgettext:c-format */
1336 einfo (_("%XError: %d-bit reloc in dll\n"),
1337 relocs
[i
]->howto
->bitsize
);
1343 /* Warning: the allocated symbols are remembered in BFD and
1344 reused later, so don't free them! */
1348 /* At this point, we have total_relocs relocation addresses in
1349 reloc_addresses, which are all suitable for the .reloc section.
1350 We must now create the new sections. */
1351 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1353 for (i
= 0; i
< total_relocs
; i
++)
1355 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1357 if (this_page
!= sec_page
)
1359 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1361 sec_page
= this_page
;
1366 if (reloc_data
[i
].type
== 4)
1370 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1371 reloc_d
= xmalloc (reloc_sz
);
1372 sec_page
= (bfd_vma
) -1;
1374 page_ptr
= (bfd_vma
) -1;
1377 for (i
= 0; i
< total_relocs
; i
++)
1379 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1380 bfd_vma this_page
= (rva
& ~0xfff);
1382 if (this_page
!= sec_page
)
1384 while (reloc_sz
& 3)
1385 reloc_d
[reloc_sz
++] = 0;
1387 if (page_ptr
!= (bfd_vma
) -1)
1388 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1390 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1391 page_ptr
= reloc_sz
;
1393 sec_page
= this_page
;
1397 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1398 reloc_d
+ reloc_sz
);
1401 if (reloc_data
[i
].type
== 4)
1403 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1410 while (reloc_sz
& 3)
1411 reloc_d
[reloc_sz
++] = 0;
1413 if (page_ptr
!= (bfd_vma
) -1)
1414 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1416 while (reloc_sz
< reloc_s
->size
)
1417 reloc_d
[reloc_sz
++] = 0;
1420 /* Given the exiting def_file structure, print out a .DEF file that
1421 corresponds to it. */
1424 quoteput (char *s
, FILE *f
, int needs_quotes
)
1428 for (cp
= s
; *cp
; cp
++)
1443 if (*s
== '"' || *s
== '\\')
1457 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1460 FILE *out
= fopen (pe_out_def_filename
, "w");
1463 /* xgettext:c-format */
1464 einfo (_("%s: Can't open output def file %s\n"),
1465 program_name
, pe_out_def_filename
);
1469 if (pe_def_file
->name
)
1471 if (pe_def_file
->is_dll
)
1472 fprintf (out
, "LIBRARY ");
1474 fprintf (out
, "NAME ");
1476 quoteput (pe_def_file
->name
, out
, 1);
1478 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1480 fprintf (out
, " BASE=0x");
1481 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1483 fprintf (out
, "\n");
1486 if (pe_def_file
->description
)
1488 fprintf (out
, "DESCRIPTION ");
1489 quoteput (pe_def_file
->description
, out
, 1);
1490 fprintf (out
, "\n");
1493 if (pe_def_file
->version_minor
!= -1)
1494 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1495 pe_def_file
->version_minor
);
1496 else if (pe_def_file
->version_major
!= -1)
1497 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1499 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1500 fprintf (out
, "\n");
1502 if (pe_def_file
->stack_commit
!= -1)
1503 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1504 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1505 else if (pe_def_file
->stack_reserve
!= -1)
1506 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1508 if (pe_def_file
->heap_commit
!= -1)
1509 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1510 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1511 else if (pe_def_file
->heap_reserve
!= -1)
1512 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1514 if (pe_def_file
->num_section_defs
> 0)
1516 fprintf (out
, "\nSECTIONS\n\n");
1518 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1521 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1523 if (pe_def_file
->section_defs
[i
].class)
1525 fprintf (out
, " CLASS ");
1526 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1529 if (pe_def_file
->section_defs
[i
].flag_read
)
1530 fprintf (out
, " READ");
1532 if (pe_def_file
->section_defs
[i
].flag_write
)
1533 fprintf (out
, " WRITE");
1535 if (pe_def_file
->section_defs
[i
].flag_execute
)
1536 fprintf (out
, " EXECUTE");
1538 if (pe_def_file
->section_defs
[i
].flag_shared
)
1539 fprintf (out
, " SHARED");
1541 fprintf (out
, "\n");
1545 if (pe_def_file
->num_exports
> 0)
1547 fprintf (out
, "EXPORTS\n");
1549 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1551 def_file_export
*e
= pe_def_file
->exports
+ i
;
1553 quoteput (e
->name
, out
, 0);
1555 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1557 fprintf (out
, " = ");
1558 quoteput (e
->internal_name
, out
, 0);
1561 if (e
->ordinal
!= -1)
1562 fprintf (out
, " @%d", e
->ordinal
);
1564 if (e
->flag_private
)
1565 fprintf (out
, " PRIVATE");
1567 if (e
->flag_constant
)
1568 fprintf (out
, " CONSTANT");
1571 fprintf (out
, " NONAME");
1574 fprintf (out
, " DATA");
1576 fprintf (out
, "\n");
1580 if (pe_def_file
->num_imports
> 0)
1582 fprintf (out
, "\nIMPORTS\n\n");
1584 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1586 def_file_import
*im
= pe_def_file
->imports
+ i
;
1589 if (im
->internal_name
1590 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1592 quoteput (im
->internal_name
, out
, 0);
1593 fprintf (out
, " = ");
1596 quoteput (im
->module
->name
, out
, 0);
1600 quoteput (im
->name
, out
, 0);
1602 fprintf (out
, "%d", im
->ordinal
);
1604 fprintf (out
, "\n");
1609 fprintf (out
, _("; no contents available\n"));
1611 if (fclose (out
) == EOF
)
1612 /* xgettext:c-format */
1613 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1616 /* Generate the import library. */
1618 static asymbol
**symtab
;
1621 static const char *dll_filename
;
1622 static char *dll_symname
;
1624 #define UNDSEC (asection *) &bfd_und_section
1627 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1632 sec
= bfd_make_section_old_way (abfd
, name
);
1633 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1634 bfd_set_section_alignment (abfd
, sec
, align
);
1635 /* Remember to undo this before trying to link internally! */
1636 sec
->output_section
= sec
;
1638 sym
= bfd_make_empty_symbol (abfd
);
1639 symtab
[symptr
++] = sym
;
1640 sym
->name
= sec
->name
;
1642 sym
->flags
= BSF_LOCAL
;
1649 quick_symbol (bfd
*abfd
,
1658 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1663 sym
= bfd_make_empty_symbol (abfd
);
1668 symtab
[symptr
++] = sym
;
1671 static arelent
*reltab
= 0;
1672 static int relcount
= 0, relsize
= 0;
1675 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1677 if (relcount
>= relsize
- 1)
1681 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1683 reltab
= xmalloc (relsize
* sizeof (arelent
));
1685 reltab
[relcount
].address
= address
;
1686 reltab
[relcount
].addend
= 0;
1687 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1688 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1693 save_relocs (asection
*sec
)
1697 sec
->relocation
= reltab
;
1698 sec
->reloc_count
= relcount
;
1699 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1700 for (i
= 0; i
< relcount
; i
++)
1701 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1702 sec
->orelocation
[relcount
] = 0;
1703 sec
->flags
|= SEC_RELOC
;
1705 relcount
= relsize
= 0;
1708 /* .section .idata$2
1709 .global __head_my_dll
1726 make_head (bfd
*parent
)
1728 asection
*id2
, *id5
, *id4
;
1729 unsigned char *d2
, *d5
, *d4
;
1733 oname
= xmalloc (20);
1734 sprintf (oname
, "d%06d.o", tmp_seq
);
1737 abfd
= bfd_create (oname
, parent
);
1738 bfd_find_target (pe_details
->object_target
, abfd
);
1739 bfd_make_writable (abfd
);
1741 bfd_set_format (abfd
, bfd_object
);
1742 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1745 symtab
= xmalloc (6 * sizeof (asymbol
*));
1746 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1747 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1748 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1749 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1750 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1752 /* OK, pay attention here. I got confused myself looking back at
1753 it. We create a four-byte section to mark the beginning of the
1754 list, and we include an offset of 4 in the section, so that the
1755 pointer to the list points to the *end* of this section, which is
1756 the start of the list of sections from other objects. */
1758 bfd_set_section_size (abfd
, id2
, 20);
1762 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
1763 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1764 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1765 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1768 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1769 d5
= xmalloc (PE_IDATA5_SIZE
);
1771 memset (d5
, 0, PE_IDATA5_SIZE
);
1773 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1774 d4
= xmalloc (PE_IDATA4_SIZE
);
1776 memset (d4
, 0, PE_IDATA4_SIZE
);
1778 bfd_set_symtab (abfd
, symtab
, symptr
);
1780 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1781 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1782 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1784 bfd_make_readable (abfd
);
1788 /* .section .idata$4
1795 .global __my_dll_iname
1800 make_tail (bfd
*parent
)
1802 asection
*id4
, *id5
, *id7
;
1803 unsigned char *d4
, *d5
, *d7
;
1808 oname
= xmalloc (20);
1809 sprintf (oname
, "d%06d.o", tmp_seq
);
1812 abfd
= bfd_create (oname
, parent
);
1813 bfd_find_target (pe_details
->object_target
, abfd
);
1814 bfd_make_writable (abfd
);
1816 bfd_set_format (abfd
, bfd_object
);
1817 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1820 symtab
= xmalloc (5 * sizeof (asymbol
*));
1821 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1822 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1823 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1824 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1826 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1827 d4
= xmalloc (PE_IDATA4_SIZE
);
1829 memset (d4
, 0, PE_IDATA4_SIZE
);
1831 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1832 d5
= xmalloc (PE_IDATA5_SIZE
);
1834 memset (d5
, 0, PE_IDATA5_SIZE
);
1836 len
= strlen (dll_filename
) + 1;
1839 bfd_set_section_size (abfd
, id7
, len
);
1842 strcpy ((char *) d7
, dll_filename
);
1843 /* If len was odd, the above
1844 strcpy leaves behind an undefined byte. That is harmless,
1845 but we set it to 0 just so the binary dumps are pretty. */
1848 bfd_set_symtab (abfd
, symtab
, symptr
);
1850 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1851 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1852 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1854 bfd_make_readable (abfd
);
1860 .global ___imp_function
1861 .global __imp__function
1863 jmp *__imp__function:
1877 .asciz "function" xlate? (add underscore, kill at) */
1879 static const unsigned char jmp_ix86_bytes
[] =
1881 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1889 .dw __imp_function */
1891 static const unsigned char jmp_sh_bytes
[] =
1893 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1897 lui $t0,<high:__imp_function>
1898 lw $t0,<low:__imp_function>
1902 static const unsigned char jmp_mips_bytes
[] =
1904 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1905 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1908 static const unsigned char jmp_arm_bytes
[] =
1910 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1911 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1917 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
1919 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1920 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1924 const unsigned char *jmp_bytes
= NULL
;
1925 int jmp_byte_count
= 0;
1927 /* Include the jump stub section only if it is needed. A jump
1928 stub is needed if the symbol being imported <sym> is a function
1929 symbol and there is at least one undefined reference to that
1930 symbol. In other words, if all the import references to <sym> are
1931 explicitly through _declspec(dllimport) then the jump stub is not
1933 if (include_jmp_stub
)
1935 switch (pe_details
->pe_arch
)
1938 jmp_bytes
= jmp_ix86_bytes
;
1939 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1942 jmp_bytes
= jmp_sh_bytes
;
1943 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1946 jmp_bytes
= jmp_mips_bytes
;
1947 jmp_byte_count
= sizeof (jmp_mips_bytes
);
1950 case PE_ARCH_arm_epoc
:
1951 case PE_ARCH_arm_wince
:
1952 jmp_bytes
= jmp_arm_bytes
;
1953 jmp_byte_count
= sizeof (jmp_arm_bytes
);
1960 oname
= xmalloc (20);
1961 sprintf (oname
, "d%06d.o", tmp_seq
);
1964 abfd
= bfd_create (oname
, parent
);
1965 bfd_find_target (pe_details
->object_target
, abfd
);
1966 bfd_make_writable (abfd
);
1968 bfd_set_format (abfd
, bfd_object
);
1969 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1972 symtab
= xmalloc (11 * sizeof (asymbol
*));
1973 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1974 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1975 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1976 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1977 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1979 if (*exp
->internal_name
== '@')
1981 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1983 if (include_jmp_stub
)
1984 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1985 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
1987 /* Fastcall applies only to functions,
1988 so no need for auto-import symbol. */
1992 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1994 if (include_jmp_stub
)
1995 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
1997 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
1999 /* Symbol to reference ord/name of imported
2000 data symbol, used to implement auto-import. */
2002 quick_symbol (abfd
, U ("_nm_"), U (""), exp
->internal_name
, id6
,
2005 if (pe_dll_compat_implib
)
2006 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "", id5
,
2009 if (include_jmp_stub
)
2011 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
2012 td
= xmalloc (jmp_byte_count
);
2014 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2016 switch (pe_details
->pe_arch
)
2019 #ifdef pe_use_x86_64
2020 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2022 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2026 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2029 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2030 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2031 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2034 case PE_ARCH_arm_epoc
:
2035 case PE_ARCH_arm_wince
:
2036 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2044 bfd_set_section_size (abfd
, tx
, 0);
2046 bfd_set_section_size (abfd
, id7
, 4);
2050 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2053 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2054 d5
= xmalloc (PE_IDATA5_SIZE
);
2056 memset (d5
, 0, PE_IDATA5_SIZE
);
2058 if (exp
->flag_noname
)
2060 d5
[0] = exp
->ordinal
;
2061 d5
[1] = exp
->ordinal
>> 8;
2062 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2066 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2070 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2071 d4
= xmalloc (PE_IDATA4_SIZE
);
2073 memset (d4
, 0, PE_IDATA4_SIZE
);
2075 if (exp
->flag_noname
)
2077 d4
[0] = exp
->ordinal
;
2078 d4
[1] = exp
->ordinal
>> 8;
2079 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2083 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2087 if (exp
->flag_noname
)
2090 bfd_set_section_size (abfd
, id6
, 0);
2094 /* { short, asciz } */
2095 len
= 2 + strlen (exp
->name
) + 1;
2098 bfd_set_section_size (abfd
, id6
, len
);
2101 memset (d6
, 0, len
);
2102 d6
[0] = exp
->hint
& 0xff;
2103 d6
[1] = exp
->hint
>> 8;
2104 strcpy ((char *) d6
+ 2, exp
->name
);
2107 bfd_set_symtab (abfd
, symtab
, symptr
);
2109 if (include_jmp_stub
)
2110 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2111 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2112 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2113 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2114 if (!exp
->flag_noname
)
2115 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2117 bfd_make_readable (abfd
);
2122 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2124 /* Name thunks go to idata$4. */
2130 oname
= xmalloc (20);
2131 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2134 abfd
= bfd_create (oname
, parent
);
2135 bfd_find_target (pe_details
->object_target
, abfd
);
2136 bfd_make_writable (abfd
);
2138 bfd_set_format (abfd
, bfd_object
);
2139 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2142 symtab
= xmalloc (3 * sizeof (asymbol
*));
2143 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2144 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
2145 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2147 /* We need space for the real thunk and for the null terminator. */
2148 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2149 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2151 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2152 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2155 bfd_set_symtab (abfd
, symtab
, symptr
);
2157 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2159 bfd_make_readable (abfd
);
2164 make_import_fixup_mark (arelent
*rel
)
2166 /* We convert reloc to symbol, for later reference. */
2168 static char *fixup_name
= NULL
;
2169 static size_t buffer_len
= 0;
2171 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2173 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2174 struct bfd_link_hash_entry
*bh
;
2178 fixup_name
= xmalloc (384);
2182 if (strlen (sym
->name
) + 25 > buffer_len
)
2183 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2184 bigger than 20 digits long, we've got worse problems than
2185 overflowing this buffer... */
2188 /* New buffer size is length of symbol, plus 25, but
2189 then rounded up to the nearest multiple of 128. */
2190 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2191 fixup_name
= xmalloc (buffer_len
);
2194 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2197 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2198 current_sec
, /* sym->section, */
2199 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2204 /* .section .idata$2
2205 .rva __nm_thnk_SYM (singleton thunk with name of func)
2208 .rva __my_dll_iname (name of dll)
2209 .rva __fuNN_SYM (pointer to reference (address) in text) */
2212 make_import_fixup_entry (const char *name
,
2213 const char *fixup_name
,
2214 const char *dll_symname
,
2222 oname
= xmalloc (20);
2223 sprintf (oname
, "fu%06d.o", tmp_seq
);
2226 abfd
= bfd_create (oname
, parent
);
2227 bfd_find_target (pe_details
->object_target
, abfd
);
2228 bfd_make_writable (abfd
);
2230 bfd_set_format (abfd
, bfd_object
);
2231 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2234 symtab
= xmalloc (6 * sizeof (asymbol
*));
2235 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2237 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2238 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2239 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2241 bfd_set_section_size (abfd
, id2
, 20);
2246 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2247 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2248 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2251 bfd_set_symtab (abfd
, symtab
, symptr
);
2253 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2255 bfd_make_readable (abfd
);
2259 /* .section .rdata_runtime_pseudo_reloc
2261 .rva __fuNN_SYM (pointer to reference (address) in text) */
2264 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2265 const char *fixup_name
,
2270 unsigned char *rt_rel_d
;
2274 oname
= xmalloc (20);
2275 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2278 abfd
= bfd_create (oname
, parent
);
2279 bfd_find_target (pe_details
->object_target
, abfd
);
2280 bfd_make_writable (abfd
);
2282 bfd_set_format (abfd
, bfd_object
);
2283 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2286 symtab
= xmalloc (2 * sizeof (asymbol
*));
2287 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2288 SEC_HAS_CONTENTS
, 2);
2290 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2292 bfd_set_section_size (abfd
, rt_rel
, 8);
2293 rt_rel_d
= xmalloc (8);
2294 rt_rel
->contents
= rt_rel_d
;
2295 memset (rt_rel_d
, 0, 8);
2296 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2298 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2299 save_relocs (rt_rel
);
2301 bfd_set_symtab (abfd
, symtab
, symptr
);
2303 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2305 bfd_make_readable (abfd
);
2310 .rva __pei386_runtime_relocator */
2313 pe_create_runtime_relocator_reference (bfd
*parent
)
2315 asection
*extern_rt_rel
;
2316 unsigned char *extern_rt_rel_d
;
2320 oname
= xmalloc (20);
2321 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2324 abfd
= bfd_create (oname
, parent
);
2325 bfd_find_target (pe_details
->object_target
, abfd
);
2326 bfd_make_writable (abfd
);
2328 bfd_set_format (abfd
, bfd_object
);
2329 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2332 symtab
= xmalloc (2 * sizeof (asymbol
*));
2333 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2335 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2338 bfd_set_section_size (abfd
, extern_rt_rel
, 4);
2339 extern_rt_rel_d
= xmalloc (4);
2340 extern_rt_rel
->contents
= extern_rt_rel_d
;
2342 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2343 save_relocs (extern_rt_rel
);
2345 bfd_set_symtab (abfd
, symtab
, symptr
);
2347 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, 4);
2349 bfd_make_readable (abfd
);
2354 pe_create_import_fixup (arelent
*rel
, asection
*s
, int addend
)
2357 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2358 struct bfd_link_hash_entry
*name_thunk_sym
;
2359 const char *name
= sym
->name
;
2360 char *fixup_name
= make_import_fixup_mark (rel
);
2363 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2365 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2367 if (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
)
2369 bfd
*b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2370 add_bfd_to_link (b
, b
->filename
, &link_info
);
2372 /* If we ever use autoimport, we have to cast text section writable. */
2373 config
.text_read_only
= FALSE
;
2374 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2377 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2379 extern char * pe_data_import_dll
;
2380 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2382 b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
,
2383 link_info
.output_bfd
);
2384 add_bfd_to_link (b
, b
->filename
, &link_info
);
2389 if (link_info
.pei386_runtime_pseudo_reloc
)
2391 if (pe_dll_extra_pe_debug
)
2392 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2393 fixup_name
, addend
);
2394 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
,
2395 link_info
.output_bfd
);
2396 add_bfd_to_link (b
, b
->filename
, &link_info
);
2398 if (runtime_pseudo_relocs_created
== 0)
2400 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2401 add_bfd_to_link (b
, b
->filename
, &link_info
);
2403 runtime_pseudo_relocs_created
++;
2407 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2408 s
->owner
, s
, rel
->address
, sym
->name
);
2416 pe_dll_generate_implib (def_file
*def
, const char *impfilename
)
2424 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2425 dll_symname
= xstrdup (dll_filename
);
2426 for (i
= 0; dll_symname
[i
]; i
++)
2427 if (!ISALNUM (dll_symname
[i
]))
2428 dll_symname
[i
] = '_';
2430 unlink_if_ordinary (impfilename
);
2432 outarch
= bfd_openw (impfilename
, 0);
2436 /* xgettext:c-format */
2437 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2441 /* xgettext:c-format */
2442 info_msg (_("Creating library file: %s\n"), impfilename
);
2444 bfd_set_format (outarch
, bfd_archive
);
2445 outarch
->has_armap
= 1;
2447 /* Work out a reasonable size of things to put onto one line. */
2448 ar_head
= make_head (outarch
);
2450 for (i
= 0; i
< def
->num_exports
; i
++)
2452 /* The import library doesn't know about the internal name. */
2453 char *internal
= def
->exports
[i
].internal_name
;
2456 /* Don't add PRIVATE entries to import lib. */
2457 if (pe_def_file
->exports
[i
].flag_private
)
2459 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2460 n
= make_one (def
->exports
+ i
, outarch
,
2461 ! (def
->exports
+ i
)->flag_data
);
2462 n
->archive_next
= head
;
2464 def
->exports
[i
].internal_name
= internal
;
2467 ar_tail
= make_tail (outarch
);
2469 if (ar_head
== NULL
|| ar_tail
== NULL
)
2472 /* Now stick them all into the archive. */
2473 ar_head
->archive_next
= head
;
2474 ar_tail
->archive_next
= ar_head
;
2477 if (! bfd_set_archive_head (outarch
, head
))
2478 einfo ("%Xbfd_set_archive_head: %E\n");
2480 if (! bfd_close (outarch
))
2481 einfo ("%Xbfd_close %s: %E\n", impfilename
);
2483 while (head
!= NULL
)
2485 bfd
*n
= head
->archive_next
;
2492 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*link_info
)
2494 lang_input_statement_type
*fake_file
;
2496 fake_file
= lang_add_input_file (name
,
2497 lang_input_file_is_fake_enum
,
2499 fake_file
->the_bfd
= abfd
;
2500 ldlang_add_file (fake_file
);
2502 if (!bfd_link_add_symbols (abfd
, link_info
))
2503 einfo ("%Xaddsym %s: %E\n", name
);
2507 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*link_info
)
2509 def_file_module
*module
;
2511 pe_dll_id_target (bfd_get_target (output_bfd
));
2516 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2520 dll_filename
= module
->name
;
2521 dll_symname
= xstrdup (module
->name
);
2522 for (i
= 0; dll_symname
[i
]; i
++)
2523 if (!ISALNUM (dll_symname
[i
]))
2524 dll_symname
[i
] = '_';
2528 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2529 if (pe_def_file
->imports
[i
].module
== module
)
2531 def_file_export exp
;
2532 struct bfd_link_hash_entry
*blhe
;
2533 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2534 /* See if we need this import. */
2535 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2536 char *name
= xmalloc (len
+ 2 + 6);
2537 bfd_boolean include_jmp_stub
= FALSE
;
2540 sprintf (name
, "%s",
2541 pe_def_file
->imports
[i
].internal_name
);
2543 sprintf (name
, "%s%s",U (""),
2544 pe_def_file
->imports
[i
].internal_name
);
2546 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2547 FALSE
, FALSE
, FALSE
);
2549 /* Include the jump stub for <sym> only if the <sym>
2551 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2554 sprintf (name
, "%s%s", "__imp_",
2555 pe_def_file
->imports
[i
].internal_name
);
2557 sprintf (name
, "%s%s%s", "__imp_", U (""),
2558 pe_def_file
->imports
[i
].internal_name
);
2560 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2561 FALSE
, FALSE
, FALSE
);
2564 include_jmp_stub
= TRUE
;
2568 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2574 bfd
*ar_head
= make_head (output_bfd
);
2575 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2578 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2579 exp
.name
= pe_def_file
->imports
[i
].name
;
2580 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2581 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2582 exp
.flag_private
= 0;
2583 exp
.flag_constant
= 0;
2584 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2585 exp
.flag_noname
= exp
.name
? 0 : 1;
2586 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
2587 add_bfd_to_link (one
, one
->filename
, link_info
);
2592 bfd
*ar_tail
= make_tail (output_bfd
);
2593 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2600 /* We were handed a *.DLL file. Parse it and turn it into a set of
2601 IMPORTS directives in the def file. Return TRUE if the file was
2602 handled, FALSE if not. */
2605 pe_get16 (bfd
*abfd
, int where
)
2609 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2610 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2611 return b
[0] + (b
[1] << 8);
2615 pe_get32 (bfd
*abfd
, int where
)
2619 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2620 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2621 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2627 unsigned char *b
= ptr
;
2629 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2633 pe_implied_import_dll (const char *filename
)
2636 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2637 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
2638 bfd_vma exp_funcbase
;
2639 unsigned char *expdata
;
2641 bfd_vma name_rvas
, ordinals
, nexp
, ordbase
;
2642 const char *dll_name
;
2643 /* Initialization with start > end guarantees that is_data
2644 will not be set by mistake, and avoids compiler warning. */
2645 bfd_vma data_start
= 1;
2646 bfd_vma data_end
= 0;
2647 bfd_vma rdata_start
= 1;
2648 bfd_vma rdata_end
= 0;
2649 bfd_vma bss_start
= 1;
2650 bfd_vma bss_end
= 0;
2652 /* No, I can't use bfd here. kernel32.dll puts its export table in
2653 the middle of the .rdata section. */
2654 dll
= bfd_openr (filename
, pe_details
->target_name
);
2657 einfo ("%Xopen %s: %E\n", filename
);
2661 /* PEI dlls seem to be bfd_objects. */
2662 if (!bfd_check_format (dll
, bfd_object
))
2664 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2668 /* Get pe_header, optional header and numbers of export entries. */
2669 pe_header_offset
= pe_get32 (dll
, 0x3c);
2670 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2671 #ifdef pe_use_x86_64
2672 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2674 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2677 if (num_entries
< 1) /* No exports. */
2680 #ifdef pe_use_x86_64
2681 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
2682 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
2684 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2685 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2688 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2689 secptr
= (pe_header_offset
+ 4 + 20 +
2690 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2693 /* Get the rva and size of the export section. */
2694 for (i
= 0; i
< nsections
; i
++)
2697 bfd_vma secptr1
= secptr
+ 40 * i
;
2698 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2699 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
2700 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
2702 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2703 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2705 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2707 expptr
= fptr
+ (export_rva
- vaddr
);
2708 if (export_rva
+ export_size
> vaddr
+ vsize
)
2709 export_size
= vsize
- (export_rva
- vaddr
);
2714 /* Scan sections and store the base and size of the
2715 data and bss segments in data/base_start/end. */
2716 for (i
= 0; i
< nsections
; i
++)
2718 bfd_vma secptr1
= secptr
+ 40 * i
;
2719 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
2720 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2721 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
2725 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
2726 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
2728 if (strcmp(sec_name
,".data") == 0)
2731 data_end
= vaddr
+ vsize
;
2733 if (pe_dll_extra_pe_debug
)
2734 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2735 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2736 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2738 else if (strcmp(sec_name
,".rdata") == 0)
2740 rdata_start
= vaddr
;
2741 rdata_end
= vaddr
+ vsize
;
2743 if (pe_dll_extra_pe_debug
)
2744 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2745 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2746 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2748 else if (strcmp (sec_name
,".bss") == 0)
2751 bss_end
= vaddr
+ vsize
;
2753 if (pe_dll_extra_pe_debug
)
2754 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2755 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2756 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2760 expdata
= xmalloc (export_size
);
2761 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2762 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2763 erva
= (char *) expdata
- export_rva
;
2765 if (pe_def_file
== 0)
2766 pe_def_file
= def_file_empty ();
2768 nexp
= pe_as32 (expdata
+ 24);
2769 name_rvas
= pe_as32 (expdata
+ 32);
2770 ordinals
= pe_as32 (expdata
+ 36);
2771 ordbase
= pe_as32 (expdata
+ 16);
2772 exp_funcbase
= pe_as32 (expdata
+ 28);
2774 /* Use internal dll name instead of filename
2775 to enable symbolic dll linking. */
2776 dll_name
= erva
+ pe_as32 (expdata
+ 12);
2778 /* Check to see if the dll has already been added to
2779 the definition list and if so return without error.
2780 This avoids multiple symbol definitions. */
2781 if (def_get_module (pe_def_file
, dll_name
))
2783 if (pe_dll_extra_pe_debug
)
2784 printf ("%s is already loaded\n", dll_name
);
2788 /* Iterate through the list of symbols. */
2789 for (i
= 0; i
< nexp
; i
++)
2791 /* Pointer to the names vector. */
2792 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
2793 def_file_import
*imp
;
2794 /* Pointer to the function address vector. */
2795 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
2798 /* Skip unwanted symbols, which are
2799 exported in buggy auto-import releases. */
2800 if (! CONST_STRNEQ (erva
+ name_rva
, "_nm_"))
2802 /* is_data is true if the address is in the data, rdata or bss
2805 (func_rva
>= data_start
&& func_rva
< data_end
)
2806 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
2807 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
2809 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
2811 /* Mark symbol type. */
2812 imp
->data
= is_data
;
2814 if (pe_dll_extra_pe_debug
)
2815 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2816 __FUNCTION__
, dll_name
, erva
+ name_rva
,
2817 (unsigned long) func_rva
, is_data
? "(data)" : "");
2824 /* These are the main functions, called from the emulation. The first
2825 is called after the bfds are read, so we can guess at how much space
2826 we need. The second is called after everything is placed, so we
2827 can put the right values in place. */
2830 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2832 pe_dll_id_target (bfd_get_target (abfd
));
2833 process_def_file (abfd
, info
);
2835 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
2838 generate_edata (abfd
, info
);
2839 build_filler_bfd (1);
2843 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2845 pe_dll_id_target (bfd_get_target (abfd
));
2846 build_filler_bfd (0);
2850 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2852 pe_dll_id_target (bfd_get_target (abfd
));
2853 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2855 generate_reloc (abfd
, info
);
2858 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2860 /* Resize the sections. */
2861 lang_reset_memory_regions ();
2862 lang_size_sections (NULL
, TRUE
);
2864 /* Redo special stuff. */
2865 ldemul_after_allocation ();
2867 /* Do the assignments again. */
2868 lang_do_assignments ();
2871 fill_edata (abfd
, info
);
2873 if (info
->shared
&& !info
->pie
)
2874 pe_data (abfd
)->dll
= 1;
2876 edata_s
->contents
= edata_d
;
2877 reloc_s
->contents
= reloc_d
;
2881 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2883 pe_dll_id_target (bfd_get_target (abfd
));
2884 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2886 generate_reloc (abfd
, info
);
2889 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2891 /* Resize the sections. */
2892 lang_reset_memory_regions ();
2893 lang_size_sections (NULL
, TRUE
);
2895 /* Redo special stuff. */
2896 ldemul_after_allocation ();
2898 /* Do the assignments again. */
2899 lang_do_assignments ();
2901 reloc_s
->contents
= reloc_d
;
2905 pe_bfd_is_dll (bfd
*abfd
)
2907 return (bfd_get_format (abfd
) == bfd_object
2909 && pe_data (abfd
)->dll
);