1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
4 Written by DJ Delorie <dj@cygnus.com>
6 This file is part of GLD, the Gnu Linker.
8 GLD 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 2, or (at your option)
13 GLD 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 GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
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 (".text") },
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") },
198 { STRING_COMMA_LEN (NULL
) }
201 static const autofilter_entry_type autofilter_symbollist_i386
[] =
203 { STRING_COMMA_LEN (".text") },
204 /* Entry point symbols, and entry hooks. */
205 { STRING_COMMA_LEN ("cygwin_crt0") },
206 { STRING_COMMA_LEN ("DllMain@12") },
207 { STRING_COMMA_LEN ("DllEntryPoint@0") },
208 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
209 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
210 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
211 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
212 { STRING_COMMA_LEN ("cygwin_attach_dll") },
213 { STRING_COMMA_LEN ("cygwin_premain0") },
214 { STRING_COMMA_LEN ("cygwin_premain1") },
215 { STRING_COMMA_LEN ("cygwin_premain2") },
216 { STRING_COMMA_LEN ("cygwin_premain3") },
217 /* Runtime pseudo-reloc. */
218 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
219 { STRING_COMMA_LEN ("do_pseudo_reloc") },
220 /* Global vars that should not be exported. */
221 { STRING_COMMA_LEN ("impure_ptr") },
222 { STRING_COMMA_LEN ("_impure_ptr") },
223 { STRING_COMMA_LEN ("_fmode") },
224 { STRING_COMMA_LEN ("environ") },
225 { STRING_COMMA_LEN (NULL
) }
228 #define PE_ARCH_i386 1
230 #define PE_ARCH_mips 3
231 #define PE_ARCH_arm 4
232 #define PE_ARCH_arm_epoc 5
233 #define PE_ARCH_arm_wince 6
235 static const pe_details_type pe_detail_list
[] =
250 autofilter_symbollist_i386
255 16 /* R_SH_IMAGEBASE */,
259 autofilter_symbollist_generic
268 autofilter_symbollist_generic
277 autofilter_symbollist_generic
280 "epoc-pei-arm-little",
281 "epoc-pe-arm-little",
286 autofilter_symbollist_generic
289 "pei-arm-wince-little",
290 "pe-arm-wince-little",
291 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
295 autofilter_symbollist_generic
297 { NULL
, NULL
, 0, 0, 0, FALSE
, NULL
}
300 static const pe_details_type
*pe_details
;
302 /* Do not specify library suffix explicitly, to allow for dllized versions. */
303 static const autofilter_entry_type autofilter_liblist
[] =
305 { STRING_COMMA_LEN ("libcegcc") },
306 { STRING_COMMA_LEN ("libcygwin") },
307 { STRING_COMMA_LEN ("libgcc") },
308 { STRING_COMMA_LEN ("libstdc++") },
309 { STRING_COMMA_LEN ("libmingw32") },
310 { STRING_COMMA_LEN ("libmingwex") },
311 { STRING_COMMA_LEN ("libg2c") },
312 { STRING_COMMA_LEN ("libsupc++") },
313 { STRING_COMMA_LEN ("libobjc") },
314 { STRING_COMMA_LEN ("libgcj") },
315 { STRING_COMMA_LEN (NULL
) }
318 static const autofilter_entry_type autofilter_objlist
[] =
320 { STRING_COMMA_LEN ("crt0.o") },
321 { STRING_COMMA_LEN ("crt1.o") },
322 { STRING_COMMA_LEN ("crt2.o") },
323 { STRING_COMMA_LEN ("dllcrt1.o") },
324 { STRING_COMMA_LEN ("dllcrt2.o") },
325 { STRING_COMMA_LEN ("gcrt0.o") },
326 { STRING_COMMA_LEN ("gcrt1.o") },
327 { STRING_COMMA_LEN ("gcrt2.o") },
328 { STRING_COMMA_LEN ("crtbegin.o") },
329 { STRING_COMMA_LEN ("crtend.o") },
330 { STRING_COMMA_LEN (NULL
) }
333 static const autofilter_entry_type autofilter_symbolprefixlist
[] =
335 /* _imp_ is treated specially, as it is always underscored. */
336 /* { STRING_COMMA_LEN ("_imp_") }, */
337 /* Don't export some c++ symbols. */
338 { STRING_COMMA_LEN ("__rtti_") },
339 { STRING_COMMA_LEN ("__builtin_") },
340 /* Don't re-export auto-imported symbols. */
341 { STRING_COMMA_LEN ("_nm_") },
342 /* Don't export symbols specifying internal DLL layout. */
343 { STRING_COMMA_LEN ("_head_") },
344 { STRING_COMMA_LEN (NULL
) }
347 static const autofilter_entry_type autofilter_symbolsuffixlist
[] =
349 { STRING_COMMA_LEN ("_iname") },
350 { STRING_COMMA_LEN (NULL
) }
353 #define U(str) (pe_details->underscored ? "_" str : str)
356 pe_dll_id_target (const char *target
)
360 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
361 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
362 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
364 pe_details
= pe_detail_list
+ i
;
367 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
371 /* Helper functions for qsort. Relocs must be sorted so that we can write
372 them out by pages. */
383 reloc_sort (const void *va
, const void *vb
)
385 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
386 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
388 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
392 pe_export_sort (const void *va
, const void *vb
)
394 const def_file_export
*a
= va
;
395 const def_file_export
*b
= vb
;
397 return strcmp (a
->name
, b
->name
);
400 /* Read and process the .DEF file. */
402 /* These correspond to the entries in pe_def_file->exports[]. I use
403 exported_symbol_sections[i] to tag whether or not the symbol was
404 defined, since we can't export symbols we don't have. */
406 static bfd_vma
*exported_symbol_offsets
;
407 static struct bfd_section
**exported_symbol_sections
;
408 static int export_table_size
;
409 static int count_exported
;
410 static int count_exported_byname
;
411 static int count_with_ordinals
;
412 static const char *dll_name
;
413 static int min_ordinal
, max_ordinal
;
414 static int *exported_symbols
;
416 typedef struct exclude_list_struct
419 struct exclude_list_struct
*next
;
424 static struct exclude_list_struct
*excludes
= 0;
427 pe_dll_add_excludes (const char *new_excludes
, const int type
)
430 char *exclude_string
;
432 local_copy
= xstrdup (new_excludes
);
434 exclude_string
= strtok (local_copy
, ",:");
435 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
437 struct exclude_list_struct
*new_exclude
;
439 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
440 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
441 strcpy (new_exclude
->string
, exclude_string
);
442 new_exclude
->type
= type
;
443 new_exclude
->next
= excludes
;
444 excludes
= new_exclude
;
451 is_import (const char* n
)
453 return (CONST_STRNEQ (n
, "__imp_"));
456 /* abfd is a bfd containing n (or NULL)
457 It can be used for contextual checks. */
460 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
463 struct exclude_list_struct
*ex
;
464 const autofilter_entry_type
*afptr
;
465 const char * libname
= 0;
466 if (abfd
&& abfd
->my_archive
)
467 libname
= lbasename (abfd
->my_archive
->filename
);
469 for (i
= 0; i
< d
->num_exports
; i
++)
470 if (strcmp (d
->exports
[i
].name
, n
) == 0)
473 if (pe_dll_do_default_excludes
)
478 if (pe_dll_extra_pe_debug
)
479 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
480 n
, abfd
, abfd
->my_archive
);
482 /* First of all, make context checks:
483 Don't export anything from standard libs. */
486 afptr
= autofilter_liblist
;
490 if (strncmp (libname
, afptr
->name
, afptr
->len
) == 0 )
496 /* Next, exclude symbols from certain startup objects. */
498 if (abfd
&& (p
= lbasename (abfd
->filename
)))
500 afptr
= autofilter_objlist
;
503 if (strcmp (p
, afptr
->name
) == 0)
509 /* Don't try to blindly exclude all symbols
510 that begin with '__'; this was tried and
511 it is too restrictive. Instead we have
512 a target specific list to use: */
513 afptr
= pe_details
->autofilter_symbollist
;
517 if (strcmp (n
, afptr
->name
) == 0)
523 /* Next, exclude symbols starting with ... */
524 afptr
= autofilter_symbolprefixlist
;
527 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
533 /* Finally, exclude symbols ending with ... */
535 afptr
= autofilter_symbolsuffixlist
;
538 if ((len
>= afptr
->len
)
539 /* Add 1 to insure match with trailing '\0'. */
540 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
541 afptr
->len
+ 1) == 0)
548 for (ex
= excludes
; ex
; ex
= ex
->next
)
550 if (ex
->type
== 1) /* exclude-libs */
553 && ((strcmp (libname
, ex
->string
) == 0)
554 || (strcasecmp ("ALL", ex
->string
) == 0)))
557 else if (strcmp (n
, ex
->string
) == 0)
565 process_def_file (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
568 struct bfd_link_hash_entry
*blhe
;
570 struct bfd_section
*s
;
571 def_file_export
*e
= 0;
574 pe_def_file
= def_file_empty ();
576 /* First, run around to all the objects looking for the .drectve
577 sections, and push those into the def file too. */
578 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
580 s
= bfd_get_section_by_name (b
, ".drectve");
584 char *buf
= xmalloc (size
);
586 bfd_get_section_contents (b
, s
, buf
, 0, size
);
587 def_file_add_directive (pe_def_file
, buf
, size
);
592 /* If we are not building a DLL, when there are no exports
593 we do not build an export table at all. */
594 if (!pe_dll_export_everything
&& pe_def_file
->num_exports
== 0
598 /* Now, maybe export everything else the default way. */
599 if (pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
601 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
606 symsize
= bfd_get_symtab_upper_bound (b
);
607 symbols
= xmalloc (symsize
);
608 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
610 for (j
= 0; j
< nsyms
; j
++)
612 /* We should export symbols which are either global or not
613 anything at all. (.bss data is the latter)
614 We should not export undefined symbols. */
615 if (symbols
[j
]->section
!= &bfd_und_section
616 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
617 || (symbols
[j
]->flags
== BFD_FORT_COMM_DEFAULT_VALUE
)))
619 const char *sn
= symbols
[j
]->name
;
621 /* We should not re-export imported stuff. */
627 name
= xmalloc (strlen ("__imp_") + strlen (sn
) + 1);
628 sprintf (name
, "%s%s", "__imp_", sn
);
630 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
631 FALSE
, FALSE
, FALSE
);
634 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
638 if (pe_details
->underscored
&& *sn
== '_')
641 if (auto_export (b
, pe_def_file
, sn
))
644 p
=def_file_add_export (pe_def_file
, sn
, 0, -1);
645 /* Fill data flag properly, from dlltool.c. */
646 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
654 #define NE pe_def_file->num_exports
656 /* Canonicalize the export list. */
659 for (i
= 0; i
< NE
; i
++)
661 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
663 /* This will preserve internal_name, which may have been
664 pointing to the same memory as name, or might not
666 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
667 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
668 char *tmp_at
= strchr (tmp
, '@');
673 einfo (_("%XCannot export %s: invalid export name\n"),
674 pe_def_file
->exports
[i
].name
);
675 pe_def_file
->exports
[i
].name
= tmp
;
680 if (pe_dll_stdcall_aliases
)
682 for (i
= 0; i
< NE
; i
++)
684 if (is_import (pe_def_file
->exports
[i
].name
))
687 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
689 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
690 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
692 *(strchr (tmp
, '@')) = 0;
693 if (auto_export (NULL
, pe_def_file
, tmp
))
694 def_file_add_export (pe_def_file
, tmp
,
695 pe_def_file
->exports
[i
].internal_name
,
703 /* Convenience, but watch out for it changing. */
704 e
= pe_def_file
->exports
;
706 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
707 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
709 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
713 count_exported_byname
= 0;
714 count_with_ordinals
= 0;
716 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
718 for (i
= 0, j
= 0; i
< NE
; i
++)
720 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
722 /* This is a duplicate. */
723 if (e
[j
- 1].ordinal
!= -1
724 && e
[i
].ordinal
!= -1
725 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
727 if (pe_dll_warn_dup_exports
)
728 /* xgettext:c-format */
729 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
730 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
734 if (pe_dll_warn_dup_exports
)
735 /* xgettext:c-format */
736 einfo (_("Warning, duplicate EXPORT: %s\n"),
740 if (e
[i
].ordinal
!= -1)
741 e
[j
- 1].ordinal
= e
[i
].ordinal
;
742 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
743 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
744 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
745 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
754 pe_def_file
->num_exports
= j
; /* == NE */
756 for (i
= 0; i
< NE
; i
++)
760 /* Check for forward exports */
761 if (strchr (pe_def_file
->exports
[i
].internal_name
, '.'))
764 if (!pe_def_file
->exports
[i
].flag_noname
)
765 count_exported_byname
++;
767 pe_def_file
->exports
[i
].flag_forward
= 1;
769 if (pe_def_file
->exports
[i
].ordinal
!= -1)
771 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
772 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
773 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
774 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
775 count_with_ordinals
++;
781 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
782 if (pe_details
->underscored
783 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
786 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
789 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
791 blhe
= bfd_link_hash_lookup (info
->hash
,
796 && (blhe
->type
== bfd_link_hash_defined
797 || (blhe
->type
== bfd_link_hash_common
)))
800 if (!pe_def_file
->exports
[i
].flag_noname
)
801 count_exported_byname
++;
803 /* Only fill in the sections. The actual offsets are computed
804 in fill_exported_offsets() after common symbols are laid
806 if (blhe
->type
== bfd_link_hash_defined
)
807 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
809 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
811 if (pe_def_file
->exports
[i
].ordinal
!= -1)
813 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
814 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
815 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
816 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
817 count_with_ordinals
++;
820 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
822 /* xgettext:c-format */
823 einfo (_("%XCannot export %s: symbol not defined\n"),
824 pe_def_file
->exports
[i
].internal_name
);
828 /* xgettext:c-format */
829 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
830 pe_def_file
->exports
[i
].internal_name
,
831 blhe
->type
, bfd_link_hash_defined
);
835 /* xgettext:c-format */
836 einfo (_("%XCannot export %s: symbol not found\n"),
837 pe_def_file
->exports
[i
].internal_name
);
843 /* Build the bfd that will contain .edata and .reloc sections. */
846 build_filler_bfd (int include_edata
)
848 lang_input_statement_type
*filler_file
;
849 filler_file
= lang_add_input_file ("dll stuff",
850 lang_input_file_is_fake_enum
,
852 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff", output_bfd
);
853 if (filler_bfd
== NULL
854 || !bfd_set_arch_mach (filler_bfd
,
855 bfd_get_arch (output_bfd
),
856 bfd_get_mach (output_bfd
)))
858 einfo ("%X%P: can not create BFD: %E\n");
864 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
866 || !bfd_set_section_flags (filler_bfd
, edata_s
,
873 einfo ("%X%P: can not create .edata section: %E\n");
876 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
879 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
881 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
888 einfo ("%X%P: can not create .reloc section: %E\n");
892 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
894 ldlang_add_file (filler_file
);
897 /* Gather all the exported symbols and build the .edata section. */
900 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
903 int name_table_size
= 0;
906 /* First, we need to know how many exported symbols there are,
907 and what the range of ordinals is. */
908 if (pe_def_file
->name
)
909 dll_name
= pe_def_file
->name
;
912 dll_name
= abfd
->filename
;
914 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
915 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
919 if (count_with_ordinals
&& max_ordinal
> count_exported
)
921 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
922 min_ordinal
= max_ordinal
- count_exported
+ 1;
927 max_ordinal
= count_exported
;
930 export_table_size
= max_ordinal
- min_ordinal
+ 1;
931 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
932 for (i
= 0; i
< export_table_size
; i
++)
933 exported_symbols
[i
] = -1;
935 /* Now we need to assign ordinals to those that don't have them. */
936 for (i
= 0; i
< NE
; i
++)
938 if (exported_symbol_sections
[i
] ||
939 pe_def_file
->exports
[i
].flag_forward
)
941 if (pe_def_file
->exports
[i
].ordinal
!= -1)
943 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
944 int pi
= exported_symbols
[ei
];
948 /* xgettext:c-format */
949 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
950 pe_def_file
->exports
[i
].ordinal
,
951 pe_def_file
->exports
[i
].name
,
952 pe_def_file
->exports
[pi
].name
);
954 exported_symbols
[ei
] = i
;
956 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
959 /* Reserve space for the forward name. */
960 if (pe_def_file
->exports
[i
].flag_forward
)
962 name_table_size
+= strlen (pe_def_file
->exports
[i
].internal_name
) + 1;
966 next_ordinal
= min_ordinal
;
967 for (i
= 0; i
< NE
; i
++)
968 if ((exported_symbol_sections
[i
] ||
969 pe_def_file
->exports
[i
].flag_forward
) &&
970 pe_def_file
->exports
[i
].ordinal
== -1)
972 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
975 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
976 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
979 /* OK, now we can allocate some memory. */
980 edata_sz
= (40 /* directory */
981 + 4 * export_table_size
/* addresses */
982 + 4 * count_exported_byname
/* name ptrs */
983 + 2 * count_exported_byname
/* ordinals */
984 + name_table_size
+ strlen (dll_name
) + 1);
987 /* Fill the exported symbol offsets. The preliminary work has already
988 been done in process_def_file(). */
991 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
994 struct bfd_link_hash_entry
*blhe
;
996 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1000 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
1001 if (pe_details
->underscored
1002 && *pe_def_file
->exports
[i
].internal_name
!= '@')
1005 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
1008 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
1010 blhe
= bfd_link_hash_lookup (info
->hash
,
1012 FALSE
, FALSE
, TRUE
);
1014 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
1015 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
1022 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1025 unsigned char *edirectory
;
1026 unsigned char *eaddresses
;
1027 unsigned char *enameptrs
;
1028 unsigned char *eordinals
;
1034 edata_d
= xmalloc (edata_sz
);
1036 /* Note use of array pointer math here. */
1037 edirectory
= edata_d
;
1038 eaddresses
= edata_d
+ 40;
1039 enameptrs
= eaddresses
+ 4 * export_table_size
;
1040 eordinals
= enameptrs
+ 4 * count_exported_byname
;
1041 enamestr
= (char *) eordinals
+ 2 * count_exported_byname
;
1043 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1044 + edata_s->output_section->vma - image_base)
1046 memset (edata_d
, 0, edata_sz
);
1047 bfd_put_32 (abfd
, now
, edata_d
+ 4);
1048 if (pe_def_file
->version_major
!= -1)
1050 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
1051 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
1054 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
1055 strcpy (enamestr
, dll_name
);
1056 enamestr
+= strlen (enamestr
) + 1;
1057 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
1058 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
1059 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
1060 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
1061 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
1062 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
1064 fill_exported_offsets (abfd
, info
);
1066 /* Ok, now for the filling in part.
1067 Scan alphabetically - ie the ordering in the exports[] table,
1068 rather than by ordinal - the ordering in the exported_symbol[]
1069 table. See dlltool.c and:
1070 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1071 for more information. */
1073 for (s
= 0; s
< NE
; s
++)
1075 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
1076 if (pe_def_file
->exports
[s
].ordinal
!= -1 &&
1077 (pe_def_file
->exports
[s
].flag_forward
|| ssec
!= NULL
))
1079 int ord
= pe_def_file
->exports
[s
].ordinal
;
1081 if (pe_def_file
->exports
[s
].flag_forward
)
1083 bfd_put_32 (abfd
, ERVA (enamestr
),
1084 eaddresses
+ 4 * (ord
- min_ordinal
));
1086 strcpy (enamestr
, pe_def_file
->exports
[s
].internal_name
);
1087 enamestr
+= strlen (pe_def_file
->exports
[s
].internal_name
) + 1;
1091 unsigned long srva
= (exported_symbol_offsets
[s
]
1092 + ssec
->output_section
->vma
1093 + ssec
->output_offset
);
1095 bfd_put_32 (abfd
, srva
- image_base
,
1096 eaddresses
+ 4 * (ord
- min_ordinal
));
1099 if (!pe_def_file
->exports
[s
].flag_noname
)
1101 char *ename
= pe_def_file
->exports
[s
].name
;
1103 bfd_put_32 (abfd
, ERVA (enamestr
), enameptrs
);
1105 strcpy (enamestr
, ename
);
1106 enamestr
+= strlen (enamestr
) + 1;
1107 bfd_put_16 (abfd
, ord
- min_ordinal
, eordinals
);
1109 pe_def_file
->exports
[s
].hint
= hint
++;
1116 static struct bfd_section
*current_sec
;
1119 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1121 int (*cb
) (arelent
*, asection
*))
1126 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1131 symsize
= bfd_get_symtab_upper_bound (b
);
1132 symbols
= xmalloc (symsize
);
1133 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1135 for (s
= b
->sections
; s
; s
= s
->next
)
1138 int relsize
, nrelocs
, i
;
1139 int flags
= bfd_get_section_flags (b
, s
);
1141 /* Skip discarded linkonce sections. */
1142 if (flags
& SEC_LINK_ONCE
1143 && s
->output_section
== bfd_abs_section_ptr
)
1148 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1149 relocs
= xmalloc (relsize
);
1150 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1152 for (i
= 0; i
< nrelocs
; i
++)
1154 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1156 if (!strcmp (name
, sym
->name
))
1162 /* Warning: the allocated symbols are remembered in BFD and reused
1163 later, so don't free them! */
1164 /* free (symbols); */
1169 /* Gather all the relocations and build the .reloc section. */
1172 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1175 /* For .reloc stuff. */
1176 reloc_data_type
*reloc_data
;
1177 int total_relocs
= 0;
1179 unsigned long sec_page
= (unsigned long) -1;
1180 unsigned long page_ptr
, page_count
;
1183 struct bfd_section
*s
;
1186 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1187 for (s
= b
->sections
; s
; s
= s
->next
)
1188 total_relocs
+= s
->reloc_count
;
1190 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1194 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1197 int relsize
, nrelocs
, i
;
1199 for (s
= b
->sections
; s
; s
= s
->next
)
1201 unsigned long sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1205 /* If it's not loaded, we don't need to relocate it this way. */
1206 if (!(s
->output_section
->flags
& SEC_LOAD
))
1209 /* I don't know why there would be a reloc for these, but I've
1210 seen it happen - DJ */
1211 if (s
->output_section
== &bfd_abs_section
)
1214 if (s
->output_section
->vma
== 0)
1216 /* Huh? Shouldn't happen, but punt if it does. */
1217 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1218 s
->output_section
->name
, s
->output_section
->index
,
1219 s
->output_section
->flags
);
1223 symsize
= bfd_get_symtab_upper_bound (b
);
1224 symbols
= xmalloc (symsize
);
1225 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1227 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1228 relocs
= xmalloc (relsize
);
1229 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1231 for (i
= 0; i
< nrelocs
; i
++)
1233 if (pe_dll_extra_pe_debug
)
1235 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1236 printf ("rel: %s\n", sym
->name
);
1238 if (!relocs
[i
]->howto
->pc_relative
1239 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1242 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1244 sym_vma
= (relocs
[i
]->addend
1247 + sym
->section
->output_offset
1248 + sym
->section
->output_section
->vma
);
1249 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1251 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1253 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1254 relocs
[i
]->howto
->rightshift
)
1256 #ifdef pe_use_x86_64
1257 case BITS_AND_SHIFT (64, 0):
1258 reloc_data
[total_relocs
].type
= 10;
1262 case BITS_AND_SHIFT (32, 0):
1263 reloc_data
[total_relocs
].type
= 3;
1266 case BITS_AND_SHIFT (16, 0):
1267 reloc_data
[total_relocs
].type
= 2;
1270 case BITS_AND_SHIFT (16, 16):
1271 reloc_data
[total_relocs
].type
= 4;
1272 /* FIXME: we can't know the symbol's right value
1273 yet, but we probably can safely assume that
1274 CE will relocate us in 64k blocks, so leaving
1276 reloc_data
[total_relocs
].extra
= 0;
1279 case BITS_AND_SHIFT (26, 2):
1280 reloc_data
[total_relocs
].type
= 5;
1283 case BITS_AND_SHIFT (24, 2):
1284 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1285 Those ARM_xxx definitions should go in proper
1287 if (relocs
[i
]->howto
->type
== 0
1288 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1289 || relocs
[i
]->howto
->type
== 5)
1290 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1291 that has already been fully processed during a
1292 previous link stage, so ignore it here. */
1296 /* xgettext:c-format */
1297 einfo (_("%XError: %d-bit reloc in dll\n"),
1298 relocs
[i
]->howto
->bitsize
);
1304 /* Warning: the allocated symbols are remembered in BFD and
1305 reused later, so don't free them! */
1309 /* At this point, we have total_relocs relocation addresses in
1310 reloc_addresses, which are all suitable for the .reloc section.
1311 We must now create the new sections. */
1312 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1314 for (i
= 0; i
< total_relocs
; i
++)
1316 unsigned long this_page
= (reloc_data
[i
].vma
>> 12);
1318 if (this_page
!= sec_page
)
1320 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1322 sec_page
= this_page
;
1327 if (reloc_data
[i
].type
== 4)
1331 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1332 reloc_d
= xmalloc (reloc_sz
);
1333 sec_page
= (unsigned long) -1;
1335 page_ptr
= (unsigned long) -1;
1338 for (i
= 0; i
< total_relocs
; i
++)
1340 unsigned long rva
= reloc_data
[i
].vma
- image_base
;
1341 unsigned long this_page
= (rva
& ~0xfff);
1343 if (this_page
!= sec_page
)
1345 while (reloc_sz
& 3)
1346 reloc_d
[reloc_sz
++] = 0;
1348 if (page_ptr
!= (unsigned long) -1)
1349 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1351 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1352 page_ptr
= reloc_sz
;
1354 sec_page
= this_page
;
1358 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1359 reloc_d
+ reloc_sz
);
1362 if (reloc_data
[i
].type
== 4)
1364 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1371 while (reloc_sz
& 3)
1372 reloc_d
[reloc_sz
++] = 0;
1374 if (page_ptr
!= (unsigned long) -1)
1375 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1377 while (reloc_sz
< reloc_s
->size
)
1378 reloc_d
[reloc_sz
++] = 0;
1381 /* Given the exiting def_file structure, print out a .DEF file that
1382 corresponds to it. */
1385 quoteput (char *s
, FILE *f
, int needs_quotes
)
1389 for (cp
= s
; *cp
; cp
++)
1404 if (*s
== '"' || *s
== '\\')
1418 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1421 FILE *out
= fopen (pe_out_def_filename
, "w");
1424 /* xgettext:c-format */
1425 einfo (_("%s: Can't open output def file %s\n"),
1426 program_name
, pe_out_def_filename
);
1430 if (pe_def_file
->name
)
1432 if (pe_def_file
->is_dll
)
1433 fprintf (out
, "LIBRARY ");
1435 fprintf (out
, "NAME ");
1437 quoteput (pe_def_file
->name
, out
, 1);
1439 if (pe_data (output_bfd
)->pe_opthdr
.ImageBase
)
1440 fprintf (out
, " BASE=0x%lx",
1441 (unsigned long) pe_data (output_bfd
)->pe_opthdr
.ImageBase
);
1442 fprintf (out
, "\n");
1445 if (pe_def_file
->description
)
1447 fprintf (out
, "DESCRIPTION ");
1448 quoteput (pe_def_file
->description
, out
, 1);
1449 fprintf (out
, "\n");
1452 if (pe_def_file
->version_minor
!= -1)
1453 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1454 pe_def_file
->version_minor
);
1455 else if (pe_def_file
->version_major
!= -1)
1456 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1458 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1459 fprintf (out
, "\n");
1461 if (pe_def_file
->stack_commit
!= -1)
1462 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1463 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1464 else if (pe_def_file
->stack_reserve
!= -1)
1465 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1467 if (pe_def_file
->heap_commit
!= -1)
1468 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1469 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1470 else if (pe_def_file
->heap_reserve
!= -1)
1471 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1473 if (pe_def_file
->num_section_defs
> 0)
1475 fprintf (out
, "\nSECTIONS\n\n");
1477 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1480 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1482 if (pe_def_file
->section_defs
[i
].class)
1484 fprintf (out
, " CLASS ");
1485 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1488 if (pe_def_file
->section_defs
[i
].flag_read
)
1489 fprintf (out
, " READ");
1491 if (pe_def_file
->section_defs
[i
].flag_write
)
1492 fprintf (out
, " WRITE");
1494 if (pe_def_file
->section_defs
[i
].flag_execute
)
1495 fprintf (out
, " EXECUTE");
1497 if (pe_def_file
->section_defs
[i
].flag_shared
)
1498 fprintf (out
, " SHARED");
1500 fprintf (out
, "\n");
1504 if (pe_def_file
->num_exports
> 0)
1506 fprintf (out
, "EXPORTS\n");
1508 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1510 def_file_export
*e
= pe_def_file
->exports
+ i
;
1512 quoteput (e
->name
, out
, 0);
1514 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1516 fprintf (out
, " = ");
1517 quoteput (e
->internal_name
, out
, 0);
1520 if (e
->ordinal
!= -1)
1521 fprintf (out
, " @%d", e
->ordinal
);
1523 if (e
->flag_private
)
1524 fprintf (out
, " PRIVATE");
1526 if (e
->flag_constant
)
1527 fprintf (out
, " CONSTANT");
1530 fprintf (out
, " NONAME");
1533 fprintf (out
, " DATA");
1535 fprintf (out
, "\n");
1539 if (pe_def_file
->num_imports
> 0)
1541 fprintf (out
, "\nIMPORTS\n\n");
1543 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1545 def_file_import
*im
= pe_def_file
->imports
+ i
;
1548 if (im
->internal_name
1549 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1551 quoteput (im
->internal_name
, out
, 0);
1552 fprintf (out
, " = ");
1555 quoteput (im
->module
->name
, out
, 0);
1559 quoteput (im
->name
, out
, 0);
1561 fprintf (out
, "%d", im
->ordinal
);
1563 fprintf (out
, "\n");
1568 fprintf (out
, _("; no contents available\n"));
1570 if (fclose (out
) == EOF
)
1571 /* xgettext:c-format */
1572 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1575 /* Generate the import library. */
1577 static asymbol
**symtab
;
1580 static const char *dll_filename
;
1581 static char *dll_symname
;
1583 #define UNDSEC (asection *) &bfd_und_section
1586 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1591 sec
= bfd_make_section_old_way (abfd
, name
);
1592 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1593 bfd_set_section_alignment (abfd
, sec
, align
);
1594 /* Remember to undo this before trying to link internally! */
1595 sec
->output_section
= sec
;
1597 sym
= bfd_make_empty_symbol (abfd
);
1598 symtab
[symptr
++] = sym
;
1599 sym
->name
= sec
->name
;
1601 sym
->flags
= BSF_LOCAL
;
1608 quick_symbol (bfd
*abfd
,
1617 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1622 sym
= bfd_make_empty_symbol (abfd
);
1627 symtab
[symptr
++] = sym
;
1630 static arelent
*reltab
= 0;
1631 static int relcount
= 0, relsize
= 0;
1634 quick_reloc (bfd
*abfd
, int address
, int which_howto
, int symidx
)
1636 if (relcount
>= relsize
- 1)
1640 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1642 reltab
= xmalloc (relsize
* sizeof (arelent
));
1644 reltab
[relcount
].address
= address
;
1645 reltab
[relcount
].addend
= 0;
1646 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1647 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1652 save_relocs (asection
*sec
)
1656 sec
->relocation
= reltab
;
1657 sec
->reloc_count
= relcount
;
1658 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1659 for (i
= 0; i
< relcount
; i
++)
1660 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1661 sec
->orelocation
[relcount
] = 0;
1662 sec
->flags
|= SEC_RELOC
;
1664 relcount
= relsize
= 0;
1667 /* .section .idata$2
1668 .global __head_my_dll
1685 make_head (bfd
*parent
)
1687 asection
*id2
, *id5
, *id4
;
1688 unsigned char *d2
, *d5
, *d4
;
1692 oname
= xmalloc (20);
1693 sprintf (oname
, "d%06d.o", tmp_seq
);
1696 abfd
= bfd_create (oname
, parent
);
1697 bfd_find_target (pe_details
->object_target
, abfd
);
1698 bfd_make_writable (abfd
);
1700 bfd_set_format (abfd
, bfd_object
);
1701 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1704 symtab
= xmalloc (6 * sizeof (asymbol
*));
1705 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1706 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1707 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1708 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1709 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1711 /* OK, pay attention here. I got confused myself looking back at
1712 it. We create a four-byte section to mark the beginning of the
1713 list, and we include an offset of 4 in the section, so that the
1714 pointer to the list points to the *end* of this section, which is
1715 the start of the list of sections from other objects. */
1717 bfd_set_section_size (abfd
, id2
, 20);
1721 d2
[0] = d2
[16] = 4; /* Reloc addend. */
1722 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1723 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1724 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1727 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1728 d5
= xmalloc (PE_IDATA5_SIZE
);
1730 memset (d5
, 0, PE_IDATA5_SIZE
);
1732 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1733 d4
= xmalloc (PE_IDATA4_SIZE
);
1735 memset (d4
, 0, PE_IDATA4_SIZE
);
1737 bfd_set_symtab (abfd
, symtab
, symptr
);
1739 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1740 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1741 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1743 bfd_make_readable (abfd
);
1747 /* .section .idata$4
1754 .global __my_dll_iname
1759 make_tail (bfd
*parent
)
1761 asection
*id4
, *id5
, *id7
;
1762 unsigned char *d4
, *d5
, *d7
;
1767 oname
= xmalloc (20);
1768 sprintf (oname
, "d%06d.o", tmp_seq
);
1771 abfd
= bfd_create (oname
, parent
);
1772 bfd_find_target (pe_details
->object_target
, abfd
);
1773 bfd_make_writable (abfd
);
1775 bfd_set_format (abfd
, bfd_object
);
1776 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1779 symtab
= xmalloc (5 * sizeof (asymbol
*));
1780 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1781 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1782 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1783 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1785 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
1786 d4
= xmalloc (PE_IDATA4_SIZE
);
1788 memset (d4
, 0, PE_IDATA4_SIZE
);
1790 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1791 d5
= xmalloc (PE_IDATA5_SIZE
);
1793 memset (d5
, 0, PE_IDATA5_SIZE
);
1795 len
= strlen (dll_filename
) + 1;
1798 bfd_set_section_size (abfd
, id7
, len
);
1801 strcpy ((char *) d7
, dll_filename
);
1802 /* If len was odd, the above
1803 strcpy leaves behind an undefined byte. That is harmless,
1804 but we set it to 0 just so the binary dumps are pretty. */
1807 bfd_set_symtab (abfd
, symtab
, symptr
);
1809 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
1810 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
1811 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1813 bfd_make_readable (abfd
);
1819 .global ___imp_function
1820 .global __imp__function
1822 jmp *__imp__function:
1836 .asciz "function" xlate? (add underscore, kill at) */
1838 static const unsigned char jmp_ix86_bytes
[] =
1840 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1848 .dw __imp_function */
1850 static const unsigned char jmp_sh_bytes
[] =
1852 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1856 lui $t0,<high:__imp_function>
1857 lw $t0,<low:__imp_function>
1861 static const unsigned char jmp_mips_bytes
[] =
1863 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1864 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1867 static const unsigned char jmp_arm_bytes
[] =
1869 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
1870 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
1876 make_one (def_file_export
*exp
, bfd
*parent
)
1878 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1879 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1883 const unsigned char *jmp_bytes
= NULL
;
1884 int jmp_byte_count
= 0;
1886 switch (pe_details
->pe_arch
)
1889 jmp_bytes
= jmp_ix86_bytes
;
1890 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1893 jmp_bytes
= jmp_sh_bytes
;
1894 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1897 jmp_bytes
= jmp_mips_bytes
;
1898 jmp_byte_count
= sizeof (jmp_mips_bytes
);
1901 case PE_ARCH_arm_epoc
:
1902 case PE_ARCH_arm_wince
:
1903 jmp_bytes
= jmp_arm_bytes
;
1904 jmp_byte_count
= sizeof (jmp_arm_bytes
);
1910 oname
= xmalloc (20);
1911 sprintf (oname
, "d%06d.o", tmp_seq
);
1914 abfd
= bfd_create (oname
, parent
);
1915 bfd_find_target (pe_details
->object_target
, abfd
);
1916 bfd_make_writable (abfd
);
1918 bfd_set_format (abfd
, bfd_object
);
1919 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1922 symtab
= xmalloc (11 * sizeof (asymbol
*));
1923 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1924 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1925 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1926 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1927 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1929 if (*exp
->internal_name
== '@')
1931 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1933 if (! exp
->flag_data
)
1934 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1935 quick_symbol (abfd
, "__imp_", exp
->internal_name
, "", id5
,
1937 /* Fastcall applies only to functions,
1938 so no need for auto-import symbol. */
1942 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1944 if (! exp
->flag_data
)
1945 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
1947 quick_symbol (abfd
, "__imp_", U (""), exp
->internal_name
, id5
,
1949 /* Symbol to reference ord/name of imported
1950 data symbol, used to implement auto-import. */
1952 quick_symbol (abfd
, U ("_nm_"), U (""), exp
->internal_name
, id6
,
1955 if (pe_dll_compat_implib
)
1956 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "", id5
,
1959 if (! exp
->flag_data
)
1961 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
1962 td
= xmalloc (jmp_byte_count
);
1964 memcpy (td
, jmp_bytes
, jmp_byte_count
);
1966 switch (pe_details
->pe_arch
)
1969 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
1972 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
1975 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
1976 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
1977 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
1980 case PE_ARCH_arm_epoc
:
1981 case PE_ARCH_arm_wince
:
1982 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
1990 bfd_set_section_size (abfd
, id7
, 4);
1994 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
1997 bfd_set_section_size (abfd
, id5
, PE_IDATA5_SIZE
);
1998 d5
= xmalloc (PE_IDATA5_SIZE
);
2000 memset (d5
, 0, PE_IDATA5_SIZE
);
2002 if (exp
->flag_noname
)
2004 d5
[0] = exp
->ordinal
;
2005 d5
[1] = exp
->ordinal
>> 8;
2006 d5
[PE_IDATA5_SIZE
- 1] = 0x80;
2010 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2014 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
);
2015 d4
= xmalloc (PE_IDATA4_SIZE
);
2017 memset (d4
, 0, PE_IDATA4_SIZE
);
2019 if (exp
->flag_noname
)
2021 d4
[0] = exp
->ordinal
;
2022 d4
[1] = exp
->ordinal
>> 8;
2023 d4
[PE_IDATA4_SIZE
- 1] = 0x80;
2027 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
2031 if (exp
->flag_noname
)
2034 bfd_set_section_size (abfd
, id6
, 0);
2038 /* { short, asciz } */
2039 len
= 2 + strlen (exp
->name
) + 1;
2042 bfd_set_section_size (abfd
, id6
, len
);
2045 memset (d6
, 0, len
);
2046 d6
[0] = exp
->hint
& 0xff;
2047 d6
[1] = exp
->hint
>> 8;
2048 strcpy ((char *) d6
+ 2, exp
->name
);
2051 bfd_set_symtab (abfd
, symtab
, symptr
);
2053 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
2054 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
2055 bfd_set_section_contents (abfd
, id5
, d5
, 0, PE_IDATA5_SIZE
);
2056 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
);
2057 if (!exp
->flag_noname
)
2058 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
2060 bfd_make_readable (abfd
);
2065 make_singleton_name_thunk (const char *import
, bfd
*parent
)
2067 /* Name thunks go to idata$4. */
2073 oname
= xmalloc (20);
2074 sprintf (oname
, "nmth%06d.o", tmp_seq
);
2077 abfd
= bfd_create (oname
, parent
);
2078 bfd_find_target (pe_details
->object_target
, abfd
);
2079 bfd_make_writable (abfd
);
2081 bfd_set_format (abfd
, bfd_object
);
2082 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2085 symtab
= xmalloc (3 * sizeof (asymbol
*));
2086 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
2087 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
2088 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
2090 /* We need space for the real thunk and for the null terminator. */
2091 bfd_set_section_size (abfd
, id4
, PE_IDATA4_SIZE
* 2);
2092 d4
= xmalloc (PE_IDATA4_SIZE
* 2);
2094 memset (d4
, 0, PE_IDATA4_SIZE
* 2);
2095 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
2098 bfd_set_symtab (abfd
, symtab
, symptr
);
2100 bfd_set_section_contents (abfd
, id4
, d4
, 0, PE_IDATA4_SIZE
* 2);
2102 bfd_make_readable (abfd
);
2107 make_import_fixup_mark (arelent
*rel
)
2109 /* We convert reloc to symbol, for later reference. */
2111 static char *fixup_name
= NULL
;
2112 static size_t buffer_len
= 0;
2114 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2116 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2117 struct bfd_link_hash_entry
*bh
;
2121 fixup_name
= xmalloc (384);
2125 if (strlen (sym
->name
) + 25 > buffer_len
)
2126 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2127 bigger than 20 digits long, we've got worse problems than
2128 overflowing this buffer... */
2131 /* New buffer size is length of symbol, plus 25, but
2132 then rounded up to the nearest multiple of 128. */
2133 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2134 fixup_name
= xmalloc (buffer_len
);
2137 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2140 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2141 current_sec
, /* sym->section, */
2142 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2147 /* .section .idata$2
2148 .rva __nm_thnk_SYM (singleton thunk with name of func)
2151 .rva __my_dll_iname (name of dll)
2152 .rva __fuNN_SYM (pointer to reference (address) in text) */
2155 make_import_fixup_entry (const char *name
,
2156 const char *fixup_name
,
2157 const char *dll_symname
,
2165 oname
= xmalloc (20);
2166 sprintf (oname
, "fu%06d.o", tmp_seq
);
2169 abfd
= bfd_create (oname
, parent
);
2170 bfd_find_target (pe_details
->object_target
, abfd
);
2171 bfd_make_writable (abfd
);
2173 bfd_set_format (abfd
, bfd_object
);
2174 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2177 symtab
= xmalloc (6 * sizeof (asymbol
*));
2178 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
2180 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2181 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2182 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2184 bfd_set_section_size (abfd
, id2
, 20);
2189 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2190 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2191 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2194 bfd_set_symtab (abfd
, symtab
, symptr
);
2196 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
2198 bfd_make_readable (abfd
);
2202 /* .section .rdata_runtime_pseudo_reloc
2204 .rva __fuNN_SYM (pointer to reference (address) in text) */
2207 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2208 const char *fixup_name
,
2213 unsigned char *rt_rel_d
;
2217 oname
= xmalloc (20);
2218 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2221 abfd
= bfd_create (oname
, parent
);
2222 bfd_find_target (pe_details
->object_target
, abfd
);
2223 bfd_make_writable (abfd
);
2225 bfd_set_format (abfd
, bfd_object
);
2226 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2229 symtab
= xmalloc (2 * sizeof (asymbol
*));
2230 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2231 SEC_HAS_CONTENTS
, 2);
2233 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2235 bfd_set_section_size (abfd
, rt_rel
, 8);
2236 rt_rel_d
= xmalloc (8);
2237 rt_rel
->contents
= rt_rel_d
;
2238 memset (rt_rel_d
, 0, 8);
2239 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2241 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2242 save_relocs (rt_rel
);
2244 bfd_set_symtab (abfd
, symtab
, symptr
);
2246 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2248 bfd_make_readable (abfd
);
2253 .rva __pei386_runtime_relocator */
2256 pe_create_runtime_relocator_reference (bfd
*parent
)
2258 asection
*extern_rt_rel
;
2259 unsigned char *extern_rt_rel_d
;
2263 oname
= xmalloc (20);
2264 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2267 abfd
= bfd_create (oname
, parent
);
2268 bfd_find_target (pe_details
->object_target
, abfd
);
2269 bfd_make_writable (abfd
);
2271 bfd_set_format (abfd
, bfd_object
);
2272 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2275 symtab
= xmalloc (2 * sizeof (asymbol
*));
2276 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2278 quick_symbol (abfd
, "", U ("_pei386_runtime_relocator"), "", UNDSEC
,
2281 bfd_set_section_size (abfd
, extern_rt_rel
, 4);
2282 extern_rt_rel_d
= xmalloc (4);
2283 extern_rt_rel
->contents
= extern_rt_rel_d
;
2285 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2286 save_relocs (extern_rt_rel
);
2288 bfd_set_symtab (abfd
, symtab
, symptr
);
2290 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, 4);
2292 bfd_make_readable (abfd
);
2297 pe_create_import_fixup (arelent
*rel
, asection
*s
, int addend
)
2300 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2301 struct bfd_link_hash_entry
*name_thunk_sym
;
2302 const char *name
= sym
->name
;
2303 char *fixup_name
= make_import_fixup_mark (rel
);
2306 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2308 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2310 if (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
)
2312 bfd
*b
= make_singleton_name_thunk (name
, output_bfd
);
2313 add_bfd_to_link (b
, b
->filename
, &link_info
);
2315 /* If we ever use autoimport, we have to cast text section writable. */
2316 config
.text_read_only
= FALSE
;
2317 output_bfd
->flags
&= ~WP_TEXT
;
2320 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2322 extern char * pe_data_import_dll
;
2323 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2325 b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
, output_bfd
);
2326 add_bfd_to_link (b
, b
->filename
, &link_info
);
2331 if (link_info
.pei386_runtime_pseudo_reloc
)
2333 if (pe_dll_extra_pe_debug
)
2334 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2335 fixup_name
, addend
);
2336 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, output_bfd
);
2337 add_bfd_to_link (b
, b
->filename
, &link_info
);
2339 if (runtime_pseudo_relocs_created
== 0)
2341 b
= pe_create_runtime_relocator_reference (output_bfd
);
2342 add_bfd_to_link (b
, b
->filename
, &link_info
);
2344 runtime_pseudo_relocs_created
++;
2348 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2349 s
->owner
, s
, rel
->address
, sym
->name
);
2357 pe_dll_generate_implib (def_file
*def
, const char *impfilename
)
2365 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2366 dll_symname
= xstrdup (dll_filename
);
2367 for (i
= 0; dll_symname
[i
]; i
++)
2368 if (!ISALNUM (dll_symname
[i
]))
2369 dll_symname
[i
] = '_';
2371 unlink_if_ordinary (impfilename
);
2373 outarch
= bfd_openw (impfilename
, 0);
2377 /* xgettext:c-format */
2378 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2382 /* xgettext:c-format */
2383 info_msg (_("Creating library file: %s\n"), impfilename
);
2385 bfd_set_format (outarch
, bfd_archive
);
2386 outarch
->has_armap
= 1;
2388 /* Work out a reasonable size of things to put onto one line. */
2389 ar_head
= make_head (outarch
);
2391 for (i
= 0; i
< def
->num_exports
; i
++)
2393 /* The import library doesn't know about the internal name. */
2394 char *internal
= def
->exports
[i
].internal_name
;
2397 /* Don't add PRIVATE entries to import lib. */
2398 if (pe_def_file
->exports
[i
].flag_private
)
2400 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2401 n
= make_one (def
->exports
+ i
, outarch
);
2404 def
->exports
[i
].internal_name
= internal
;
2407 ar_tail
= make_tail (outarch
);
2409 if (ar_head
== NULL
|| ar_tail
== NULL
)
2412 /* Now stick them all into the archive. */
2413 ar_head
->next
= head
;
2414 ar_tail
->next
= ar_head
;
2417 if (! bfd_set_archive_head (outarch
, head
))
2418 einfo ("%Xbfd_set_archive_head: %E\n");
2420 if (! bfd_close (outarch
))
2421 einfo ("%Xbfd_close %s: %E\n", impfilename
);
2423 while (head
!= NULL
)
2425 bfd
*n
= head
->next
;
2432 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*link_info
)
2434 lang_input_statement_type
*fake_file
;
2436 fake_file
= lang_add_input_file (name
,
2437 lang_input_file_is_fake_enum
,
2439 fake_file
->the_bfd
= abfd
;
2440 ldlang_add_file (fake_file
);
2442 if (!bfd_link_add_symbols (abfd
, link_info
))
2443 einfo ("%Xaddsym %s: %E\n", name
);
2447 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*link_info
)
2449 def_file_module
*module
;
2451 pe_dll_id_target (bfd_get_target (output_bfd
));
2456 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2460 dll_filename
= module
->name
;
2461 dll_symname
= xstrdup (module
->name
);
2462 for (i
= 0; dll_symname
[i
]; i
++)
2463 if (!ISALNUM (dll_symname
[i
]))
2464 dll_symname
[i
] = '_';
2468 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2469 if (pe_def_file
->imports
[i
].module
== module
)
2471 def_file_export exp
;
2472 struct bfd_link_hash_entry
*blhe
;
2473 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2474 /* See if we need this import. */
2475 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2476 char *name
= xmalloc (len
+ 2 + 6);
2479 sprintf (name
, "%s",
2480 pe_def_file
->imports
[i
].internal_name
);
2482 sprintf (name
, "%s%s",U (""),
2483 pe_def_file
->imports
[i
].internal_name
);
2485 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2486 FALSE
, FALSE
, FALSE
);
2488 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2491 sprintf (name
, "%s%s", "__imp_",
2492 pe_def_file
->imports
[i
].internal_name
);
2494 sprintf (name
, "%s%s%s", "__imp_", U (""),
2495 pe_def_file
->imports
[i
].internal_name
);
2497 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2498 FALSE
, FALSE
, FALSE
);
2502 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2508 bfd
*ar_head
= make_head (output_bfd
);
2509 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2512 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2513 exp
.name
= pe_def_file
->imports
[i
].name
;
2514 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2515 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2516 exp
.flag_private
= 0;
2517 exp
.flag_constant
= 0;
2518 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2519 exp
.flag_noname
= exp
.name
? 0 : 1;
2520 one
= make_one (&exp
, output_bfd
);
2521 add_bfd_to_link (one
, one
->filename
, link_info
);
2526 bfd
*ar_tail
= make_tail (output_bfd
);
2527 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2534 /* We were handed a *.DLL file. Parse it and turn it into a set of
2535 IMPORTS directives in the def file. Return TRUE if the file was
2536 handled, FALSE if not. */
2539 pe_get16 (bfd
*abfd
, int where
)
2543 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2544 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2545 return b
[0] + (b
[1] << 8);
2549 pe_get32 (bfd
*abfd
, int where
)
2553 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2554 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2555 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2561 unsigned char *b
= ptr
;
2563 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2567 pe_implied_import_dll (const char *filename
)
2570 unsigned long pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2571 unsigned long export_rva
, export_size
, nsections
, secptr
, expptr
;
2572 unsigned long exp_funcbase
;
2573 unsigned char *expdata
;
2575 unsigned long name_rvas
, ordinals
, nexp
, ordbase
;
2576 const char *dll_name
;
2577 /* Initialization with start > end guarantees that is_data
2578 will not be set by mistake, and avoids compiler warning. */
2579 unsigned long data_start
= 1;
2580 unsigned long data_end
= 0;
2581 unsigned long rdata_start
= 1;
2582 unsigned long rdata_end
= 0;
2583 unsigned long bss_start
= 1;
2584 unsigned long bss_end
= 0;
2586 /* No, I can't use bfd here. kernel32.dll puts its export table in
2587 the middle of the .rdata section. */
2588 dll
= bfd_openr (filename
, pe_details
->target_name
);
2591 einfo ("%Xopen %s: %E\n", filename
);
2595 /* PEI dlls seem to be bfd_objects. */
2596 if (!bfd_check_format (dll
, bfd_object
))
2598 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2602 /* Get pe_header, optional header and numbers of export entries. */
2603 pe_header_offset
= pe_get32 (dll
, 0x3c);
2604 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2605 #ifdef pe_use_x86_64
2606 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
2608 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2611 if (num_entries
< 1) /* No exports. */
2614 #ifdef pe_use_x86_64
2615 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96 + 4 * 4);
2616 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100 + 4 * 4);
2618 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2619 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2622 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2623 secptr
= (pe_header_offset
+ 4 + 20 +
2624 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2627 /* Get the rva and size of the export section. */
2628 for (i
= 0; i
< nsections
; i
++)
2631 unsigned long secptr1
= secptr
+ 40 * i
;
2632 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
2633 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 16);
2634 unsigned long fptr
= pe_get32 (dll
, secptr1
+ 20);
2636 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2637 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2639 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2641 expptr
= fptr
+ (export_rva
- vaddr
);
2642 if (export_rva
+ export_size
> vaddr
+ vsize
)
2643 export_size
= vsize
- (export_rva
- vaddr
);
2648 /* Scan sections and store the base and size of the
2649 data and bss segments in data/base_start/end. */
2650 for (i
= 0; i
< nsections
; i
++)
2652 unsigned long secptr1
= secptr
+ 40 * i
;
2653 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 8);
2654 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
2655 unsigned long flags
= pe_get32 (dll
, secptr1
+ 36);
2659 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
2660 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
2662 if (strcmp(sec_name
,".data") == 0)
2665 data_end
= vaddr
+ vsize
;
2667 if (pe_dll_extra_pe_debug
)
2668 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2669 __FUNCTION__
, sec_name
, vaddr
, vaddr
+ vsize
, flags
);
2671 else if (strcmp(sec_name
,".rdata") == 0)
2673 rdata_start
= vaddr
;
2674 rdata_end
= vaddr
+ vsize
;
2676 if (pe_dll_extra_pe_debug
)
2677 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2678 __FUNCTION__
, sec_name
, vaddr
, vaddr
+ vsize
, flags
);
2680 else if (strcmp (sec_name
,".bss") == 0)
2683 bss_end
= vaddr
+ vsize
;
2685 if (pe_dll_extra_pe_debug
)
2686 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2687 __FUNCTION__
, sec_name
, vaddr
, vaddr
+ vsize
, flags
);
2691 expdata
= xmalloc (export_size
);
2692 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2693 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2694 erva
= (char *) expdata
- export_rva
;
2696 if (pe_def_file
== 0)
2697 pe_def_file
= def_file_empty ();
2699 nexp
= pe_as32 (expdata
+ 24);
2700 name_rvas
= pe_as32 (expdata
+ 32);
2701 ordinals
= pe_as32 (expdata
+ 36);
2702 ordbase
= pe_as32 (expdata
+ 16);
2703 exp_funcbase
= pe_as32 (expdata
+ 28);
2705 /* Use internal dll name instead of filename
2706 to enable symbolic dll linking. */
2707 dll_name
= erva
+ pe_as32 (expdata
+ 12);
2709 /* Check to see if the dll has already been added to
2710 the definition list and if so return without error.
2711 This avoids multiple symbol definitions. */
2712 if (def_get_module (pe_def_file
, dll_name
))
2714 if (pe_dll_extra_pe_debug
)
2715 printf ("%s is already loaded\n", dll_name
);
2719 /* Iterate through the list of symbols. */
2720 for (i
= 0; i
< nexp
; i
++)
2722 /* Pointer to the names vector. */
2723 unsigned long name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
2724 def_file_import
*imp
;
2725 /* Pointer to the function address vector. */
2726 unsigned long func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
2729 /* Skip unwanted symbols, which are
2730 exported in buggy auto-import releases. */
2731 if (! CONST_STRNEQ (erva
+ name_rva
, "_nm_"))
2733 /* is_data is true if the address is in the data, rdata or bss
2736 (func_rva
>= data_start
&& func_rva
< data_end
)
2737 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
2738 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
2740 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
2742 /* Mark symbol type. */
2743 imp
->data
= is_data
;
2745 if (pe_dll_extra_pe_debug
)
2746 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2747 __FUNCTION__
, dll_name
, erva
+ name_rva
,
2748 func_rva
, is_data
? "(data)" : "");
2755 /* These are the main functions, called from the emulation. The first
2756 is called after the bfds are read, so we can guess at how much space
2757 we need. The second is called after everything is placed, so we
2758 can put the right values in place. */
2761 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2763 pe_dll_id_target (bfd_get_target (abfd
));
2764 process_def_file (abfd
, info
);
2766 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
2769 generate_edata (abfd
, info
);
2770 build_filler_bfd (1);
2774 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2776 pe_dll_id_target (bfd_get_target (abfd
));
2777 build_filler_bfd (0);
2781 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2783 pe_dll_id_target (bfd_get_target (abfd
));
2784 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2786 generate_reloc (abfd
, info
);
2789 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2791 /* Resize the sections. */
2792 lang_reset_memory_regions ();
2793 lang_size_sections (NULL
, TRUE
);
2795 /* Redo special stuff. */
2796 ldemul_after_allocation ();
2798 /* Do the assignments again. */
2799 lang_do_assignments ();
2802 fill_edata (abfd
, info
);
2804 if (info
->shared
&& !info
->pie
)
2805 pe_data (abfd
)->dll
= 1;
2807 edata_s
->contents
= edata_d
;
2808 reloc_s
->contents
= reloc_d
;
2812 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2814 pe_dll_id_target (bfd_get_target (abfd
));
2815 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2817 generate_reloc (abfd
, info
);
2820 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2822 /* Resize the sections. */
2823 lang_reset_memory_regions ();
2824 lang_size_sections (NULL
, TRUE
);
2826 /* Redo special stuff. */
2827 ldemul_after_allocation ();
2829 /* Do the assignments again. */
2830 lang_do_assignments ();
2832 reloc_s
->contents
= reloc_d
;
2836 pe_bfd_is_dll (bfd
*abfd
)
2838 return (bfd_get_format (abfd
) == bfd_object
2840 && pe_data (abfd
)->dll
);