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"
46 #define PE_IDATA4_SIZE 8
47 #define PE_IDATA5_SIZE 8
50 #define AOUTSZ PEPAOUTSZ
51 #define PEAOUTHDR PEPAOUTHDR
59 #ifndef PE_IDATA4_SIZE
60 #define PE_IDATA4_SIZE 4
63 #ifndef PE_IDATA5_SIZE
64 #define PE_IDATA5_SIZE 4
67 /* This file turns a regular Windows PE image into a DLL. Because of
68 the complexity of this operation, it has been broken down into a
69 number of separate modules which are all called by the main function
70 at the end of this file. This function is not re-entrant and is
71 normally only called once, so static variables are used to reduce
72 the number of parameters and return values required.
74 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
76 /* Auto-import feature by Paul Sokolovsky
80 1. With this feature on, DLL clients can import variables from DLL
81 without any concern from their side (for example, without any source
84 2. This is done completely in bounds of the PE specification (to be fair,
85 there's a place where it pokes nose out of, but in practice it works).
86 So, resulting module can be used with any other PE compiler/linker.
88 3. Auto-import is fully compatible with standard import method and they
89 can be mixed together.
91 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
92 reference to it; load time: negligible; virtual/physical memory: should be
93 less than effect of DLL relocation, and I sincerely hope it doesn't affect
94 DLL sharability (too much).
98 The obvious and only way to get rid of dllimport insanity is to make client
99 access variable directly in the DLL, bypassing extra dereference. I.e.,
100 whenever client contains something like
104 address of dll_var in the command should be relocated to point into loaded
105 DLL. The aim is to make OS loader do so, and than make ld help with that.
106 Import section of PE made following way: there's a vector of structures
107 each describing imports from particular DLL. Each such structure points
108 to two other parallel vectors: one holding imported names, and one which
109 will hold address of corresponding imported name. So, the solution is
110 de-vectorize these structures, making import locations be sparse and
111 pointing directly into code. Before continuing, it is worth a note that,
112 while authors strives to make PE act ELF-like, there're some other people
113 make ELF act PE-like: elfvector, ;-) .
117 For each reference of data symbol to be imported from DLL (to set of which
118 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
119 import fixup entry is generated. That entry is of type
120 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
121 fixup entry contains pointer to symbol's address within .text section
122 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
123 (so, DLL name is referenced by multiple entries), and pointer to symbol
124 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
125 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
126 containing imported name. Here comes that "on the edge" problem mentioned
127 above: PE specification rambles that name vector (OriginalFirstThunk)
128 should run in parallel with addresses vector (FirstThunk), i.e. that they
129 should have same number of elements and terminated with zero. We violate
130 this, since FirstThunk points directly into machine code. But in practice,
131 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
132 puts addresses to FirstThunk, not something else. It once again should be
133 noted that dll and symbol name structures are reused across fixup entries
134 and should be there anyway to support standard import stuff, so sustained
135 overhead is 20 bytes per reference. Other question is whether having several
136 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
137 done even by native compiler/linker (libth32's functions are in fact reside
138 in windows9x kernel32.dll, so if you use it, you have two
139 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
140 referencing the same PE structures several times is valid. The answer is why
141 not, prohibiting that (detecting violation) would require more work on
142 behalf of loader than not doing it.
144 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
146 static void add_bfd_to_link (bfd
*, const char *, struct bfd_link_info
*);
148 /* For emultempl/pe.em. */
150 def_file
* pe_def_file
= 0;
151 int pe_dll_export_everything
= 0;
152 int pe_dll_do_default_excludes
= 1;
153 int pe_dll_kill_ats
= 0;
154 int pe_dll_stdcall_aliases
= 0;
155 int pe_dll_warn_dup_exports
= 0;
156 int pe_dll_compat_implib
= 0;
157 int pe_dll_extra_pe_debug
= 0;
159 /* Static variables and types. */
161 static bfd_vma image_base
;
162 static bfd
*filler_bfd
;
163 static struct bfd_section
*edata_s
, *reloc_s
;
164 static unsigned char *edata_d
, *reloc_d
;
165 static size_t edata_sz
, reloc_sz
;
166 static int runtime_pseudo_relocs_created
= 0;
167 static int runtime_pseudp_reloc_v2_init
= 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 ("libgcc_s") },
318 { STRING_COMMA_LEN ("libstdc++") },
319 { STRING_COMMA_LEN ("libmingw32") },
320 { STRING_COMMA_LEN ("libmingwex") },
321 { STRING_COMMA_LEN ("libg2c") },
322 { STRING_COMMA_LEN ("libsupc++") },
323 { STRING_COMMA_LEN ("libobjc") },
324 { STRING_COMMA_LEN ("libgcj") },
328 /* Regardless of the suffix issue mentioned above, we must ensure that
329 we do not falsely match on a leading substring, such as when libtool
330 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
331 This routine ensures that the leading part of the name matches and that
332 it is followed by only an optional version suffix and a file extension,
333 returning zero if so or -1 if not. */
334 static int libnamencmp (const char *libname
, const autofilter_entry_type
*afptr
)
336 if (strncmp (libname
, afptr
->name
, afptr
->len
))
339 libname
+= afptr
->len
;
341 /* Be liberal in interpreting what counts as a version suffix; we
342 accept anything that has a dash to separate it from the name and
343 begins with a digit. */
344 if (libname
[0] == '-')
346 if (!ISDIGIT (*++libname
))
348 /* Ensure the filename has an extension. */
349 while (*++libname
!= '.')
353 else if (libname
[0] != '.')
359 static const autofilter_entry_type autofilter_objlist
[] =
361 { STRING_COMMA_LEN ("crt0.o") },
362 { STRING_COMMA_LEN ("crt1.o") },
363 { STRING_COMMA_LEN ("crt2.o") },
364 { STRING_COMMA_LEN ("dllcrt1.o") },
365 { STRING_COMMA_LEN ("dllcrt2.o") },
366 { STRING_COMMA_LEN ("gcrt0.o") },
367 { STRING_COMMA_LEN ("gcrt1.o") },
368 { STRING_COMMA_LEN ("gcrt2.o") },
369 { STRING_COMMA_LEN ("crtbegin.o") },
370 { STRING_COMMA_LEN ("crtend.o") },
374 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
376 /* _imp_ is treated specially, as it is always underscored. */
377 /* { STRING_COMMA_LEN ("_imp_") }, */
378 /* Don't export some c++ symbols. */
379 { STRING_COMMA_LEN ("__rtti_") },
380 { STRING_COMMA_LEN ("__builtin_") },
381 /* Don't re-export auto-imported symbols. */
382 { STRING_COMMA_LEN ("_nm_") },
383 /* Don't export symbols specifying internal DLL layout. */
384 { STRING_COMMA_LEN ("_head_") },
385 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
386 /* Don't export section labels or artificial symbols
388 { STRING_COMMA_LEN (".") },
392 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
394 { STRING_COMMA_LEN ("_iname") },
395 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
399 #define U(str) (pe_details->underscored ? "_" str : str)
402 pe_dll_id_target (const char *target
)
406 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
407 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
408 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
410 pe_details
= pe_detail_list
+ i
;
413 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
417 /* Helper functions for qsort. Relocs must be sorted so that we can write
418 them out by pages. */
429 reloc_sort (const void *va
, const void *vb
)
431 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
432 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
434 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
438 pe_export_sort (const void *va
, const void *vb
)
440 const def_file_export
*a
= va
;
441 const def_file_export
*b
= vb
;
443 return strcmp (a
->name
, b
->name
);
446 /* Read and process the .DEF file. */
448 /* These correspond to the entries in pe_def_file->exports[]. I use
449 exported_symbol_sections[i] to tag whether or not the symbol was
450 defined, since we can't export symbols we don't have. */
452 static bfd_vma
*exported_symbol_offsets
;
453 static struct bfd_section
**exported_symbol_sections
;
454 static int export_table_size
;
455 static int count_exported
;
456 static int count_exported_byname
;
457 static int count_with_ordinals
;
458 static const char *dll_name
;
459 static int min_ordinal
, max_ordinal
;
460 static int *exported_symbols
;
462 typedef struct exclude_list_struct
465 struct exclude_list_struct
*next
;
470 static struct exclude_list_struct
*excludes
= 0;
473 pe_dll_add_excludes (const char *new_excludes
, const int type
)
476 char *exclude_string
;
478 local_copy
= xstrdup (new_excludes
);
480 exclude_string
= strtok (local_copy
, ",:");
481 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
483 struct exclude_list_struct
*new_exclude
;
485 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
486 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
487 strcpy (new_exclude
->string
, exclude_string
);
488 new_exclude
->type
= type
;
489 new_exclude
->next
= excludes
;
490 excludes
= new_exclude
;
497 is_import (const char* n
)
499 return (CONST_STRNEQ (n
, "__imp_"));
502 /* abfd is a bfd containing n (or NULL)
503 It can be used for contextual checks. */
506 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
509 struct exclude_list_struct
*ex
;
510 const autofilter_entry_type
*afptr
;
511 const char * libname
= 0;
512 if (abfd
&& abfd
->my_archive
)
513 libname
= lbasename (abfd
->my_archive
->filename
);
515 for (i
= 0; i
< d
->num_exports
; i
++)
516 if (strcmp (d
->exports
[i
].name
, n
) == 0)
519 if (pe_dll_do_default_excludes
)
524 if (pe_dll_extra_pe_debug
)
525 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
526 n
, abfd
, abfd
->my_archive
);
528 /* First of all, make context checks:
529 Don't export anything from standard libs. */
532 afptr
= autofilter_liblist
;
536 if (libnamencmp (libname
, afptr
) == 0 )
542 /* Next, exclude symbols from certain startup objects. */
544 if (abfd
&& (p
= lbasename (abfd
->filename
)))
546 afptr
= autofilter_objlist
;
549 if (strcmp (p
, afptr
->name
) == 0)
555 /* Don't try to blindly exclude all symbols
556 that begin with '__'; this was tried and
557 it is too restrictive. Instead we have
558 a target specific list to use: */
559 afptr
= pe_details
->autofilter_symbollist
;
563 if (strcmp (n
, afptr
->name
) == 0)
569 /* Next, exclude symbols starting with ... */
570 afptr
= autofilter_symbolprefixlist
;
573 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
579 /* Finally, exclude symbols ending with ... */
581 afptr
= autofilter_symbolsuffixlist
;
584 if ((len
>= afptr
->len
)
585 /* Add 1 to insure match with trailing '\0'. */
586 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
587 afptr
->len
+ 1) == 0)
594 for (ex
= excludes
; ex
; ex
= ex
->next
)
596 if (ex
->type
== 1) /* exclude-libs */
599 && ((strcmp (libname
, ex
->string
) == 0)
600 || (strcasecmp ("ALL", ex
->string
) == 0)))
603 else if (strcmp (n
, ex
->string
) == 0)
611 process_def_file (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
614 struct bfd_link_hash_entry
*blhe
;
616 struct bfd_section
*s
;
617 def_file_export
*e
= 0;
620 pe_def_file
= def_file_empty ();
622 /* First, run around to all the objects looking for the .drectve
623 sections, and push those into the def file too. */
624 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
626 s
= bfd_get_section_by_name (b
, ".drectve");
630 char *buf
= xmalloc (size
);
632 bfd_get_section_contents (b
, s
, buf
, 0, size
);
633 def_file_add_directive (pe_def_file
, buf
, size
);
638 /* If we are not building a DLL, when there are no exports
639 we do not build an export table at all. */
640 if (!pe_dll_export_everything
&& pe_def_file
->num_exports
== 0
644 /* Now, maybe export everything else the default way. */
645 if (pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
647 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
652 if (!bfd_generic_link_read_symbols (b
))
654 einfo (_("%B%F: could not read symbols: %E\n"), b
);
658 symbols
= bfd_get_outsymbols (b
);
659 nsyms
= bfd_get_symcount (b
);
661 for (j
= 0; j
< nsyms
; j
++)
663 /* We should export symbols which are either global or not
664 anything at all. (.bss data is the latter)
665 We should not export undefined symbols. */
666 if (symbols
[j
]->section
!= &bfd_und_section
667 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
668 || (symbols
[j
]->flags
== 0)))
670 const char *sn
= symbols
[j
]->name
;
672 /* We should not re-export imported stuff. */
678 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
679 sprintf (name
, "%s%s", "__imp_", sn
);
681 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
682 FALSE
, FALSE
, FALSE
);
685 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
689 if (pe_details
->underscored
&& *sn
== '_')
692 if (auto_export (b
, pe_def_file
, sn
))
695 p
=def_file_add_export (pe_def_file
, sn
, 0, -1);
696 /* Fill data flag properly, from dlltool.c. */
697 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
705 #define NE pe_def_file->num_exports
707 /* Canonicalize the export list. */
710 for (i
= 0; i
< NE
; i
++)
712 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
714 /* This will preserve internal_name, which may have been
715 pointing to the same memory as name, or might not
717 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
718 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
719 char *tmp_at
= strchr (tmp
, '@');
724 einfo (_("%XCannot export %s: invalid export name\n"),
725 pe_def_file
->exports
[i
].name
);
726 pe_def_file
->exports
[i
].name
= tmp
;
731 if (pe_dll_stdcall_aliases
)
733 for (i
= 0; i
< NE
; i
++)
735 if (is_import (pe_def_file
->exports
[i
].name
))
738 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
740 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
741 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
743 *(strchr (tmp
, '@')) = 0;
744 if (auto_export (NULL
, pe_def_file
, tmp
))
745 def_file_add_export (pe_def_file
, tmp
,
746 pe_def_file
->exports
[i
].internal_name
,
754 /* Convenience, but watch out for it changing. */
755 e
= pe_def_file
->exports
;
757 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
758 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
760 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
764 count_exported_byname
= 0;
765 count_with_ordinals
= 0;
767 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
769 for (i
= 0, j
= 0; i
< NE
; i
++)
771 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
773 /* This is a duplicate. */
774 if (e
[j
- 1].ordinal
!= -1
775 && e
[i
].ordinal
!= -1
776 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
778 if (pe_dll_warn_dup_exports
)
779 /* xgettext:c-format */
780 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
781 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
785 if (pe_dll_warn_dup_exports
)
786 /* xgettext:c-format */
787 einfo (_("Warning, duplicate EXPORT: %s\n"),
791 if (e
[i
].ordinal
!= -1)
792 e
[j
- 1].ordinal
= e
[i
].ordinal
;
793 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
794 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
795 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
796 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
805 pe_def_file
->num_exports
= j
; /* == NE */
807 for (i
= 0; i
< NE
; i
++)
811 /* Check for forward exports */
812 if (strchr (pe_def_file
->exports
[i
].internal_name
, '.'))
815 if (!pe_def_file
->exports
[i
].flag_noname
)
816 count_exported_byname
++;
818 pe_def_file
->exports
[i
].flag_forward
= 1;
820 if (pe_def_file
->exports
[i
].ordinal
!= -1)
822 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
823 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
824 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
825 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
826 count_with_ordinals
++;
832 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
833 if (pe_details
->underscored
834 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
837 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
840 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
842 blhe
= bfd_link_hash_lookup (info
->hash
,
847 && (blhe
->type
== bfd_link_hash_defined
848 || (blhe
->type
== bfd_link_hash_common
)))
851 if (!pe_def_file
->exports
[i
].flag_noname
)
852 count_exported_byname
++;
854 /* Only fill in the sections. The actual offsets are computed
855 in fill_exported_offsets() after common symbols are laid
857 if (blhe
->type
== bfd_link_hash_defined
)
858 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
860 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
862 if (pe_def_file
->exports
[i
].ordinal
!= -1)
864 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
865 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
866 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
867 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
868 count_with_ordinals
++;
871 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
873 /* xgettext:c-format */
874 einfo (_("%XCannot export %s: symbol not defined\n"),
875 pe_def_file
->exports
[i
].internal_name
);
879 /* xgettext:c-format */
880 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
881 pe_def_file
->exports
[i
].internal_name
,
882 blhe
->type
, bfd_link_hash_defined
);
886 /* xgettext:c-format */
887 einfo (_("%XCannot export %s: symbol not found\n"),
888 pe_def_file
->exports
[i
].internal_name
);
894 /* Build the bfd that will contain .edata and .reloc sections. */
897 build_filler_bfd (int include_edata
)
899 lang_input_statement_type
*filler_file
;
900 filler_file
= lang_add_input_file ("dll stuff",
901 lang_input_file_is_fake_enum
,
903 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff",
904 link_info
.output_bfd
);
905 if (filler_bfd
== NULL
906 || !bfd_set_arch_mach (filler_bfd
,
907 bfd_get_arch (link_info
.output_bfd
),
908 bfd_get_mach (link_info
.output_bfd
)))
910 einfo ("%X%P: can not create BFD: %E\n");
916 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
918 || !bfd_set_section_flags (filler_bfd
, edata_s
,
925 einfo ("%X%P: can not create .edata section: %E\n");
928 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
931 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
933 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
940 einfo ("%X%P: can not create .reloc section: %E\n");
944 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
946 ldlang_add_file (filler_file
);
949 /* Gather all the exported symbols and build the .edata section. */
952 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
955 int name_table_size
= 0;
958 /* First, we need to know how many exported symbols there are,
959 and what the range of ordinals is. */
960 if (pe_def_file
->name
)
961 dll_name
= pe_def_file
->name
;
964 dll_name
= abfd
->filename
;
966 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
967 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
971 if (count_with_ordinals
&& max_ordinal
> count_exported
)
973 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
974 min_ordinal
= max_ordinal
- count_exported
+ 1;
979 max_ordinal
= count_exported
;
982 export_table_size
= max_ordinal
- min_ordinal
+ 1;
983 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
984 for (i
= 0; i
< export_table_size
; i
++)
985 exported_symbols
[i
] = -1;
987 /* Now we need to assign ordinals to those that don't have them. */
988 for (i
= 0; i
< NE
; i
++)
990 if (exported_symbol_sections
[i
] ||
991 pe_def_file
->exports
[i
].flag_forward
)
993 if (pe_def_file
->exports
[i
].ordinal
!= -1)
995 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
996 int pi
= exported_symbols
[ei
];
1000 /* xgettext:c-format */
1001 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1002 pe_def_file
->exports
[i
].ordinal
,
1003 pe_def_file
->exports
[i
].name
,
1004 pe_def_file
->exports
[pi
].name
);
1006 exported_symbols
[ei
] = i
;
1008 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
1011 /* Reserve space for the forward name. */
1012 if (pe_def_file
->exports
[i
].flag_forward
)
1014 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
1018 next_ordinal
= min_ordinal
;
1019 for (i
= 0; i
< NE
; i
++)
1020 if ((exported_symbol_sections
[i
] ||
1021 pe_def_file
->exports
[i
].flag_forward
) &&
1022 pe_def_file
->exports
[i
].ordinal
== -1)
1024 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
1027 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
1028 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
1031 /* OK, now we can allocate some memory. */
1032 edata_sz
= (40 /* directory */
1033 + 4 * export_table_size
/* addresses */
1034 + 4 * count_exported_byname
/* name ptrs */
1035 + 2 * count_exported_byname
/* ordinals */
1036 + name_table_size
+ strlen (dll_name
) + 1);
1039 /* Fill the exported symbol offsets. The preliminary work has already
1040 been done in process_def_file(). */
1043 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
1046 struct bfd_link_hash_entry
*blhe
;
1048 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1052 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1053 if (pe_details
->underscored
1054 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1057 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1060 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1062 blhe
= bfd_link_hash_lookup (info
->hash
,
1064 FALSE
, FALSE
, TRUE
);
1066 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1067 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1074 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1077 unsigned char *edirectory
;
1078 unsigned char *eaddresses
;
1079 unsigned char *enameptrs
;
1080 unsigned char *eordinals
;
1086 edata_d
= xmalloc (edata_sz
);
1088 /* Note use of array pointer math here. */
1089 edirectory
= edata_d
;
1090 eaddresses
= edata_d
+ 40;
1091 enameptrs
= eaddresses
+ 4 * export_table_size
;
1092 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1093 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1095 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1096 + edata_s->output_section->vma - image_base)
1098 memset (edata_d
, 0, edata_sz
);
1099 bfd_put_32 (abfd
, now
, edata_d
+ 4);
1100 if (pe_def_file
->version_major
!= -1)
1102 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1103 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1106 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1107 strcpy (enamestr
, dll_name
);
1108 enamestr
+= strlen (enamestr
) + 1;
1109 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1110 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1111 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1112 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1113 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1114 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1116 fill_exported_offsets (abfd
, info
);
1118 /* Ok, now for the filling in part.
1119 Scan alphabetically - ie the ordering in the exports[] table,
1120 rather than by ordinal - the ordering in the exported_symbol[]
1121 table. See dlltool.c and:
1122 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1123 for more information. */
1125 for (s
= 0; s
< NE
; s
++)
1127 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1128 if (pe_def_file
->exports
[s
].ordinal
!= -1 &&
1129 (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1131 int ord
= pe_def_file
->exports
[s
].ordinal
;
1133 if (pe_def_file
->exports
[s
].flag_forward
)
1135 bfd_put_32 (abfd
, ERVA (enamestr
),
1136 eaddresses
+ 4 * (ord
- min_ordinal
));
1138 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1139 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1143 bfd_vma srva
= (exported_symbol_offsets
[s
]
1144 + ssec
->output_section
->vma
1145 + ssec
->output_offset
);
1147 bfd_put_32 (abfd
, srva
- image_base
,
1148 eaddresses
+ 4 * (ord
- min_ordinal
));
1151 if (!pe_def_file
->exports
[s
].flag_noname
)
1153 char *ename
= pe_def_file
->exports
[s
].name
;
1155 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1157 strcpy (enamestr
, ename
);
1158 enamestr
+= strlen (enamestr
) + 1;
1159 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1161 pe_def_file
->exports
[s
].hint
= hint
++;
1168 static struct bfd_section
*current_sec
;
1171 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1173 int (*cb
) (arelent
*, asection
*))
1178 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1183 if (!bfd_generic_link_read_symbols (b
))
1185 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1189 symbols
= bfd_get_outsymbols (b
);
1190 nsyms
= bfd_get_symcount (b
);
1192 for (s
= b
->sections
; s
; s
= s
->next
)
1195 int relsize
, nrelocs
, i
;
1196 int flags
= bfd_get_section_flags (b
, s
);
1198 /* Skip discarded linkonce sections. */
1199 if (flags
& SEC_LINK_ONCE
1200 && s
->output_section
== bfd_abs_section_ptr
)
1205 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1206 relocs
= xmalloc (relsize
);
1207 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1209 for (i
= 0; i
< nrelocs
; i
++)
1211 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1213 if (!strcmp (name
, sym
->name
))
1219 /* Warning: the allocated symbols are remembered in BFD and reused
1220 later, so don't free them! */
1221 /* free (symbols); */
1226 /* Gather all the relocations and build the .reloc section. */
1229 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1232 /* For .reloc stuff. */
1233 reloc_data_type
*reloc_data
;
1234 int total_relocs
= 0;
1236 bfd_vma sec_page
= (bfd_vma
) -1;
1237 bfd_vma page_ptr
, page_count
;
1240 struct bfd_section
*s
;
1243 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1244 for (s
= b
->sections
; s
; s
= s
->next
)
1245 total_relocs
+= s
->reloc_count
;
1247 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1251 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1254 int relsize
, nrelocs
, i
;
1256 for (s
= b
->sections
; s
; s
= s
->next
)
1258 bfd_vma sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1262 /* If it's not loaded, we don't need to relocate it this way. */
1263 if (!(s
->output_section
->flags
& SEC_LOAD
))
1266 /* I don't know why there would be a reloc for these, but I've
1267 seen it happen - DJ */
1268 if (s
->output_section
== &bfd_abs_section
)
1271 if (s
->output_section
->vma
== 0)
1273 /* Huh? Shouldn't happen, but punt if it does. */
1274 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1275 s
->output_section
->name
, s
->output_section
->index
,
1276 s
->output_section
->flags
);
1280 if (!bfd_generic_link_read_symbols (b
))
1282 einfo (_("%B%F: could not read symbols: %E\n"), b
);
1286 symbols
= bfd_get_outsymbols (b
);
1287 nsyms
= bfd_get_symcount (b
);
1288 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1289 relocs
= xmalloc (relsize
);
1290 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1292 for (i
= 0; i
< nrelocs
; i
++)
1294 if (pe_dll_extra_pe_debug
)
1296 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1297 printf ("rel: %s\n", sym
->name
);
1299 if (!relocs
[i
]->howto
->pc_relative
1300 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1303 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1305 /* Don't create relocs for undefined weak symbols. */
1306 if (sym
->flags
== BSF_WEAK
)
1308 struct bfd_link_hash_entry
*blhe
1309 = bfd_link_hash_lookup (info
->hash
, sym
->name
,
1310 FALSE
, FALSE
, FALSE
);
1311 if (!blhe
|| blhe
->type
!= bfd_link_hash_defined
)
1315 sym_vma
= (relocs
[i
]->addend
1318 + sym
->section
->output_offset
1319 + sym
->section
->output_section
->vma
);
1320 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1322 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1324 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1325 relocs
[i
]->howto
->rightshift
)
1327 #ifdef pe_use_x86_64
1328 case BITS_AND_SHIFT (64, 0):
1329 reloc_data
[total_relocs
].type
= 10;
1333 case BITS_AND_SHIFT (32, 0):
1334 reloc_data
[total_relocs
].type
= 3;
1337 case BITS_AND_SHIFT (16, 0):
1338 reloc_data
[total_relocs
].type
= 2;
1341 case BITS_AND_SHIFT (16, 16):
1342 reloc_data
[total_relocs
].type
= 4;
1343 /* FIXME: we can't know the symbol's right value
1344 yet, but we probably can safely assume that
1345 CE will relocate us in 64k blocks, so leaving
1347 reloc_data
[total_relocs
].extra
= 0;
1350 case BITS_AND_SHIFT (26, 2):
1351 reloc_data
[total_relocs
].type
= 5;
1354 case BITS_AND_SHIFT (24, 2):
1355 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1356 Those ARM_xxx definitions should go in proper
1358 if (relocs
[i
]->howto
->type
== 0
1359 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1360 || relocs
[i
]->howto
->type
== 5)
1361 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1362 that has already been fully processed during a
1363 previous link stage, so ignore it here. */
1367 /* xgettext:c-format */
1368 einfo (_("%XError: %d-bit reloc in dll\n"),
1369 relocs
[i
]->howto
->bitsize
);
1375 /* Warning: the allocated symbols are remembered in BFD and
1376 reused later, so don't free them! */
1380 /* At this point, we have total_relocs relocation addresses in
1381 reloc_addresses, which are all suitable for the .reloc section.
1382 We must now create the new sections. */
1383 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1385 for (i
= 0; i
< total_relocs
; i
++)
1387 bfd_vma this_page
= (reloc_data
[i
].vma
>> 12);
1389 if (this_page
!= sec_page
)
1391 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1393 sec_page
= this_page
;
1398 if (reloc_data
[i
].type
== 4)
1402 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1403 reloc_d
= xmalloc (reloc_sz
);
1404 sec_page
= (bfd_vma
) -1;
1406 page_ptr
= (bfd_vma
) -1;
1409 for (i
= 0; i
< total_relocs
; i
++)
1411 bfd_vma rva
= reloc_data
[i
].vma
- image_base
;
1412 bfd_vma this_page
= (rva
& ~0xfff);
1414 if (this_page
!= sec_page
)
1416 while (reloc_sz
& 3)
1417 reloc_d
[reloc_sz
++] = 0;
1419 if (page_ptr
!= (bfd_vma
) -1)
1420 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1422 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1423 page_ptr
= reloc_sz
;
1425 sec_page
= this_page
;
1429 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1430 reloc_d
+ reloc_sz
);
1433 if (reloc_data
[i
].type
== 4)
1435 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1442 while (reloc_sz
& 3)
1443 reloc_d
[reloc_sz
++] = 0;
1445 if (page_ptr
!= (bfd_vma
) -1)
1446 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1448 while (reloc_sz
< reloc_s
->size
)
1449 reloc_d
[reloc_sz
++] = 0;
1452 /* Given the exiting def_file structure, print out a .DEF file that
1453 corresponds to it. */
1456 quoteput (char *s
, FILE *f
, int needs_quotes
)
1460 for (cp
= s
; *cp
; cp
++)
1475 if (*s
== '"' || *s
== '\\')
1489 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1492 FILE *out
= fopen (pe_out_def_filename
, "w");
1495 /* xgettext:c-format */
1496 einfo (_("%s: Can't open output def file %s\n"),
1497 program_name
, pe_out_def_filename
);
1501 if (pe_def_file
->name
)
1503 if (pe_def_file
->is_dll
)
1504 fprintf (out
, "LIBRARY ");
1506 fprintf (out
, "NAME ");
1508 quoteput (pe_def_file
->name
, out
, 1);
1510 if (pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
)
1512 fprintf (out
, " BASE=0x");
1513 fprintf_vma (out
, ((bfd_vma
) pe_data (link_info
.output_bfd
)->pe_opthdr
.ImageBase
));
1515 fprintf (out
, "\n");
1518 if (pe_def_file
->description
)
1520 fprintf (out
, "DESCRIPTION ");
1521 quoteput (pe_def_file
->description
, out
, 1);
1522 fprintf (out
, "\n");
1525 if (pe_def_file
->version_minor
!= -1)
1526 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1527 pe_def_file
->version_minor
);
1528 else if (pe_def_file
->version_major
!= -1)
1529 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1531 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1532 fprintf (out
, "\n");
1534 if (pe_def_file
->stack_commit
!= -1)
1535 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1536 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1537 else if (pe_def_file
->stack_reserve
!= -1)
1538 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1540 if (pe_def_file
->heap_commit
!= -1)
1541 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1542 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1543 else if (pe_def_file
->heap_reserve
!= -1)
1544 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1546 if (pe_def_file
->num_section_defs
> 0)
1548 fprintf (out
, "\nSECTIONS\n\n");
1550 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1553 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1555 if (pe_def_file
->section_defs
[i
].class)
1557 fprintf (out
, " CLASS ");
1558 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1561 if (pe_def_file
->section_defs
[i
].flag_read
)
1562 fprintf (out
, " READ");
1564 if (pe_def_file
->section_defs
[i
].flag_write
)
1565 fprintf (out
, " WRITE");
1567 if (pe_def_file
->section_defs
[i
].flag_execute
)
1568 fprintf (out
, " EXECUTE");
1570 if (pe_def_file
->section_defs
[i
].flag_shared
)
1571 fprintf (out
, " SHARED");
1573 fprintf (out
, "\n");
1577 if (pe_def_file
->num_exports
> 0)
1579 fprintf (out
, "EXPORTS\n");
1581 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1583 def_file_export
*e
= pe_def_file
->exports
+ i
;
1585 quoteput (e
->name
, out
, 0);
1587 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1589 fprintf (out
, " = ");
1590 quoteput (e
->internal_name
, out
, 0);
1593 if (e
->ordinal
!= -1)
1594 fprintf (out
, " @%d", e
->ordinal
);
1596 if (e
->flag_private
)
1597 fprintf (out
, " PRIVATE");
1599 if (e
->flag_constant
)
1600 fprintf (out
, " CONSTANT");
1603 fprintf (out
, " NONAME");
1606 fprintf (out
, " DATA");
1608 fprintf (out
, "\n");
1612 if (pe_def_file
->num_imports
> 0)
1614 fprintf (out
, "\nIMPORTS\n\n");
1616 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1618 def_file_import
*im
= pe_def_file
->imports
+ i
;
1621 if (im
->internal_name
1622 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1624 quoteput (im
->internal_name
, out
, 0);
1625 fprintf (out
, " = ");
1628 quoteput (im
->module
->name
, out
, 0);
1632 quoteput (im
->name
, out
, 0);
1634 fprintf (out
, "%d", im
->ordinal
);
1636 fprintf (out
, "\n");
1641 fprintf (out
, _("; no contents available\n"));
1643 if (fclose (out
) == EOF
)
1644 /* xgettext:c-format */
1645 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1648 /* Generate the import library. */
1650 static asymbol
**symtab
;
1653 static const char *dll_filename
;
1654 static char *dll_symname
;
1656 #define UNDSEC (asection *) &bfd_und_section
1659 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1664 sec
= bfd_make_section_old_way (abfd
, name
);
1665 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1666 bfd_set_section_alignment (abfd
, sec
, align
);
1667 /* Remember to undo this before trying to link internally! */
1668 sec
->output_section
= sec
;
1670 sym
= bfd_make_empty_symbol (abfd
);
1671 symtab
[symptr
++] = sym
;
1672 sym
->name
= sec
->name
;
1674 sym
->flags
= BSF_LOCAL
;
1681 quick_symbol (bfd
*abfd
,
1690 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1695 sym
= bfd_make_empty_symbol (abfd
);
1700 symtab
[symptr
++] = sym
;
1703 static arelent
*reltab
= 0;
1704 static int relcount
= 0, relsize
= 0;
1707 quick_reloc (bfd
*abfd
, bfd_size_type address
, int which_howto
, int symidx
)
1709 if (relcount
>= relsize
- 1)
1713 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1715 reltab
= xmalloc (relsize
* sizeof (arelent
));
1717 reltab
[relcount
].address
= address
;
1718 reltab
[relcount
].addend
= 0;
1719 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1720 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1725 save_relocs (asection
*sec
)
1729 sec
->relocation
= reltab
;
1730 sec
->reloc_count
= relcount
;
1731 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1732 for (i
= 0; i
< relcount
; i
++)
1733 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1734 sec
->orelocation
[relcount
] = 0;
1735 sec
->flags
|= SEC_RELOC
;
1737 relcount
= relsize
= 0;
1740 /* .section .idata$2
1741 .global __head_my_dll
1758 make_head (bfd
*parent
)
1760 asection
*id2
, *id5
, *id4
;
1761 unsigned char *d2
, *d5
, *d4
;
1765 oname
= xmalloc (20);
1766 sprintf (oname
, "d%06d.o", tmp_seq
);
1769 abfd
= bfd_create (oname
, parent
);
1770 bfd_find_target (pe_details
->object_target
, abfd
);
1771 bfd_make_writable (abfd
);
1773 bfd_set_format (abfd
, bfd_object
);
1774 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1777 symtab
= xmalloc (6 * sizeof (asymbol
*));
1778 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1779 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1780 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1781 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1782 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1784 /* OK, pay attention here. I got confused myself looking back at
1785 it. We create a four-byte section to mark the beginning of the
1786 list, and we include an offset of 4 in the section, so that the
1787 pointer to the list points to the *end* of this section, which is
1788 the start of the list of sections from other objects. */
1790 bfd_set_section_size (abfd
, id2
, 20);
1794 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
1795 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1796 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1797 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1800 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1801 d5
= xmalloc (PE_IDATA5_SIZE
);
1803 memset (d5
, 0, PE_IDATA5_SIZE
);
1805 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1806 d4
= xmalloc (PE_IDATA4_SIZE
);
1808 memset (d4
, 0, PE_IDATA4_SIZE
);
1810 bfd_set_symtab (abfd
, symtab
, symptr
);
1812 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1813 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1814 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1816 bfd_make_readable (abfd
);
1820 /* .section .idata$4
1827 .global __my_dll_iname
1832 make_tail (bfd
*parent
)
1834 asection
*id4
, *id5
, *id7
;
1835 unsigned char *d4
, *d5
, *d7
;
1840 oname
= xmalloc (20);
1841 sprintf (oname
, "d%06d.o", tmp_seq
);
1844 abfd
= bfd_create (oname
, parent
);
1845 bfd_find_target (pe_details
->object_target
, abfd
);
1846 bfd_make_writable (abfd
);
1848 bfd_set_format (abfd
, bfd_object
);
1849 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1852 symtab
= xmalloc (5 * sizeof (asymbol
*));
1853 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1854 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1855 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1856 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1858 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1859 d4
= xmalloc (PE_IDATA4_SIZE
);
1861 memset (d4
, 0, PE_IDATA4_SIZE
);
1863 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1864 d5
= xmalloc (PE_IDATA5_SIZE
);
1866 memset (d5
, 0, PE_IDATA5_SIZE
);
1868 len
= strlen (dll_filename
) + 1;
1871 bfd_set_section_size (abfd
, id7
, len
);
1874 strcpy ((char *) d7
, dll_filename
);
1875 /* If len was odd, the above
1876 strcpy leaves behind an undefined byte. That is harmless,
1877 but we set it to 0 just so the binary dumps are pretty. */
1880 bfd_set_symtab (abfd
, symtab
, symptr
);
1882 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1883 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1884 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1886 bfd_make_readable (abfd
);
1892 .global ___imp_function
1893 .global __imp__function
1895 jmp *__imp__function:
1909 .asciz "function" xlate? (add underscore, kill at) */
1911 static const unsigned char jmp_ix86_bytes
[] =
1913 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1921 .dw __imp_function */
1923 static const unsigned char jmp_sh_bytes
[] =
1925 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1929 lui $t0,<high:__imp_function>
1930 lw $t0,<low:__imp_function>
1934 static const unsigned char jmp_mips_bytes
[] =
1936 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1937 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1940 static const unsigned char jmp_arm_bytes
[] =
1942 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1943 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1949 make_one (def_file_export
*exp
, bfd
*parent
, bfd_boolean include_jmp_stub
)
1951 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1952 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1956 const unsigned char *jmp_bytes
= NULL
;
1957 int jmp_byte_count
= 0;
1959 /* Include the jump stub section only if it is needed. A jump
1960 stub is needed if the symbol being imported <sym> is a function
1961 symbol and there is at least one undefined reference to that
1962 symbol. In other words, if all the import references to <sym> are
1963 explicitly through _declspec(dllimport) then the jump stub is not
1965 if (include_jmp_stub
)
1967 switch (pe_details
->pe_arch
)
1970 jmp_bytes
= jmp_ix86_bytes
;
1971 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1974 jmp_bytes
= jmp_sh_bytes
;
1975 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1978 jmp_bytes
= jmp_mips_bytes
;
1979 jmp_byte_count
= sizeof (jmp_mips_bytes
);
1982 case PE_ARCH_arm_epoc
:
1983 case PE_ARCH_arm_wince
:
1984 jmp_bytes
= jmp_arm_bytes
;
1985 jmp_byte_count
= sizeof (jmp_arm_bytes
);
1992 oname
= xmalloc (20);
1993 sprintf (oname
, "d%06d.o", tmp_seq
);
1996 abfd
= bfd_create (oname
, parent
);
1997 bfd_find_target (pe_details
->object_target
, abfd
);
1998 bfd_make_writable (abfd
);
2000 bfd_set_format (abfd
, bfd_object
);
2001 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2004 symtab
= xmalloc (11 * sizeof (asymbol
*));
2005 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
2006 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
2007 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
2008 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2009 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
2011 if (*exp
->internal_name
== '@')
2013 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2015 if (include_jmp_stub
)
2016 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
2017 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
2019 /* Fastcall applies only to functions,
2020 so no need for auto-import symbol. */
2024 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
2026 if (include_jmp_stub
)
2027 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
2029 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
2031 /* Symbol to reference ord/name of imported
2032 data symbol, used to implement auto-import. */
2034 quick_symbol (abfd
, U ("_nm_"), U (""), exp
->internal_name
, id6
,
2037 if (pe_dll_compat_implib
)
2038 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "", id5
,
2041 if (include_jmp_stub
)
2043 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
2044 td
= xmalloc (jmp_byte_count
);
2046 memcpy (td
, jmp_bytes
, jmp_byte_count
);
2048 switch (pe_details
->pe_arch
)
2051 #ifdef pe_use_x86_64
2052 quick_reloc (abfd
, 2, BFD_RELOC_32_PCREL
, 2);
2054 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
2058 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2061 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
2062 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
2063 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
2066 case PE_ARCH_arm_epoc
:
2067 case PE_ARCH_arm_wince
:
2068 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
2076 bfd_set_section_size (abfd
, tx
, 0);
2078 bfd_set_section_size (abfd
, id7
, 4);
2082 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
2085 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
2086 d5
= xmalloc (PE_IDATA5_SIZE
);
2088 memset (d5
, 0, PE_IDATA5_SIZE
);
2090 if (exp
->flag_noname
)
2092 d5
[0] = exp
->ordinal
;
2093 d5
[1] = exp
->ordinal
>> 8;
2094 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2098 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2102 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2103 d4
= xmalloc (PE_IDATA4_SIZE
);
2105 memset (d4
, 0, PE_IDATA4_SIZE
);
2107 if (exp
->flag_noname
)
2109 d4
[0] = exp
->ordinal
;
2110 d4
[1] = exp
->ordinal
>> 8;
2111 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2115 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2119 if (exp
->flag_noname
)
2122 bfd_set_section_size (abfd
, id6
, 0);
2126 /* { short, asciz } */
2127 len
= 2 + strlen (exp
->name
) + 1;
2130 bfd_set_section_size (abfd
, id6
, len
);
2133 memset (d6
, 0, len
);
2134 d6
[0] = exp
->hint
& 0xff;
2135 d6
[1] = exp
->hint
>> 8;
2136 strcpy ((char *) d6
+ 2, exp
->name
);
2139 bfd_set_symtab (abfd
, symtab
, symptr
);
2141 if (include_jmp_stub
)
2142 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2143 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2144 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2145 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2146 if (!exp
->flag_noname
)
2147 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2149 bfd_make_readable (abfd
);
2154 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2156 /* Name thunks go to idata$4. */
2162 oname
= xmalloc (20);
2163 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2166 abfd
= bfd_create (oname
, parent
);
2167 bfd_find_target (pe_details
->object_target
, abfd
);
2168 bfd_make_writable (abfd
);
2170 bfd_set_format (abfd
, bfd_object
);
2171 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2174 symtab
= xmalloc (3 * sizeof (asymbol
*));
2175 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2176 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
2177 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2179 /* We need space for the real thunk and for the null terminator. */
2180 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2181 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2183 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2184 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2187 bfd_set_symtab (abfd
, symtab
, symptr
);
2189 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2191 bfd_make_readable (abfd
);
2196 make_import_fixup_mark (arelent
*rel
)
2198 /* We convert reloc to symbol, for later reference. */
2200 static char *fixup_name
= NULL
;
2201 static size_t buffer_len
= 0;
2203 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2205 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2206 struct bfd_link_hash_entry
*bh
;
2210 fixup_name
= xmalloc (384);
2214 if (strlen (sym
->name
) + 25 > buffer_len
)
2215 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2216 bigger than 20 digits long, we've got worse problems than
2217 overflowing this buffer... */
2220 /* New buffer size is length of symbol, plus 25, but
2221 then rounded up to the nearest multiple of 128. */
2222 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2223 fixup_name
= xmalloc (buffer_len
);
2226 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2229 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2230 current_sec
, /* sym->section, */
2231 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2236 /* .section .idata$2
2237 .rva __nm_thnk_SYM (singleton thunk with name of func)
2240 .rva __my_dll_iname (name of dll)
2241 .rva __fuNN_SYM (pointer to reference (address) in text) */
2244 make_import_fixup_entry (const char *name
,
2245 const char *fixup_name
,
2246 const char *dll_symname
,
2254 oname
= xmalloc (20);
2255 sprintf (oname
, "fu%06d.o", tmp_seq
);
2258 abfd
= bfd_create (oname
, parent
);
2259 bfd_find_target (pe_details
->object_target
, abfd
);
2260 bfd_make_writable (abfd
);
2262 bfd_set_format (abfd
, bfd_object
);
2263 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2266 symtab
= xmalloc (6 * sizeof (asymbol
*));
2267 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2269 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2270 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2271 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2273 bfd_set_section_size (abfd
, id2
, 20);
2277 d2
[0] = d2
[16] = PE_IDATA5_SIZE
; /* Reloc addend. */
2279 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2280 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2281 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2284 bfd_set_symtab (abfd
, symtab
, symptr
);
2286 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2288 bfd_make_readable (abfd
);
2292 /* .section .rdata_runtime_pseudo_reloc
2294 .rva __fuNN_SYM (pointer to reference (address) in text) */
2297 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2298 const char *fixup_name
,
2299 bfd_vma addend ATTRIBUTE_UNUSED
,
2304 unsigned char *rt_rel_d
;
2307 oname
= xmalloc (20);
2308 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2311 abfd
= bfd_create (oname
, parent
);
2312 bfd_find_target (pe_details
->object_target
, abfd
);
2313 bfd_make_writable (abfd
);
2315 bfd_set_format (abfd
, bfd_object
);
2316 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2319 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2321 symtab
= xmalloc ((runtime_pseudp_reloc_v2_init
? 3 : 6) * sizeof (asymbol
*));
2325 symtab
= xmalloc (2 * sizeof (asymbol
*));
2327 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2328 SEC_HAS_CONTENTS
, 2);
2330 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2332 if (link_info
.pei386_runtime_pseudo_reloc
== 2)
2335 if (! runtime_pseudp_reloc_v2_init
)
2338 runtime_pseudp_reloc_v2_init
= 1;
2340 quick_symbol (abfd
, U ("_imp_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2342 bfd_set_section_size (abfd
, rt_rel
, size
);
2343 rt_rel_d
= xmalloc (size
);
2344 rt_rel
->contents
= rt_rel_d
;
2345 memset (rt_rel_d
, 0, size
);
2346 quick_reloc (abfd
, size
- 8, BFD_RELOC_RVA
, 1);
2347 quick_reloc (abfd
, size
- 12, BFD_RELOC_RVA
, 2);
2348 bfd_put_32 (abfd
, bitsize
, rt_rel_d
+ (size
- 4));
2350 bfd_put_32 (abfd
, 1, rt_rel_d
+ 8);
2351 save_relocs (rt_rel
);
2353 bfd_set_symtab (abfd
, symtab
, symptr
);
2355 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, size
);
2359 bfd_set_section_size (abfd
, rt_rel
, 8);
2360 rt_rel_d
= xmalloc (8);
2361 rt_rel
->contents
= rt_rel_d
;
2362 memset (rt_rel_d
, 0, 8);
2364 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2365 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2367 save_relocs (rt_rel
);
2369 bfd_set_symtab (abfd
, symtab
, symptr
);
2371 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2373 bfd_make_readable (abfd
);
2378 .rva __pei386_runtime_relocator */
2381 pe_create_runtime_relocator_reference (bfd
*parent
)
2383 asection
*extern_rt_rel
;
2384 unsigned char *extern_rt_rel_d
;
2388 oname
= xmalloc (20);
2389 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2392 abfd
= bfd_create (oname
, parent
);
2393 bfd_find_target (pe_details
->object_target
, abfd
);
2394 bfd_make_writable (abfd
);
2396 bfd_set_format (abfd
, bfd_object
);
2397 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2400 symtab
= xmalloc (2 * sizeof (asymbol
*));
2401 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2403 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2406 bfd_set_section_size (abfd
, extern_rt_rel
, 4);
2407 extern_rt_rel_d
= xmalloc (4);
2408 extern_rt_rel
->contents
= extern_rt_rel_d
;
2410 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2411 save_relocs (extern_rt_rel
);
2413 bfd_set_symtab (abfd
, symtab
, symptr
);
2415 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, 4);
2417 bfd_make_readable (abfd
);
2422 pe_create_import_fixup (arelent
*rel
, asection
*s
, bfd_vma addend
)
2425 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2426 struct bfd_link_hash_entry
*name_thunk_sym
;
2427 const char *name
= sym
->name
;
2428 char *fixup_name
= make_import_fixup_mark (rel
);
2431 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2433 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2435 if (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
)
2437 bfd
*b
= make_singleton_name_thunk (name
, link_info
.output_bfd
);
2438 add_bfd_to_link (b
, b
->filename
, &link_info
);
2440 /* If we ever use autoimport, we have to cast text section writable. */
2441 config
.text_read_only
= FALSE
;
2442 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2445 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2447 extern char * pe_data_import_dll
;
2448 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2450 b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
,
2451 link_info
.output_bfd
);
2452 add_bfd_to_link (b
, b
->filename
, &link_info
);
2455 if ((link_info
.pei386_runtime_pseudo_reloc
!= 0 && addend
!= 0)
2456 || link_info
.pei386_runtime_pseudo_reloc
== 2)
2458 if (pe_dll_extra_pe_debug
)
2459 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2460 fixup_name
, (int) addend
);
2462 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, rel
->howto
->bitsize
,
2463 link_info
.output_bfd
);
2464 add_bfd_to_link (b
, b
->filename
, &link_info
);
2466 if (runtime_pseudo_relocs_created
== 0)
2468 b
= pe_create_runtime_relocator_reference (link_info
.output_bfd
);
2469 add_bfd_to_link (b
, b
->filename
, &link_info
);
2471 runtime_pseudo_relocs_created
++;
2473 else if (addend
!= 0)
2475 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2476 s
->owner
, s
, rel
->address
, sym
->name
);
2483 pe_dll_generate_implib (def_file
*def
, const char *impfilename
)
2491 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2492 dll_symname
= xstrdup (dll_filename
);
2493 for (i
= 0; dll_symname
[i
]; i
++)
2494 if (!ISALNUM (dll_symname
[i
]))
2495 dll_symname
[i
] = '_';
2497 unlink_if_ordinary (impfilename
);
2499 outarch
= bfd_openw (impfilename
, 0);
2503 /* xgettext:c-format */
2504 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2508 /* xgettext:c-format */
2509 info_msg (_("Creating library file: %s\n"), impfilename
);
2511 bfd_set_format (outarch
, bfd_archive
);
2512 outarch
->has_armap
= 1;
2514 /* Work out a reasonable size of things to put onto one line. */
2515 ar_head
= make_head (outarch
);
2517 for (i
= 0; i
< def
->num_exports
; i
++)
2519 /* The import library doesn't know about the internal name. */
2520 char *internal
= def
->exports
[i
].internal_name
;
2523 /* Don't add PRIVATE entries to import lib. */
2524 if (pe_def_file
->exports
[i
].flag_private
)
2526 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2527 n
= make_one (def
->exports
+ i
, outarch
,
2528 ! (def
->exports
+ i
)->flag_data
);
2529 n
->archive_next
= head
;
2531 def
->exports
[i
].internal_name
= internal
;
2534 ar_tail
= make_tail (outarch
);
2536 if (ar_head
== NULL
|| ar_tail
== NULL
)
2539 /* Now stick them all into the archive. */
2540 ar_head
->archive_next
= head
;
2541 ar_tail
->archive_next
= ar_head
;
2544 if (! bfd_set_archive_head (outarch
, head
))
2545 einfo ("%Xbfd_set_archive_head: %E\n");
2547 if (! bfd_close (outarch
))
2548 einfo ("%Xbfd_close %s: %E\n", impfilename
);
2550 while (head
!= NULL
)
2552 bfd
*n
= head
->archive_next
;
2559 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*link_info
)
2561 lang_input_statement_type
*fake_file
;
2563 fake_file
= lang_add_input_file (name
,
2564 lang_input_file_is_fake_enum
,
2566 fake_file
->the_bfd
= abfd
;
2567 ldlang_add_file (fake_file
);
2569 if (!bfd_link_add_symbols (abfd
, link_info
))
2570 einfo ("%Xaddsym %s: %E\n", name
);
2574 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*link_info
)
2576 def_file_module
*module
;
2578 pe_dll_id_target (bfd_get_target (output_bfd
));
2583 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2587 dll_filename
= module
->name
;
2588 dll_symname
= xstrdup (module
->name
);
2589 for (i
= 0; dll_symname
[i
]; i
++)
2590 if (!ISALNUM (dll_symname
[i
]))
2591 dll_symname
[i
] = '_';
2595 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2596 if (pe_def_file
->imports
[i
].module
== module
)
2598 def_file_export exp
;
2599 struct bfd_link_hash_entry
*blhe
;
2600 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2601 /* See if we need this import. */
2602 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2603 char *name
= xmalloc (len
+ 2 + 6);
2604 bfd_boolean include_jmp_stub
= FALSE
;
2607 sprintf (name
, "%s",
2608 pe_def_file
->imports
[i
].internal_name
);
2610 sprintf (name
, "%s%s",U (""),
2611 pe_def_file
->imports
[i
].internal_name
);
2613 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2614 FALSE
, FALSE
, FALSE
);
2616 /* Include the jump stub for <sym> only if the <sym>
2618 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2621 sprintf (name
, "%s%s", "__imp_",
2622 pe_def_file
->imports
[i
].internal_name
);
2624 sprintf (name
, "%s%s%s", "__imp_", U (""),
2625 pe_def_file
->imports
[i
].internal_name
);
2627 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2628 FALSE
, FALSE
, FALSE
);
2631 include_jmp_stub
= TRUE
;
2635 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2641 bfd
*ar_head
= make_head (output_bfd
);
2642 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2645 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2646 exp
.name
= pe_def_file
->imports
[i
].name
;
2647 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2648 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2649 exp
.flag_private
= 0;
2650 exp
.flag_constant
= 0;
2651 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2652 exp
.flag_noname
= exp
.name
? 0 : 1;
2653 one
= make_one (&exp
, output_bfd
, (! exp
.flag_data
) && include_jmp_stub
);
2654 add_bfd_to_link (one
, one
->filename
, link_info
);
2659 bfd
*ar_tail
= make_tail (output_bfd
);
2660 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2667 /* We were handed a *.DLL file. Parse it and turn it into a set of
2668 IMPORTS directives in the def file. Return TRUE if the file was
2669 handled, FALSE if not. */
2672 pe_get16 (bfd
*abfd
, int where
)
2676 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2677 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2678 return b
[0] + (b
[1] << 8);
2682 pe_get32 (bfd
*abfd
, int where
)
2686 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2687 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2688 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2694 unsigned char *b
= ptr
;
2696 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2700 pe_implied_import_dll (const char *filename
)
2703 bfd_vma pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2704 bfd_vma export_rva
, export_size
, nsections
, secptr
, expptr
;
2705 bfd_vma exp_funcbase
;
2706 unsigned char *expdata
;
2708 bfd_vma name_rvas
, ordinals
, nexp
, ordbase
;
2709 const char *dll_name
;
2710 /* Initialization with start > end guarantees that is_data
2711 will not be set by mistake, and avoids compiler warning. */
2712 bfd_vma data_start
= 1;
2713 bfd_vma data_end
= 0;
2714 bfd_vma rdata_start
= 1;
2715 bfd_vma rdata_end
= 0;
2716 bfd_vma bss_start
= 1;
2717 bfd_vma bss_end
= 0;
2719 /* No, I can't use bfd here. kernel32.dll puts its export table in
2720 the middle of the .rdata section. */
2721 dll
= bfd_openr (filename
, pe_details
->target_name
);
2724 einfo ("%Xopen %s: %E\n", filename
);
2728 /* PEI dlls seem to be bfd_objects. */
2729 if (!bfd_check_format (dll
, bfd_object
))
2731 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2735 /* Get pe_header, optional header and numbers of export entries. */
2736 pe_header_offset
= pe_get32 (dll
, 0x3c);
2737 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2738 #ifdef pe_use_x86_64
2739 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2741 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2744 if (num_entries
< 1) /* No exports. */
2747 #ifdef pe_use_x86_64
2748 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
2749 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
2751 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2752 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2755 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2756 secptr
= (pe_header_offset
+ 4 + 20 +
2757 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2760 /* Get the rva and size of the export section. */
2761 for (i
= 0; i
< nsections
; i
++)
2764 bfd_vma secptr1
= secptr
+ 40 * i
;
2765 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2766 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 16);
2767 bfd_vma fptr
= pe_get32 (dll
, secptr1
+ 20);
2769 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2770 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2772 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2774 expptr
= fptr
+ (export_rva
- vaddr
);
2775 if (export_rva
+ export_size
> vaddr
+ vsize
)
2776 export_size
= vsize
- (export_rva
- vaddr
);
2781 /* Scan sections and store the base and size of the
2782 data and bss segments in data/base_start/end. */
2783 for (i
= 0; i
< nsections
; i
++)
2785 bfd_vma secptr1
= secptr
+ 40 * i
;
2786 bfd_vma vsize
= pe_get32 (dll
, secptr1
+ 8);
2787 bfd_vma vaddr
= pe_get32 (dll
, secptr1
+ 12);
2788 bfd_vma flags
= pe_get32 (dll
, secptr1
+ 36);
2792 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
2793 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
2795 if (strcmp(sec_name
,".data") == 0)
2798 data_end
= vaddr
+ vsize
;
2800 if (pe_dll_extra_pe_debug
)
2801 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2802 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2803 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2805 else if (strcmp(sec_name
,".rdata") == 0)
2807 rdata_start
= vaddr
;
2808 rdata_end
= vaddr
+ vsize
;
2810 if (pe_dll_extra_pe_debug
)
2811 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2812 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2813 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2815 else if (strcmp (sec_name
,".bss") == 0)
2818 bss_end
= vaddr
+ vsize
;
2820 if (pe_dll_extra_pe_debug
)
2821 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2822 __FUNCTION__
, sec_name
, (unsigned long) vaddr
,
2823 (unsigned long) (vaddr
+ vsize
), (unsigned long) flags
);
2827 expdata
= xmalloc (export_size
);
2828 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2829 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2830 erva
= (char *) expdata
- export_rva
;
2832 if (pe_def_file
== 0)
2833 pe_def_file
= def_file_empty ();
2835 nexp
= pe_as32 (expdata
+ 24);
2836 name_rvas
= pe_as32 (expdata
+ 32);
2837 ordinals
= pe_as32 (expdata
+ 36);
2838 ordbase
= pe_as32 (expdata
+ 16);
2839 exp_funcbase
= pe_as32 (expdata
+ 28);
2841 /* Use internal dll name instead of filename
2842 to enable symbolic dll linking. */
2843 dll_name
= erva
+ pe_as32 (expdata
+ 12);
2845 /* Check to see if the dll has already been added to
2846 the definition list and if so return without error.
2847 This avoids multiple symbol definitions. */
2848 if (def_get_module (pe_def_file
, dll_name
))
2850 if (pe_dll_extra_pe_debug
)
2851 printf ("%s is already loaded\n", dll_name
);
2855 /* Iterate through the list of symbols. */
2856 for (i
= 0; i
< nexp
; i
++)
2858 /* Pointer to the names vector. */
2859 bfd_vma name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
2860 def_file_import
*imp
;
2861 /* Pointer to the function address vector. */
2862 bfd_vma func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
2865 /* Skip unwanted symbols, which are
2866 exported in buggy auto-import releases. */
2867 if (! CONST_STRNEQ (erva
+ name_rva
, "_nm_"))
2869 /* is_data is true if the address is in the data, rdata or bss
2872 (func_rva
>= data_start
&& func_rva
< data_end
)
2873 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
2874 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
2876 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
2878 /* Mark symbol type. */
2879 imp
->data
= is_data
;
2881 if (pe_dll_extra_pe_debug
)
2882 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2883 __FUNCTION__
, dll_name
, erva
+ name_rva
,
2884 (unsigned long) func_rva
, is_data
? "(data)" : "");
2891 /* These are the main functions, called from the emulation. The first
2892 is called after the bfds are read, so we can guess at how much space
2893 we need. The second is called after everything is placed, so we
2894 can put the right values in place. */
2897 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2899 pe_dll_id_target (bfd_get_target (abfd
));
2900 process_def_file (abfd
, info
);
2902 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
2905 generate_edata (abfd
, info
);
2906 build_filler_bfd (1);
2910 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2912 pe_dll_id_target (bfd_get_target (abfd
));
2913 build_filler_bfd (0);
2917 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2919 pe_dll_id_target (bfd_get_target (abfd
));
2920 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2922 generate_reloc (abfd
, info
);
2925 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2927 /* Resize the sections. */
2928 lang_reset_memory_regions ();
2929 lang_size_sections (NULL
, TRUE
);
2931 /* Redo special stuff. */
2932 ldemul_after_allocation ();
2934 /* Do the assignments again. */
2935 lang_do_assignments ();
2938 fill_edata (abfd
, info
);
2940 if (info
->shared
&& !info
->pie
)
2941 pe_data (abfd
)->dll
= 1;
2943 edata_s
->contents
= edata_d
;
2944 reloc_s
->contents
= reloc_d
;
2948 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2950 pe_dll_id_target (bfd_get_target (abfd
));
2951 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2953 generate_reloc (abfd
, info
);
2956 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2958 /* Resize the sections. */
2959 lang_reset_memory_regions ();
2960 lang_size_sections (NULL
, TRUE
);
2962 /* Redo special stuff. */
2963 ldemul_after_allocation ();
2965 /* Do the assignments again. */
2966 lang_do_assignments ();
2968 reloc_s
->contents
= reloc_d
;
2972 pe_bfd_is_dll (bfd
*abfd
)
2974 return (bfd_get_format (abfd
) == bfd_object
2976 && pe_data (abfd
)->dll
);