1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3 Written by DJ Delorie <dj@cygnus.com>
5 This file is part of GLD, the Gnu Linker.
7 GLD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GLD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GLD; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
39 #include "coff/internal.h"
40 #include "../bfd/libcoff.h"
44 /* This file turns a regular Windows PE image into a DLL. Because of
45 the complexity of this operation, it has been broken down into a
46 number of separate modules which are all called by the main function
47 at the end of this file. This function is not re-entrant and is
48 normally only called once, so static variables are used to reduce
49 the number of parameters and return values required.
51 See also: ld/emultempl/pe.em. */
53 /* Auto-import feature by Paul Sokolovsky
57 1. With this feature on, DLL clients can import variables from DLL
58 without any concern from their side (for example, without any source
61 2. This is done completely in bounds of the PE specification (to be fair,
62 there's a place where it pokes nose out of, but in practice it works).
63 So, resulting module can be used with any other PE compiler/linker.
65 3. Auto-import is fully compatible with standard import method and they
66 can be mixed together.
68 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
69 reference to it; load time: negligible; virtual/physical memory: should be
70 less than effect of DLL relocation, and I sincerely hope it doesn't affect
71 DLL sharability (too much).
75 The obvious and only way to get rid of dllimport insanity is to make client
76 access variable directly in the DLL, bypassing extra dereference. I.e.,
77 whenever client contains something like
81 address of dll_var in the command should be relocated to point into loaded
82 DLL. The aim is to make OS loader do so, and than make ld help with that.
83 Import section of PE made following way: there's a vector of structures
84 each describing imports from particular DLL. Each such structure points
85 to two other parallel vectors: one holding imported names, and one which
86 will hold address of corresponding imported name. So, the solution is
87 de-vectorize these structures, making import locations be sparse and
88 pointing directly into code. Before continuing, it is worth a note that,
89 while authors strives to make PE act ELF-like, there're some other people
90 make ELF act PE-like: elfvector, ;-) .
94 For each reference of data symbol to be imported from DLL (to set of which
95 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
96 import fixup entry is generated. That entry is of type
97 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$3 subsection. Each
98 fixup entry contains pointer to symbol's address within .text section
99 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
100 (so, DLL name is referenced by multiple entries), and pointer to symbol
101 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
102 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
103 containing imported name. Here comes that "om the edge" problem mentioned
104 above: PE specification rambles that name vector (OriginalFirstThunk)
105 should run in parallel with addresses vector (FirstThunk), i.e. that they
106 should have same number of elements and terminated with zero. We violate
107 this, since FirstThunk points directly into machine code. But in practice,
108 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
109 puts addresses to FirstThunk, not something else. It once again should be
110 noted that dll and symbol name structures are reused across fixup entries
111 and should be there anyway to support standard import stuff, so sustained
112 overhead is 20 bytes per reference. Other question is whether having several
113 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
114 done even by native compiler/linker (libth32's functions are in fact reside
115 in windows9x kernel32.dll, so if you use it, you have two
116 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
117 referencing the same PE structures several times is valid. The answer is why
118 not, prohibiting that (detecting violation) would require more work on
119 behalf of loader than not doing it.
121 See also: ld/emultempl/pe.em. */
124 add_bfd_to_link
PARAMS ((bfd
*, const char *, struct bfd_link_info
*));
126 /* For emultempl/pe.em. */
128 def_file
* pe_def_file
= 0;
129 int pe_dll_export_everything
= 0;
130 int pe_dll_do_default_excludes
= 1;
131 int pe_dll_kill_ats
= 0;
132 int pe_dll_stdcall_aliases
= 0;
133 int pe_dll_warn_dup_exports
= 0;
134 int pe_dll_compat_implib
= 0;
135 int pe_dll_extra_pe_debug
= 0;
137 /* Static variables and types. */
139 static bfd_vma image_base
;
140 static bfd
*filler_bfd
;
141 static struct sec
*edata_s
, *reloc_s
;
142 static unsigned char *edata_d
, *reloc_d
;
143 static size_t edata_sz
, reloc_sz
;
144 static int runtime_pseudo_relocs_created
= 0;
150 unsigned int imagebase_reloc
;
162 autofilter_entry_type
;
164 #define PE_ARCH_i386 1
166 #define PE_ARCH_mips 3
167 #define PE_ARCH_arm 4
168 #define PE_ARCH_arm_epoc 5
170 static pe_details_type pe_detail_list
[] =
183 16 /* R_SH_IMAGEBASE */,
205 "epoc-pei-arm-little",
206 "epoc-pe-arm-little",
212 { NULL
, NULL
, 0, 0, 0, 0 }
215 static pe_details_type
*pe_details
;
217 static autofilter_entry_type autofilter_symbollist
[] =
219 { "DllMain@12", 10 },
220 { "DllEntryPoint@0", 15 },
221 { "DllMainCRTStartup@12", 20 },
222 { "_cygwin_dll_entry@12", 20 },
223 { "_cygwin_crt0_common@8", 21 },
224 { "_cygwin_noncygwin_dll_entry@12", 30 },
225 { "impure_ptr", 10 },
226 { "_pei386_runtime_relocator", 25 },
227 { "do_pseudo_reloc", 15 },
231 /* Do not specify library suffix explicitly, to allow for dllized versions. */
232 static autofilter_entry_type autofilter_liblist
[] =
236 { "libmingw32", 10 },
237 { "libmingwex", 10 },
245 static autofilter_entry_type autofilter_objlist
[] =
255 { "crtbegin.o", 10 },
260 static autofilter_entry_type autofilter_symbolprefixlist
[] =
262 /* { "__imp_", 6 }, */
263 /* Do __imp_ explicitly to save time. */
265 /* Don't re-export auto-imported symbols. */
267 { "__builtin_", 10 },
268 /* Don't export symbols specifying internal DLL layout. */
271 { "_impure_ptr", 11 },
272 { "cygwin_attach_dll", 17 },
273 { "cygwin_premain0", 15 },
274 { "cygwin_premain1", 15 },
275 { "cygwin_premain2", 15 },
276 { "cygwin_premain3", 15 },
281 static autofilter_entry_type autofilter_symbolsuffixlist
[] =
287 #define U(str) (pe_details->underscored ? "_" str : str)
289 static int reloc_sort
PARAMS ((const void *, const void *));
290 static int pe_export_sort
PARAMS ((const void *, const void *));
291 static int auto_export
PARAMS ((bfd
*, def_file
*, const char *));
292 static void process_def_file
PARAMS ((bfd
*, struct bfd_link_info
*));
293 static void build_filler_bfd
PARAMS ((int));
294 static void generate_edata
PARAMS ((bfd
*, struct bfd_link_info
*));
295 static void fill_exported_offsets
PARAMS ((bfd
*, struct bfd_link_info
*));
296 static void fill_edata
PARAMS ((bfd
*, struct bfd_link_info
*));
297 static void generate_reloc
PARAMS ((bfd
*, struct bfd_link_info
*));
298 static void quoteput
PARAMS ((char *, FILE *, int));
299 static asection
*quick_section
PARAMS ((bfd
*, const char *, int, int));
300 static void quick_symbol
301 PARAMS ((bfd
*, const char *, const char *, const char *,
302 asection
*, int, int));
303 static void quick_reloc
PARAMS ((bfd
*, int, int, int));
304 static bfd
*make_head
PARAMS ((bfd
*));
305 static bfd
*make_tail
PARAMS ((bfd
*));
306 static bfd
*make_one
PARAMS ((def_file_export
*, bfd
*));
307 static bfd
*make_singleton_name_thunk
PARAMS ((const char *, bfd
*));
308 static char *make_import_fixup_mark
PARAMS ((arelent
*));
309 static bfd
*make_import_fixup_entry
310 PARAMS ((const char *, const char *, const char *, bfd
*));
311 static bfd
*make_runtime_pseudo_reloc
312 PARAMS ((const char *, const char *, int, bfd
*));
313 static bfd
*pe_create_runtime_relocator_reference
315 static unsigned int pe_get16
PARAMS ((bfd
*, int));
316 static unsigned int pe_get32
PARAMS ((bfd
*, int));
317 static unsigned int pe_as32
PARAMS ((void *));
320 pe_dll_id_target (target
)
325 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
326 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
327 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
329 pe_details
= pe_detail_list
+ i
;
332 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
336 /* Helper functions for qsort. Relocs must be sorted so that we can write
337 them out by pages. */
351 bfd_vma a
= ((reloc_data_type
*) va
)->vma
;
352 bfd_vma b
= ((reloc_data_type
*) vb
)->vma
;
354 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
358 pe_export_sort (va
, vb
)
361 def_file_export
*a
= (def_file_export
*) va
;
362 def_file_export
*b
= (def_file_export
*) vb
;
364 return strcmp (a
->name
, b
->name
);
367 /* Read and process the .DEF file. */
369 /* These correspond to the entries in pe_def_file->exports[]. I use
370 exported_symbol_sections[i] to tag whether or not the symbol was
371 defined, since we can't export symbols we don't have. */
373 static bfd_vma
*exported_symbol_offsets
;
374 static struct sec
**exported_symbol_sections
;
375 static int export_table_size
;
376 static int count_exported
;
377 static int count_exported_byname
;
378 static int count_with_ordinals
;
379 static const char *dll_name
;
380 static int min_ordinal
, max_ordinal
;
381 static int *exported_symbols
;
383 typedef struct exclude_list_struct
386 struct exclude_list_struct
*next
;
391 static struct exclude_list_struct
*excludes
= 0;
394 pe_dll_add_excludes (new_excludes
, type
)
395 const char *new_excludes
;
399 char *exclude_string
;
401 local_copy
= xstrdup (new_excludes
);
403 exclude_string
= strtok (local_copy
, ",:");
404 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
406 struct exclude_list_struct
*new_exclude
;
408 new_exclude
= ((struct exclude_list_struct
*)
409 xmalloc (sizeof (struct exclude_list_struct
)));
410 new_exclude
->string
= (char *) xmalloc (strlen (exclude_string
) + 1);
411 strcpy (new_exclude
->string
, exclude_string
);
412 new_exclude
->type
= type
;
413 new_exclude
->next
= excludes
;
414 excludes
= new_exclude
;
421 /* abfd is a bfd containing n (or NULL)
422 It can be used for contextual checks. */
425 auto_export (abfd
, d
, n
)
431 struct exclude_list_struct
*ex
;
432 autofilter_entry_type
*afptr
;
433 const char * libname
= 0;
434 if (abfd
&& abfd
->my_archive
)
435 libname
= lbasename (abfd
->my_archive
->filename
);
437 /* We should not re-export imported stuff. */
438 if (strncmp (n
, "_imp__", 6) == 0)
441 for (i
= 0; i
< d
->num_exports
; i
++)
442 if (strcmp (d
->exports
[i
].name
, n
) == 0)
445 if (pe_dll_do_default_excludes
)
450 if (pe_dll_extra_pe_debug
)
451 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
452 n
, abfd
, abfd
->my_archive
);
454 /* First of all, make context checks:
455 Don't export anything from standard libs. */
458 afptr
= autofilter_liblist
;
462 if (strncmp (libname
, afptr
->name
, afptr
->len
) == 0 )
468 /* Next, exclude symbols from certain startup objects. */
470 if (abfd
&& (p
= lbasename (abfd
->filename
)))
472 afptr
= autofilter_objlist
;
475 if (strcmp (p
, afptr
->name
) == 0)
481 /* Don't try to blindly exclude all symbols
482 that begin with '__'; this was tried and
483 it is too restrictive. */
485 /* Then, exclude specific symbols. */
486 afptr
= autofilter_symbollist
;
489 if (strcmp (n
, afptr
->name
) == 0)
495 /* Next, exclude symbols starting with ... */
496 afptr
= autofilter_symbolprefixlist
;
499 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
505 /* Finally, exclude symbols ending with ... */
507 afptr
= autofilter_symbolsuffixlist
;
510 if ((len
>= afptr
->len
)
511 /* Add 1 to insure match with trailing '\0'. */
512 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
513 afptr
->len
+ 1) == 0)
520 for (ex
= excludes
; ex
; ex
= ex
->next
)
522 if (ex
->type
== 1) /* exclude-libs */
525 && ((strcmp (libname
, ex
->string
) == 0)
526 || (strcasecmp ("ALL", ex
->string
) == 0)))
529 else if (strcmp (n
, ex
->string
) == 0)
537 process_def_file (abfd
, info
)
538 bfd
*abfd ATTRIBUTE_UNUSED
;
539 struct bfd_link_info
*info
;
542 struct bfd_link_hash_entry
*blhe
;
545 def_file_export
*e
= 0;
548 pe_def_file
= def_file_empty ();
550 /* First, run around to all the objects looking for the .drectve
551 sections, and push those into the def file too. */
552 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
554 s
= bfd_get_section_by_name (b
, ".drectve");
557 int size
= bfd_get_section_size_before_reloc (s
);
558 char *buf
= xmalloc (size
);
560 bfd_get_section_contents (b
, s
, buf
, 0, size
);
561 def_file_add_directive (pe_def_file
, buf
, size
);
566 /* Now, maybe export everything else the default way. */
567 if (pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
569 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
574 symsize
= bfd_get_symtab_upper_bound (b
);
575 symbols
= (asymbol
**) xmalloc (symsize
);
576 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
578 for (j
= 0; j
< nsyms
; j
++)
580 /* We should export symbols which are either global or not
581 anything at all. (.bss data is the latter)
582 We should not export undefined symbols. */
583 if (symbols
[j
]->section
!= &bfd_und_section
584 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
585 || (symbols
[j
]->flags
== BFD_FORT_COMM_DEFAULT_VALUE
)))
587 const char *sn
= symbols
[j
]->name
;
589 /* We should not re-export imported stuff. */
591 char *name
= (char *) xmalloc (strlen (sn
) + 2 + 6);
592 sprintf (name
, "%s%s", U("_imp_"), sn
);
594 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
595 FALSE
, FALSE
, FALSE
);
598 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
605 if (auto_export (b
, pe_def_file
, sn
))
608 p
=def_file_add_export (pe_def_file
, sn
, 0, -1);
609 /* Fill data flag properly, from dlltool.c. */
610 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
618 #define NE pe_def_file->num_exports
620 /* Canonicalize the export list. */
623 for (i
= 0; i
< NE
; i
++)
625 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
627 /* This will preserve internal_name, which may have been
628 pointing to the same memory as name, or might not
630 int lead_at
= (*pe_def_file
->exports
[i
].name
=='@');
631 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
633 *(strchr (tmp
, '@')) = 0;
634 pe_def_file
->exports
[i
].name
= tmp
;
639 if (pe_dll_stdcall_aliases
)
641 for (i
= 0; i
< NE
; i
++)
643 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
645 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@' ) ;
646 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
648 *(strchr (tmp
, '@')) = 0;
649 if (auto_export (NULL
, pe_def_file
, tmp
))
650 def_file_add_export (pe_def_file
, tmp
,
651 pe_def_file
->exports
[i
].internal_name
,
659 /* Convenience, but watch out for it changing. */
660 e
= pe_def_file
->exports
;
662 exported_symbol_offsets
= (bfd_vma
*) xmalloc (NE
* sizeof (bfd_vma
));
663 exported_symbol_sections
= (struct sec
**) xmalloc (NE
* sizeof (struct sec
*));
665 memset (exported_symbol_sections
, 0, NE
* sizeof (struct sec
*));
669 count_exported_byname
= 0;
670 count_with_ordinals
= 0;
672 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]), pe_export_sort
);
673 for (i
= 0, j
= 0; i
< NE
; i
++)
675 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
677 /* This is a duplicate. */
678 if (e
[j
- 1].ordinal
!= -1
679 && e
[i
].ordinal
!= -1
680 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
682 if (pe_dll_warn_dup_exports
)
683 /* xgettext:c-format */
684 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
685 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
689 if (pe_dll_warn_dup_exports
)
690 /* xgettext:c-format */
691 einfo (_("Warning, duplicate EXPORT: %s\n"),
695 if (e
[i
].ordinal
!= -1)
696 e
[j
- 1].ordinal
= e
[i
].ordinal
;
697 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
698 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
699 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
700 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
709 pe_def_file
->num_exports
= j
; /* == NE */
711 for (i
= 0; i
< NE
; i
++)
713 char *name
= (char *) xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
715 if (pe_details
->underscored
716 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
719 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
722 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
724 blhe
= bfd_link_hash_lookup (info
->hash
,
729 && (blhe
->type
== bfd_link_hash_defined
730 || (blhe
->type
== bfd_link_hash_common
)))
733 if (!pe_def_file
->exports
[i
].flag_noname
)
734 count_exported_byname
++;
736 /* Only fill in the sections. The actual offsets are computed
737 in fill_exported_offsets() after common symbols are laid
739 if (blhe
->type
== bfd_link_hash_defined
)
740 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
742 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
744 if (pe_def_file
->exports
[i
].ordinal
!= -1)
746 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
747 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
748 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
749 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
750 count_with_ordinals
++;
753 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
755 /* xgettext:c-format */
756 einfo (_("%XCannot export %s: symbol not defined\n"),
757 pe_def_file
->exports
[i
].internal_name
);
761 /* xgettext:c-format */
762 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
763 pe_def_file
->exports
[i
].internal_name
,
764 blhe
->type
, bfd_link_hash_defined
);
768 /* xgettext:c-format */
769 einfo (_("%XCannot export %s: symbol not found\n"),
770 pe_def_file
->exports
[i
].internal_name
);
776 /* Build the bfd that will contain .edata and .reloc sections. */
779 build_filler_bfd (include_edata
)
782 lang_input_statement_type
*filler_file
;
783 filler_file
= lang_add_input_file ("dll stuff",
784 lang_input_file_is_fake_enum
,
786 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff", output_bfd
);
787 if (filler_bfd
== NULL
788 || !bfd_set_arch_mach (filler_bfd
,
789 bfd_get_arch (output_bfd
),
790 bfd_get_mach (output_bfd
)))
792 einfo ("%X%P: can not create BFD %E\n");
798 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
800 || !bfd_set_section_flags (filler_bfd
, edata_s
,
807 einfo ("%X%P: can not create .edata section: %E\n");
810 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
813 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
815 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
822 einfo ("%X%P: can not create .reloc section: %E\n");
826 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
828 ldlang_add_file (filler_file
);
831 /* Gather all the exported symbols and build the .edata section. */
834 generate_edata (abfd
, info
)
836 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
839 int name_table_size
= 0;
842 /* First, we need to know how many exported symbols there are,
843 and what the range of ordinals is. */
844 if (pe_def_file
->name
)
845 dll_name
= pe_def_file
->name
;
848 dll_name
= abfd
->filename
;
850 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
851 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
855 if (count_with_ordinals
&& max_ordinal
> count_exported
)
857 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
858 min_ordinal
= max_ordinal
- count_exported
+ 1;
863 max_ordinal
= count_exported
;
866 export_table_size
= max_ordinal
- min_ordinal
+ 1;
867 exported_symbols
= (int *) xmalloc (export_table_size
* sizeof (int));
868 for (i
= 0; i
< export_table_size
; i
++)
869 exported_symbols
[i
] = -1;
871 /* Now we need to assign ordinals to those that don't have them. */
872 for (i
= 0; i
< NE
; i
++)
874 if (exported_symbol_sections
[i
])
876 if (pe_def_file
->exports
[i
].ordinal
!= -1)
878 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
879 int pi
= exported_symbols
[ei
];
883 /* xgettext:c-format */
884 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
885 pe_def_file
->exports
[i
].ordinal
,
886 pe_def_file
->exports
[i
].name
,
887 pe_def_file
->exports
[pi
].name
);
889 exported_symbols
[ei
] = i
;
891 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
895 next_ordinal
= min_ordinal
;
896 for (i
= 0; i
< NE
; i
++)
897 if (exported_symbol_sections
[i
])
898 if (pe_def_file
->exports
[i
].ordinal
== -1)
900 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
903 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
904 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
907 /* OK, now we can allocate some memory. */
908 edata_sz
= (40 /* directory */
909 + 4 * export_table_size
/* addresses */
910 + 4 * count_exported_byname
/* name ptrs */
911 + 2 * count_exported_byname
/* ordinals */
912 + name_table_size
+ strlen (dll_name
) + 1);
915 /* Fill the exported symbol offsets. The preliminary work has already
916 been done in process_def_file(). */
919 fill_exported_offsets (abfd
, info
)
920 bfd
*abfd ATTRIBUTE_UNUSED
;
921 struct bfd_link_info
*info
;
924 struct bfd_link_hash_entry
*blhe
;
926 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
928 char *name
= (char *) xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
930 if (pe_details
->underscored
931 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
934 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
937 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
939 blhe
= bfd_link_hash_lookup (info
->hash
,
943 if (blhe
&& (blhe
->type
== bfd_link_hash_defined
))
944 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
951 fill_edata (abfd
, info
)
953 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
956 unsigned char *edirectory
;
957 unsigned long *eaddresses
;
958 unsigned long *enameptrs
;
959 unsigned short *eordinals
;
960 unsigned char *enamestr
;
965 edata_d
= (unsigned char *) xmalloc (edata_sz
);
967 /* Note use of array pointer math here. */
968 edirectory
= edata_d
;
969 eaddresses
= (unsigned long *) (edata_d
+ 40);
970 enameptrs
= eaddresses
+ export_table_size
;
971 eordinals
= (unsigned short *) (enameptrs
+ count_exported_byname
);
972 enamestr
= (char *) (eordinals
+ count_exported_byname
);
974 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
976 memset (edata_d
, 0, edata_sz
);
977 bfd_put_32 (abfd
, now
, edata_d
+ 4);
978 if (pe_def_file
->version_major
!= -1)
980 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
981 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
984 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
985 strcpy (enamestr
, dll_name
);
986 enamestr
+= strlen (enamestr
) + 1;
987 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
988 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
989 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
990 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
991 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
992 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
994 fill_exported_offsets (abfd
, info
);
996 /* Ok, now for the filling in part. */
998 for (i
= 0; i
< export_table_size
; i
++)
1000 int s
= exported_symbols
[i
];
1004 struct sec
*ssec
= exported_symbol_sections
[s
];
1005 unsigned long srva
= (exported_symbol_offsets
[s
]
1006 + ssec
->output_section
->vma
1007 + ssec
->output_offset
);
1008 int ord
= pe_def_file
->exports
[s
].ordinal
;
1010 bfd_put_32 (abfd
, srva
- image_base
,
1011 (void *) (eaddresses
+ ord
- min_ordinal
));
1013 if (!pe_def_file
->exports
[s
].flag_noname
)
1015 char *ename
= pe_def_file
->exports
[s
].name
;
1016 bfd_put_32 (abfd
, ERVA (enamestr
), (void *) enameptrs
);
1018 strcpy (enamestr
, ename
);
1019 enamestr
+= strlen (enamestr
) + 1;
1020 bfd_put_16 (abfd
, ord
- min_ordinal
, (void *) eordinals
);
1022 pe_def_file
->exports
[s
].hint
= hint
++;
1029 static struct sec
*current_sec
;
1032 pe_walk_relocs_of_symbol (info
, name
, cb
)
1033 struct bfd_link_info
*info
;
1035 int (*cb
) (arelent
*, asection
*);
1040 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1045 symsize
= bfd_get_symtab_upper_bound (b
);
1046 symbols
= (asymbol
**) xmalloc (symsize
);
1047 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1049 for (s
= b
->sections
; s
; s
= s
->next
)
1052 int relsize
, nrelocs
, i
;
1053 int flags
= bfd_get_section_flags (b
, s
);
1055 /* Skip discarded linkonce sections. */
1056 if (flags
& SEC_LINK_ONCE
1057 && s
->output_section
== bfd_abs_section_ptr
)
1062 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1063 relocs
= (arelent
**) xmalloc ((size_t) relsize
);
1064 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1066 for (i
= 0; i
< nrelocs
; i
++)
1068 struct symbol_cache_entry
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1070 if (!strcmp (name
, sym
->name
))
1076 /* Warning: the allocated symbols are remembered in BFD and reused
1077 later, so don't free them! */
1078 /* free (symbols); */
1083 /* Gather all the relocations and build the .reloc section. */
1086 generate_reloc (abfd
, info
)
1088 struct bfd_link_info
*info
;
1091 /* For .reloc stuff. */
1092 reloc_data_type
*reloc_data
;
1093 int total_relocs
= 0;
1095 unsigned long sec_page
= (unsigned long) (-1);
1096 unsigned long page_ptr
, page_count
;
1102 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1103 for (s
= b
->sections
; s
; s
= s
->next
)
1104 total_relocs
+= s
->reloc_count
;
1107 (reloc_data_type
*) xmalloc (total_relocs
* sizeof (reloc_data_type
));
1111 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1114 int relsize
, nrelocs
, i
;
1116 for (s
= b
->sections
; s
; s
= s
->next
)
1118 unsigned long sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1122 /* If it's not loaded, we don't need to relocate it this way. */
1123 if (!(s
->output_section
->flags
& SEC_LOAD
))
1126 /* I don't know why there would be a reloc for these, but I've
1127 seen it happen - DJ */
1128 if (s
->output_section
== &bfd_abs_section
)
1131 if (s
->output_section
->vma
== 0)
1133 /* Huh? Shouldn't happen, but punt if it does. */
1134 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1135 s
->output_section
->name
, s
->output_section
->index
,
1136 s
->output_section
->flags
);
1140 symsize
= bfd_get_symtab_upper_bound (b
);
1141 symbols
= (asymbol
**) xmalloc (symsize
);
1142 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1144 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1145 relocs
= (arelent
**) xmalloc ((size_t) relsize
);
1146 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1148 for (i
= 0; i
< nrelocs
; i
++)
1150 if (pe_dll_extra_pe_debug
)
1152 struct symbol_cache_entry
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1153 printf ("rel: %s\n", sym
->name
);
1155 if (!relocs
[i
]->howto
->pc_relative
1156 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1159 struct symbol_cache_entry
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1161 sym_vma
= (relocs
[i
]->addend
1164 + sym
->section
->output_offset
1165 + sym
->section
->output_section
->vma
);
1166 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1168 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1170 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1171 relocs
[i
]->howto
->rightshift
)
1173 case BITS_AND_SHIFT (32, 0):
1174 reloc_data
[total_relocs
].type
= 3;
1177 case BITS_AND_SHIFT (16, 0):
1178 reloc_data
[total_relocs
].type
= 2;
1181 case BITS_AND_SHIFT (16, 16):
1182 reloc_data
[total_relocs
].type
= 4;
1183 /* FIXME: we can't know the symbol's right value
1184 yet, but we probably can safely assume that
1185 CE will relocate us in 64k blocks, so leaving
1187 reloc_data
[total_relocs
].extra
= 0;
1190 case BITS_AND_SHIFT (26, 2):
1191 reloc_data
[total_relocs
].type
= 5;
1195 /* xgettext:c-format */
1196 einfo (_("%XError: %d-bit reloc in dll\n"),
1197 relocs
[i
]->howto
->bitsize
);
1203 /* Warning: the allocated symbols are remembered in BFD and
1204 reused later, so don't free them! */
1211 /* At this point, we have total_relocs relocation addresses in
1212 reloc_addresses, which are all suitable for the .reloc section.
1213 We must now create the new sections. */
1214 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1216 for (i
= 0; i
< total_relocs
; i
++)
1218 unsigned long this_page
= (reloc_data
[i
].vma
>> 12);
1220 if (this_page
!= sec_page
)
1222 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1224 sec_page
= this_page
;
1229 if (reloc_data
[i
].type
== 4)
1233 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1234 reloc_d
= (unsigned char *) xmalloc (reloc_sz
);
1235 sec_page
= (unsigned long) (-1);
1237 page_ptr
= (unsigned long) (-1);
1240 for (i
= 0; i
< total_relocs
; i
++)
1242 unsigned long rva
= reloc_data
[i
].vma
- image_base
;
1243 unsigned long this_page
= (rva
& ~0xfff);
1245 if (this_page
!= sec_page
)
1247 while (reloc_sz
& 3)
1248 reloc_d
[reloc_sz
++] = 0;
1250 if (page_ptr
!= (unsigned long) (-1))
1251 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1253 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1254 page_ptr
= reloc_sz
;
1256 sec_page
= this_page
;
1260 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1261 reloc_d
+ reloc_sz
);
1264 if (reloc_data
[i
].type
== 4)
1266 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1273 while (reloc_sz
& 3)
1274 reloc_d
[reloc_sz
++] = 0;
1276 if (page_ptr
!= (unsigned long) (-1))
1277 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1279 while (reloc_sz
< reloc_s
->_raw_size
)
1280 reloc_d
[reloc_sz
++] = 0;
1283 /* Given the exiting def_file structure, print out a .DEF file that
1284 corresponds to it. */
1287 quoteput (s
, f
, needs_quotes
)
1294 for (cp
= s
; *cp
; cp
++)
1309 if (*s
== '"' || *s
== '\\')
1323 pe_dll_generate_def_file (pe_out_def_filename
)
1324 const char *pe_out_def_filename
;
1327 FILE *out
= fopen (pe_out_def_filename
, "w");
1330 /* xgettext:c-format */
1331 einfo (_("%s: Can't open output def file %s\n"),
1332 program_name
, pe_out_def_filename
);
1336 if (pe_def_file
->name
)
1338 if (pe_def_file
->is_dll
)
1339 fprintf (out
, "LIBRARY ");
1341 fprintf (out
, "NAME ");
1343 quoteput (pe_def_file
->name
, out
, 1);
1345 if (pe_data (output_bfd
)->pe_opthdr
.ImageBase
)
1346 fprintf (out
, " BASE=0x%lx",
1347 (unsigned long) pe_data (output_bfd
)->pe_opthdr
.ImageBase
);
1348 fprintf (out
, "\n");
1351 if (pe_def_file
->description
)
1353 fprintf (out
, "DESCRIPTION ");
1354 quoteput (pe_def_file
->description
, out
, 1);
1355 fprintf (out
, "\n");
1358 if (pe_def_file
->version_minor
!= -1)
1359 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1360 pe_def_file
->version_minor
);
1361 else if (pe_def_file
->version_major
!= -1)
1362 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1364 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1365 fprintf (out
, "\n");
1367 if (pe_def_file
->stack_commit
!= -1)
1368 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1369 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1370 else if (pe_def_file
->stack_reserve
!= -1)
1371 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1373 if (pe_def_file
->heap_commit
!= -1)
1374 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1375 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1376 else if (pe_def_file
->heap_reserve
!= -1)
1377 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1379 if (pe_def_file
->num_section_defs
> 0)
1381 fprintf (out
, "\nSECTIONS\n\n");
1383 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1386 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1388 if (pe_def_file
->section_defs
[i
].class)
1390 fprintf (out
, " CLASS ");
1391 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1394 if (pe_def_file
->section_defs
[i
].flag_read
)
1395 fprintf (out
, " READ");
1397 if (pe_def_file
->section_defs
[i
].flag_write
)
1398 fprintf (out
, " WRITE");
1400 if (pe_def_file
->section_defs
[i
].flag_execute
)
1401 fprintf (out
, " EXECUTE");
1403 if (pe_def_file
->section_defs
[i
].flag_shared
)
1404 fprintf (out
, " SHARED");
1406 fprintf (out
, "\n");
1410 if (pe_def_file
->num_exports
> 0)
1412 fprintf (out
, "EXPORTS\n");
1414 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1416 def_file_export
*e
= pe_def_file
->exports
+ i
;
1418 quoteput (e
->name
, out
, 0);
1420 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1422 fprintf (out
, " = ");
1423 quoteput (e
->internal_name
, out
, 0);
1426 if (e
->ordinal
!= -1)
1427 fprintf (out
, " @%d", e
->ordinal
);
1429 if (e
->flag_private
)
1430 fprintf (out
, " PRIVATE");
1432 if (e
->flag_constant
)
1433 fprintf (out
, " CONSTANT");
1436 fprintf (out
, " NONAME");
1439 fprintf (out
, " DATA");
1441 fprintf (out
, "\n");
1445 if (pe_def_file
->num_imports
> 0)
1447 fprintf (out
, "\nIMPORTS\n\n");
1449 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1451 def_file_import
*im
= pe_def_file
->imports
+ i
;
1454 if (im
->internal_name
1455 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1457 quoteput (im
->internal_name
, out
, 0);
1458 fprintf (out
, " = ");
1461 quoteput (im
->module
->name
, out
, 0);
1465 quoteput (im
->name
, out
, 0);
1467 fprintf (out
, "%d", im
->ordinal
);
1469 fprintf (out
, "\n");
1474 fprintf (out
, _("; no contents available\n"));
1476 if (fclose (out
) == EOF
)
1477 /* xgettext:c-format */
1478 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1481 /* Generate the import library. */
1483 static asymbol
**symtab
;
1486 static const char *dll_filename
;
1487 static char *dll_symname
;
1489 #define UNDSEC (asection *) &bfd_und_section
1492 quick_section (abfd
, name
, flags
, align
)
1501 sec
= bfd_make_section_old_way (abfd
, name
);
1502 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1503 bfd_set_section_alignment (abfd
, sec
, align
);
1504 /* Remember to undo this before trying to link internally! */
1505 sec
->output_section
= sec
;
1507 sym
= bfd_make_empty_symbol (abfd
);
1508 symtab
[symptr
++] = sym
;
1509 sym
->name
= sec
->name
;
1511 sym
->flags
= BSF_LOCAL
;
1518 quick_symbol (abfd
, n1
, n2
, n3
, sec
, flags
, addr
)
1528 char *name
= (char *) xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1533 sym
= bfd_make_empty_symbol (abfd
);
1538 symtab
[symptr
++] = sym
;
1541 static arelent
*reltab
= 0;
1542 static int relcount
= 0, relsize
= 0;
1545 quick_reloc (abfd
, address
, which_howto
, symidx
)
1551 if (relcount
>= (relsize
- 1))
1555 reltab
= (arelent
*) xrealloc (reltab
, relsize
* sizeof (arelent
));
1557 reltab
= (arelent
*) xmalloc (relsize
* sizeof (arelent
));
1559 reltab
[relcount
].address
= address
;
1560 reltab
[relcount
].addend
= 0;
1561 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1562 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1567 save_relocs (asection
*sec
)
1571 sec
->relocation
= reltab
;
1572 sec
->reloc_count
= relcount
;
1573 sec
->orelocation
= (arelent
**) xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1574 for (i
= 0; i
< relcount
; i
++)
1575 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1576 sec
->orelocation
[relcount
] = 0;
1577 sec
->flags
|= SEC_RELOC
;
1579 relcount
= relsize
= 0;
1582 /* .section .idata$2
1583 .global __head_my_dll
1603 asection
*id2
, *id5
, *id4
;
1604 unsigned char *d2
, *d5
, *d4
;
1608 oname
= (char *) xmalloc (20);
1609 sprintf (oname
, "d%06d.o", tmp_seq
);
1612 abfd
= bfd_create (oname
, parent
);
1613 bfd_find_target (pe_details
->object_target
, abfd
);
1614 bfd_make_writable (abfd
);
1616 bfd_set_format (abfd
, bfd_object
);
1617 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1620 symtab
= (asymbol
**) xmalloc (6 * sizeof (asymbol
*));
1621 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1622 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1623 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1624 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1625 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1627 /* OK, pay attention here. I got confused myself looking back at
1628 it. We create a four-byte section to mark the beginning of the
1629 list, and we include an offset of 4 in the section, so that the
1630 pointer to the list points to the *end* of this section, which is
1631 the start of the list of sections from other objects. */
1633 bfd_set_section_size (abfd
, id2
, 20);
1634 d2
= (unsigned char *) xmalloc (20);
1637 d2
[0] = d2
[16] = 4; /* Reloc addend. */
1638 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1639 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1640 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1643 bfd_set_section_size (abfd
, id5
, 4);
1644 d5
= (unsigned char *) xmalloc (4);
1648 bfd_set_section_size (abfd
, id4
, 4);
1649 d4
= (unsigned char *) xmalloc (4);
1653 bfd_set_symtab (abfd
, symtab
, symptr
);
1655 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1656 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1657 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1659 bfd_make_readable (abfd
);
1663 /* .section .idata$4
1668 .global __my_dll_iname
1676 asection
*id4
, *id5
, *id7
;
1677 unsigned char *d4
, *d5
, *d7
;
1682 oname
= (char *) xmalloc (20);
1683 sprintf (oname
, "d%06d.o", tmp_seq
);
1686 abfd
= bfd_create (oname
, parent
);
1687 bfd_find_target (pe_details
->object_target
, abfd
);
1688 bfd_make_writable (abfd
);
1690 bfd_set_format (abfd
, bfd_object
);
1691 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1694 symtab
= (asymbol
**) xmalloc (5 * sizeof (asymbol
*));
1695 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1696 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1697 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1698 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1700 bfd_set_section_size (abfd
, id4
, 4);
1701 d4
= (unsigned char *) xmalloc (4);
1705 bfd_set_section_size (abfd
, id5
, 4);
1706 d5
= (unsigned char *) xmalloc (4);
1710 len
= strlen (dll_filename
) + 1;
1713 bfd_set_section_size (abfd
, id7
, len
);
1714 d7
= (unsigned char *) xmalloc (len
);
1716 strcpy (d7
, dll_filename
);
1718 bfd_set_symtab (abfd
, symtab
, symptr
);
1720 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1721 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1722 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1724 bfd_make_readable (abfd
);
1730 .global ___imp_function
1731 .global __imp__function
1733 jmp *__imp__function:
1747 .asciz "function" xlate? (add underscore, kill at) */
1749 static unsigned char jmp_ix86_bytes
[] =
1751 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1759 .dw __imp_function */
1761 static unsigned char jmp_sh_bytes
[] =
1763 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1767 lui $t0,<high:__imp_function>
1768 lw $t0,<low:__imp_function>
1772 static unsigned char jmp_mips_bytes
[] =
1774 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1775 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1779 make_one (exp
, parent
)
1780 def_file_export
*exp
;
1783 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1784 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1788 unsigned char *jmp_bytes
= NULL
;
1789 int jmp_byte_count
= 0;
1791 switch (pe_details
->pe_arch
)
1794 jmp_bytes
= jmp_ix86_bytes
;
1795 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1798 jmp_bytes
= jmp_sh_bytes
;
1799 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1802 jmp_bytes
= jmp_mips_bytes
;
1803 jmp_byte_count
= sizeof (jmp_mips_bytes
);
1809 oname
= (char *) xmalloc (20);
1810 sprintf (oname
, "d%06d.o", tmp_seq
);
1813 abfd
= bfd_create (oname
, parent
);
1814 bfd_find_target (pe_details
->object_target
, abfd
);
1815 bfd_make_writable (abfd
);
1817 bfd_set_format (abfd
, bfd_object
);
1818 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1821 symtab
= (asymbol
**) xmalloc (11 * sizeof (asymbol
*));
1822 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1823 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1824 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1825 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1826 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1828 if (*exp
->internal_name
== '@')
1830 if (! exp
->flag_data
)
1831 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1832 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
, BSF_GLOBAL
, 0);
1833 quick_symbol (abfd
, U ("_imp_"), exp
->internal_name
, "", id5
, BSF_GLOBAL
, 0);
1834 /* Fastcall applies only to functions,
1835 so no need for auto-import symbol. */
1839 if (! exp
->flag_data
)
1840 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1841 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
, BSF_GLOBAL
, 0);
1842 quick_symbol (abfd
, U ("_imp__"), exp
->internal_name
, "", id5
, BSF_GLOBAL
, 0);
1843 /* Symbol to reference ord/name of imported
1844 data symbol, used to implement auto-import. */
1846 quick_symbol (abfd
, U("_nm__"), exp
->internal_name
, "", id6
, BSF_GLOBAL
,0);
1848 if (pe_dll_compat_implib
)
1849 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "",
1850 id5
, BSF_GLOBAL
, 0);
1852 if (! exp
->flag_data
)
1854 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
1855 td
= (unsigned char *) xmalloc (jmp_byte_count
);
1857 memcpy (td
, jmp_bytes
, jmp_byte_count
);
1859 switch (pe_details
->pe_arch
)
1862 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
1865 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
1868 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
1869 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
1870 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
1878 bfd_set_section_size (abfd
, id7
, 4);
1879 d7
= (unsigned char *) xmalloc (4);
1882 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 6);
1885 bfd_set_section_size (abfd
, id5
, 4);
1886 d5
= (unsigned char *) xmalloc (4);
1890 if (exp
->flag_noname
)
1892 d5
[0] = exp
->ordinal
;
1893 d5
[1] = exp
->ordinal
>> 8;
1898 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1902 bfd_set_section_size (abfd
, id4
, 4);
1903 d4
= (unsigned char *) xmalloc (4);
1907 if (exp
->flag_noname
)
1909 d4
[0] = exp
->ordinal
;
1910 d4
[1] = exp
->ordinal
>> 8;
1915 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1919 if (exp
->flag_noname
)
1922 bfd_set_section_size (abfd
, id6
, 0);
1926 len
= strlen (exp
->name
) + 3;
1929 bfd_set_section_size (abfd
, id6
, len
);
1930 d6
= (unsigned char *) xmalloc (len
);
1932 memset (d6
, 0, len
);
1933 d6
[0] = exp
->hint
& 0xff;
1934 d6
[1] = exp
->hint
>> 8;
1935 strcpy (d6
+ 2, exp
->name
);
1938 bfd_set_symtab (abfd
, symtab
, symptr
);
1940 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
1941 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
1942 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1943 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1944 if (!exp
->flag_noname
)
1945 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
1947 bfd_make_readable (abfd
);
1952 make_singleton_name_thunk (import
, parent
)
1956 /* Name thunks go to idata$4. */
1962 oname
= (char *) xmalloc (20);
1963 sprintf (oname
, "nmth%06d.o", tmp_seq
);
1966 abfd
= bfd_create (oname
, parent
);
1967 bfd_find_target (pe_details
->object_target
, abfd
);
1968 bfd_make_writable (abfd
);
1970 bfd_set_format (abfd
, bfd_object
);
1971 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1974 symtab
= (asymbol
**) xmalloc (3 * sizeof (asymbol
*));
1975 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1976 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
1977 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
1979 bfd_set_section_size (abfd
, id4
, 8);
1980 d4
= (unsigned char *) xmalloc (4);
1983 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1986 bfd_set_symtab (abfd
, symtab
, symptr
);
1988 bfd_set_section_contents (abfd
, id4
, d4
, 0, 8);
1990 bfd_make_readable (abfd
);
1995 make_import_fixup_mark (rel
)
1998 /* We convert reloc to symbol, for later reference. */
2000 static char *fixup_name
= NULL
;
2001 static size_t buffer_len
= 0;
2003 struct symbol_cache_entry
*sym
= *rel
->sym_ptr_ptr
;
2005 bfd
*abfd
= bfd_asymbol_bfd (sym
);
2006 struct bfd_link_hash_entry
*bh
;
2010 fixup_name
= (char *) xmalloc (384);
2014 if (strlen (sym
->name
) + 25 > buffer_len
)
2015 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2016 bigger than 20 digits long, we've got worse problems than
2017 overflowing this buffer... */
2020 /* New buffer size is length of symbol, plus 25, but then
2021 rounded up to the nearest multiple of 128. */
2022 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
2023 fixup_name
= (char *) xmalloc (buffer_len
);
2026 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
2029 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
2030 current_sec
, /* sym->section, */
2031 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
2035 struct coff_link_hash_entry
*myh
;
2037 myh
= (struct coff_link_hash_entry
*) bh
;
2038 printf ("type:%d\n", myh
->type
);
2039 printf ("%s\n", myh
->root
.u
.def
.section
->name
);
2045 /* .section .idata$3
2046 .rva __nm_thnk_SYM (singleton thunk with name of func)
2049 .rva __my_dll_iname (name of dll)
2050 .rva __fuNN_SYM (pointer to reference (address) in text) */
2053 make_import_fixup_entry (name
, fixup_name
, dll_symname
, parent
)
2055 const char *fixup_name
;
2056 const char *dll_symname
;
2064 oname
= (char *) xmalloc (20);
2065 sprintf (oname
, "fu%06d.o", tmp_seq
);
2068 abfd
= bfd_create (oname
, parent
);
2069 bfd_find_target (pe_details
->object_target
, abfd
);
2070 bfd_make_writable (abfd
);
2072 bfd_set_format (abfd
, bfd_object
);
2073 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2076 symtab
= (asymbol
**) xmalloc (6 * sizeof (asymbol
*));
2077 id3
= quick_section (abfd
, ".idata$3", SEC_HAS_CONTENTS
, 2);
2080 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2082 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2083 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2084 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2086 bfd_set_section_size (abfd
, id3
, 20);
2087 d3
= (unsigned char *) xmalloc (20);
2091 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2092 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2093 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2096 bfd_set_symtab (abfd
, symtab
, symptr
);
2098 bfd_set_section_contents (abfd
, id3
, d3
, 0, 20);
2100 bfd_make_readable (abfd
);
2104 /* .section .rdata_runtime_pseudo_reloc
2106 .rva __fuNN_SYM (pointer to reference (address) in text) */
2109 make_runtime_pseudo_reloc (name
, fixup_name
, addend
, parent
)
2110 const char *name ATTRIBUTE_UNUSED
;
2111 const char *fixup_name
;
2116 unsigned char *rt_rel_d
;
2120 oname
= (char *) xmalloc (20);
2121 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2124 abfd
= bfd_create (oname
, parent
);
2125 bfd_find_target (pe_details
->object_target
, abfd
);
2126 bfd_make_writable (abfd
);
2128 bfd_set_format (abfd
, bfd_object
);
2129 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2132 symtab
= (asymbol
**) xmalloc (2 * sizeof (asymbol
*));
2133 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS
, 2);
2135 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2137 bfd_set_section_size (abfd
, rt_rel
, 8);
2138 rt_rel_d
= (unsigned char *) xmalloc (8);
2139 rt_rel
->contents
= rt_rel_d
;
2140 memset (rt_rel_d
, 0, 8);
2141 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2143 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2144 save_relocs (rt_rel
);
2146 bfd_set_symtab (abfd
, symtab
, symptr
);
2148 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2150 bfd_make_readable (abfd
);
2155 .rva __pei386_runtime_relocator */
2158 pe_create_runtime_relocator_reference (parent
)
2161 asection
*extern_rt_rel
;
2162 unsigned char *extern_rt_rel_d
;
2166 oname
= (char *) xmalloc (20);
2167 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2170 abfd
= bfd_create (oname
, parent
);
2171 bfd_find_target (pe_details
->object_target
, abfd
);
2172 bfd_make_writable (abfd
);
2174 bfd_set_format (abfd
, bfd_object
);
2175 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2178 symtab
= (asymbol
**) xmalloc (2 * sizeof (asymbol
*));
2179 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2181 quick_symbol (abfd
, "", "__pei386_runtime_relocator", "", UNDSEC
, BSF_NO_FLAGS
, 0);
2183 bfd_set_section_size (abfd
, extern_rt_rel
, 4);
2184 extern_rt_rel_d
= (unsigned char *) xmalloc (4);
2185 extern_rt_rel
->contents
= extern_rt_rel_d
;
2187 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2188 save_relocs (extern_rt_rel
);
2190 bfd_set_symtab (abfd
, symtab
, symptr
);
2192 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, 4);
2194 bfd_make_readable (abfd
);
2199 pe_create_import_fixup (rel
, s
, addend
)
2205 struct symbol_cache_entry
*sym
= *rel
->sym_ptr_ptr
;
2206 struct bfd_link_hash_entry
*name_thunk_sym
;
2207 const char *name
= sym
->name
;
2208 char *fixup_name
= make_import_fixup_mark (rel
);
2211 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2213 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2215 if (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
)
2217 bfd
*b
= make_singleton_name_thunk (name
, output_bfd
);
2218 add_bfd_to_link (b
, b
->filename
, &link_info
);
2220 /* If we ever use autoimport, we have to cast text section writable. */
2221 config
.text_read_only
= FALSE
;
2224 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2226 extern char * pe_data_import_dll
;
2227 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2229 b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
, output_bfd
);
2230 add_bfd_to_link (b
, b
->filename
, &link_info
);
2235 if (link_info
.pei386_runtime_pseudo_reloc
)
2237 if (pe_dll_extra_pe_debug
)
2238 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2239 fixup_name
, addend
);
2240 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, output_bfd
);
2241 add_bfd_to_link (b
, b
->filename
, &link_info
);
2243 if (runtime_pseudo_relocs_created
== 0)
2245 b
= pe_create_runtime_relocator_reference (output_bfd
);
2246 add_bfd_to_link (b
, b
->filename
, &link_info
);
2248 runtime_pseudo_relocs_created
++;
2252 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2253 s
->owner
, s
, rel
->address
, sym
->name
);
2261 pe_dll_generate_implib (def
, impfilename
)
2263 const char *impfilename
;
2271 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2272 dll_symname
= xstrdup (dll_filename
);
2273 for (i
= 0; dll_symname
[i
]; i
++)
2274 if (!ISALNUM (dll_symname
[i
]))
2275 dll_symname
[i
] = '_';
2277 unlink (impfilename
);
2279 outarch
= bfd_openw (impfilename
, 0);
2283 /* xgettext:c-format */
2284 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2288 /* xgettext:c-format */
2289 einfo (_("Creating library file: %s\n"), impfilename
);
2291 bfd_set_format (outarch
, bfd_archive
);
2292 outarch
->has_armap
= 1;
2294 /* Work out a reasonable size of things to put onto one line. */
2295 ar_head
= make_head (outarch
);
2297 for (i
= 0; i
< def
->num_exports
; i
++)
2299 /* The import library doesn't know about the internal name. */
2300 char *internal
= def
->exports
[i
].internal_name
;
2303 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2304 n
= make_one (def
->exports
+ i
, outarch
);
2307 def
->exports
[i
].internal_name
= internal
;
2310 ar_tail
= make_tail (outarch
);
2312 if (ar_head
== NULL
|| ar_tail
== NULL
)
2315 /* Now stick them all into the archive. */
2316 ar_head
->next
= head
;
2317 ar_tail
->next
= ar_head
;
2320 if (! bfd_set_archive_head (outarch
, head
))
2321 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
2323 if (! bfd_close (outarch
))
2324 einfo ("%Xbfd_close %s: %s\n", impfilename
, bfd_errmsg (bfd_get_error ()));
2326 while (head
!= NULL
)
2328 bfd
*n
= head
->next
;
2335 add_bfd_to_link (abfd
, name
, link_info
)
2338 struct bfd_link_info
*link_info
;
2340 lang_input_statement_type
*fake_file
;
2342 fake_file
= lang_add_input_file (name
,
2343 lang_input_file_is_fake_enum
,
2345 fake_file
->the_bfd
= abfd
;
2346 ldlang_add_file (fake_file
);
2348 if (!bfd_link_add_symbols (abfd
, link_info
))
2349 einfo ("%Xaddsym %s: %s\n", name
, bfd_errmsg (bfd_get_error ()));
2353 pe_process_import_defs (output_bfd
, link_info
)
2355 struct bfd_link_info
*link_info
;
2357 def_file_module
*module
;
2359 pe_dll_id_target (bfd_get_target (output_bfd
));
2364 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2368 dll_filename
= module
->name
;
2369 dll_symname
= xstrdup (module
->name
);
2370 for (i
= 0; dll_symname
[i
]; i
++)
2371 if (!ISALNUM (dll_symname
[i
]))
2372 dll_symname
[i
] = '_';
2376 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2377 if (pe_def_file
->imports
[i
].module
== module
)
2379 def_file_export exp
;
2380 struct bfd_link_hash_entry
*blhe
;
2381 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2382 /* See if we need this import. */
2383 char *name
= (char *) xmalloc (strlen (pe_def_file
->imports
[i
].internal_name
) + 2 + 6);
2386 sprintf (name
, "%s%s", "", pe_def_file
->imports
[i
].internal_name
);
2388 sprintf (name
, "%s%s",U (""), pe_def_file
->imports
[i
].internal_name
);
2390 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2391 FALSE
, FALSE
, FALSE
);
2393 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2396 sprintf (name
, "%s%s", U ("_imp_"),
2397 pe_def_file
->imports
[i
].internal_name
);
2399 sprintf (name
, "%s%s", U ("_imp__"),
2400 pe_def_file
->imports
[i
].internal_name
);
2402 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2403 FALSE
, FALSE
, FALSE
);
2407 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2413 bfd
*ar_head
= make_head (output_bfd
);
2414 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2417 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2418 exp
.name
= pe_def_file
->imports
[i
].name
;
2419 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2420 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2421 exp
.flag_private
= 0;
2422 exp
.flag_constant
= 0;
2423 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2424 exp
.flag_noname
= exp
.name
? 0 : 1;
2425 one
= make_one (&exp
, output_bfd
);
2426 add_bfd_to_link (one
, one
->filename
, link_info
);
2431 bfd
*ar_tail
= make_tail (output_bfd
);
2432 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2439 /* We were handed a *.DLL file. Parse it and turn it into a set of
2440 IMPORTS directives in the def file. Return TRUE if the file was
2441 handled, FALSE if not. */
2444 pe_get16 (abfd
, where
)
2450 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2451 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2452 return b
[0] + (b
[1] << 8);
2456 pe_get32 (abfd
, where
)
2462 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2463 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2464 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2467 #if 0 /* This is not currently used. */
2473 unsigned char *b
= ptr
;
2475 return b
[0] + (b
[1] << 8);
2484 unsigned char *b
= ptr
;
2486 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2490 pe_implied_import_dll (filename
)
2491 const char *filename
;
2494 unsigned long pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2495 unsigned long export_rva
, export_size
, nsections
, secptr
, expptr
;
2496 unsigned long exp_funcbase
;
2497 unsigned char *expdata
, *erva
;
2498 unsigned long name_rvas
, ordinals
, nexp
, ordbase
;
2499 const char *dll_name
;
2500 /* Initialization with start > end guarantees that is_data
2501 will not be set by mistake, and avoids compiler warning. */
2502 unsigned long data_start
= 1;
2503 unsigned long data_end
= 0;
2504 unsigned long bss_start
= 1;
2505 unsigned long bss_end
= 0;
2507 /* No, I can't use bfd here. kernel32.dll puts its export table in
2508 the middle of the .rdata section. */
2509 dll
= bfd_openr (filename
, pe_details
->target_name
);
2512 einfo ("%Xopen %s: %s\n", filename
, bfd_errmsg (bfd_get_error ()));
2516 /* PEI dlls seem to be bfd_objects. */
2517 if (!bfd_check_format (dll
, bfd_object
))
2519 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2523 /* Get pe_header, optional header and numbers of export entries. */
2524 pe_header_offset
= pe_get32 (dll
, 0x3c);
2525 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2526 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2528 if (num_entries
< 1) /* No exports. */
2531 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2532 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2533 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2534 secptr
= (pe_header_offset
+ 4 + 20 +
2535 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2538 /* Get the rva and size of the export section. */
2539 for (i
= 0; i
< nsections
; i
++)
2542 unsigned long secptr1
= secptr
+ 40 * i
;
2543 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
2544 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 16);
2545 unsigned long fptr
= pe_get32 (dll
, secptr1
+ 20);
2547 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2548 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2550 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2552 expptr
= fptr
+ (export_rva
- vaddr
);
2553 if (export_rva
+ export_size
> vaddr
+ vsize
)
2554 export_size
= vsize
- (export_rva
- vaddr
);
2559 /* Scan sections and store the base and size of the
2560 data and bss segments in data/base_start/end. */
2561 for (i
= 0; i
< nsections
; i
++)
2563 unsigned long secptr1
= secptr
+ 40 * i
;
2564 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 8);
2565 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
2566 unsigned long flags
= pe_get32 (dll
, secptr1
+ 36);
2570 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
2571 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
2573 if (strcmp(sec_name
,".data") == 0)
2576 data_end
= vaddr
+ vsize
;
2578 if (pe_dll_extra_pe_debug
)
2579 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2580 __FUNCTION__
, sec_name
, vaddr
, vaddr
+ vsize
, flags
);
2582 else if (strcmp (sec_name
,".bss") == 0)
2585 bss_end
= vaddr
+ vsize
;
2587 if (pe_dll_extra_pe_debug
)
2588 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2589 __FUNCTION__
, sec_name
, vaddr
, vaddr
+ vsize
, flags
);
2593 expdata
= (unsigned char *) xmalloc (export_size
);
2594 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2595 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2596 erva
= expdata
- export_rva
;
2598 if (pe_def_file
== 0)
2599 pe_def_file
= def_file_empty ();
2601 nexp
= pe_as32 (expdata
+ 24);
2602 name_rvas
= pe_as32 (expdata
+ 32);
2603 ordinals
= pe_as32 (expdata
+ 36);
2604 ordbase
= pe_as32 (expdata
+ 16);
2605 exp_funcbase
= pe_as32 (expdata
+ 28);
2607 /* Use internal dll name instead of filename
2608 to enable symbolic dll linking. */
2609 dll_name
= pe_as32 (expdata
+ 12) + erva
;
2611 /* Iterate through the list of symbols. */
2612 for (i
= 0; i
< nexp
; i
++)
2614 /* Pointer to the names vector. */
2615 unsigned long name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
2616 def_file_import
*imp
;
2617 /* Pointer to the function address vector. */
2618 unsigned long func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
2621 /* Skip unwanted symbols, which are
2622 exported in buggy auto-import releases. */
2623 if (strncmp (erva
+ name_rva
, "_nm_", 4) != 0)
2625 /* is_data is true if the address is in the data or bss segment. */
2627 (func_rva
>= data_start
&& func_rva
< data_end
)
2628 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
2630 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
2632 /* Mark symbol type. */
2633 imp
->data
= is_data
;
2635 if (pe_dll_extra_pe_debug
)
2636 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2637 __FUNCTION__
, dll_name
, erva
+ name_rva
,
2638 func_rva
, is_data
? "(data)" : "");
2645 /* These are the main functions, called from the emulation. The first
2646 is called after the bfds are read, so we can guess at how much space
2647 we need. The second is called after everything is placed, so we
2648 can put the right values in place. */
2651 pe_dll_build_sections (abfd
, info
)
2653 struct bfd_link_info
*info
;
2655 pe_dll_id_target (bfd_get_target (abfd
));
2656 process_def_file (abfd
, info
);
2658 generate_edata (abfd
, info
);
2659 build_filler_bfd (1);
2663 pe_exe_build_sections (abfd
, info
)
2665 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2667 pe_dll_id_target (bfd_get_target (abfd
));
2668 build_filler_bfd (0);
2672 pe_dll_fill_sections (abfd
, info
)
2674 struct bfd_link_info
*info
;
2676 pe_dll_id_target (bfd_get_target (abfd
));
2677 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2679 generate_reloc (abfd
, info
);
2682 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2684 /* Resize the sections. */
2685 lang_size_sections (stat_ptr
->head
, abs_output_section
,
2686 &stat_ptr
->head
, 0, (bfd_vma
) 0, NULL
);
2688 /* Redo special stuff. */
2689 ldemul_after_allocation ();
2691 /* Do the assignments again. */
2692 lang_do_assignments (stat_ptr
->head
,
2694 (fill_type
*) 0, (bfd_vma
) 0);
2697 fill_edata (abfd
, info
);
2699 pe_data (abfd
)->dll
= 1;
2701 edata_s
->contents
= edata_d
;
2702 reloc_s
->contents
= reloc_d
;
2706 pe_exe_fill_sections (abfd
, info
)
2708 struct bfd_link_info
*info
;
2710 pe_dll_id_target (bfd_get_target (abfd
));
2711 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2713 generate_reloc (abfd
, info
);
2716 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2718 /* Resize the sections. */
2719 lang_size_sections (stat_ptr
->head
, abs_output_section
,
2720 &stat_ptr
->head
, 0, (bfd_vma
) 0, NULL
);
2722 /* Redo special stuff. */
2723 ldemul_after_allocation ();
2725 /* Do the assignments again. */
2726 lang_do_assignments (stat_ptr
->head
,
2728 (fill_type
*) 0, (bfd_vma
) 0);
2730 reloc_s
->contents
= reloc_d
;