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. */
123 static void add_bfd_to_link (bfd
*, const char *, struct bfd_link_info
*);
125 /* For emultempl/pe.em. */
127 def_file
* pe_def_file
= 0;
128 int pe_dll_export_everything
= 0;
129 int pe_dll_do_default_excludes
= 1;
130 int pe_dll_kill_ats
= 0;
131 int pe_dll_stdcall_aliases
= 0;
132 int pe_dll_warn_dup_exports
= 0;
133 int pe_dll_compat_implib
= 0;
134 int pe_dll_extra_pe_debug
= 0;
136 /* Static variables and types. */
138 static bfd_vma image_base
;
139 static bfd
*filler_bfd
;
140 static struct bfd_section
*edata_s
, *reloc_s
;
141 static unsigned char *edata_d
, *reloc_d
;
142 static size_t edata_sz
, reloc_sz
;
143 static int runtime_pseudo_relocs_created
= 0;
149 unsigned int imagebase_reloc
;
161 autofilter_entry_type
;
163 #define PE_ARCH_i386 1
165 #define PE_ARCH_mips 3
166 #define PE_ARCH_arm 4
167 #define PE_ARCH_arm_epoc 5
169 static pe_details_type pe_detail_list
[] =
182 16 /* R_SH_IMAGEBASE */,
204 "epoc-pei-arm-little",
205 "epoc-pe-arm-little",
211 { NULL
, NULL
, 0, 0, 0, 0 }
214 static pe_details_type
*pe_details
;
216 static autofilter_entry_type autofilter_symbollist
[] =
218 { "DllMain@12", 10 },
219 { "DllEntryPoint@0", 15 },
220 { "DllMainCRTStartup@12", 20 },
221 { "_cygwin_dll_entry@12", 20 },
222 { "_cygwin_crt0_common@8", 21 },
223 { "_cygwin_noncygwin_dll_entry@12", 30 },
224 { "impure_ptr", 10 },
225 { "_pei386_runtime_relocator", 25 },
226 { "do_pseudo_reloc", 15 },
227 { "cygwin_crt0", 11 },
231 /* Do not specify library suffix explicitly, to allow for dllized versions. */
232 static autofilter_entry_type autofilter_liblist
[] =
237 { "libmingw32", 10 },
238 { "libmingwex", 10 },
246 static autofilter_entry_type autofilter_objlist
[] =
256 { "crtbegin.o", 10 },
261 static autofilter_entry_type autofilter_symbolprefixlist
[] =
263 /* { "__imp_", 6 }, */
264 /* Do __imp_ explicitly to save time. */
266 /* Don't re-export auto-imported symbols. */
268 { "__builtin_", 10 },
269 /* Don't export symbols specifying internal DLL layout. */
272 { "_impure_ptr", 11 },
273 { "cygwin_attach_dll", 17 },
274 { "cygwin_premain0", 15 },
275 { "cygwin_premain1", 15 },
276 { "cygwin_premain2", 15 },
277 { "cygwin_premain3", 15 },
282 static autofilter_entry_type autofilter_symbolsuffixlist
[] =
288 #define U(str) (pe_details->underscored ? "_" str : str)
291 pe_dll_id_target (const char *target
)
295 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
296 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
297 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
299 pe_details
= pe_detail_list
+ i
;
302 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
306 /* Helper functions for qsort. Relocs must be sorted so that we can write
307 them out by pages. */
318 reloc_sort (const void *va
, const void *vb
)
320 bfd_vma a
= ((const reloc_data_type
*) va
)->vma
;
321 bfd_vma b
= ((const reloc_data_type
*) vb
)->vma
;
323 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
327 pe_export_sort (const void *va
, const void *vb
)
329 const def_file_export
*a
= va
;
330 const def_file_export
*b
= vb
;
332 return strcmp (a
->name
, b
->name
);
335 /* Read and process the .DEF file. */
337 /* These correspond to the entries in pe_def_file->exports[]. I use
338 exported_symbol_sections[i] to tag whether or not the symbol was
339 defined, since we can't export symbols we don't have. */
341 static bfd_vma
*exported_symbol_offsets
;
342 static struct bfd_section
**exported_symbol_sections
;
343 static int export_table_size
;
344 static int count_exported
;
345 static int count_exported_byname
;
346 static int count_with_ordinals
;
347 static const char *dll_name
;
348 static int min_ordinal
, max_ordinal
;
349 static int *exported_symbols
;
351 typedef struct exclude_list_struct
354 struct exclude_list_struct
*next
;
359 static struct exclude_list_struct
*excludes
= 0;
362 pe_dll_add_excludes (const char *new_excludes
, const int type
)
365 char *exclude_string
;
367 local_copy
= xstrdup (new_excludes
);
369 exclude_string
= strtok (local_copy
, ",:");
370 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
372 struct exclude_list_struct
*new_exclude
;
374 new_exclude
= xmalloc (sizeof (struct exclude_list_struct
));
375 new_exclude
->string
= xmalloc (strlen (exclude_string
) + 1);
376 strcpy (new_exclude
->string
, exclude_string
);
377 new_exclude
->type
= type
;
378 new_exclude
->next
= excludes
;
379 excludes
= new_exclude
;
386 /* abfd is a bfd containing n (or NULL)
387 It can be used for contextual checks. */
390 auto_export (bfd
*abfd
, def_file
*d
, const char *n
)
393 struct exclude_list_struct
*ex
;
394 autofilter_entry_type
*afptr
;
395 const char * libname
= 0;
396 if (abfd
&& abfd
->my_archive
)
397 libname
= lbasename (abfd
->my_archive
->filename
);
399 /* We should not re-export imported stuff. */
400 if (strncmp (n
, "_imp__", 6) == 0)
403 for (i
= 0; i
< d
->num_exports
; i
++)
404 if (strcmp (d
->exports
[i
].name
, n
) == 0)
407 if (pe_dll_do_default_excludes
)
412 if (pe_dll_extra_pe_debug
)
413 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
414 n
, abfd
, abfd
->my_archive
);
416 /* First of all, make context checks:
417 Don't export anything from standard libs. */
420 afptr
= autofilter_liblist
;
424 if (strncmp (libname
, afptr
->name
, afptr
->len
) == 0 )
430 /* Next, exclude symbols from certain startup objects. */
432 if (abfd
&& (p
= lbasename (abfd
->filename
)))
434 afptr
= autofilter_objlist
;
437 if (strcmp (p
, afptr
->name
) == 0)
443 /* Don't try to blindly exclude all symbols
444 that begin with '__'; this was tried and
445 it is too restrictive. */
447 /* Then, exclude specific symbols. */
448 afptr
= autofilter_symbollist
;
451 if (strcmp (n
, afptr
->name
) == 0)
457 /* Next, exclude symbols starting with ... */
458 afptr
= autofilter_symbolprefixlist
;
461 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
467 /* Finally, exclude symbols ending with ... */
469 afptr
= autofilter_symbolsuffixlist
;
472 if ((len
>= afptr
->len
)
473 /* Add 1 to insure match with trailing '\0'. */
474 && strncmp (n
+ len
- afptr
->len
, afptr
->name
,
475 afptr
->len
+ 1) == 0)
482 for (ex
= excludes
; ex
; ex
= ex
->next
)
484 if (ex
->type
== 1) /* exclude-libs */
487 && ((strcmp (libname
, ex
->string
) == 0)
488 || (strcasecmp ("ALL", ex
->string
) == 0)))
491 else if (strcmp (n
, ex
->string
) == 0)
499 process_def_file (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
502 struct bfd_link_hash_entry
*blhe
;
504 struct bfd_section
*s
;
505 def_file_export
*e
= 0;
508 pe_def_file
= def_file_empty ();
510 /* First, run around to all the objects looking for the .drectve
511 sections, and push those into the def file too. */
512 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
514 s
= bfd_get_section_by_name (b
, ".drectve");
517 int size
= bfd_get_section_size_before_reloc (s
);
518 char *buf
= xmalloc (size
);
520 bfd_get_section_contents (b
, s
, buf
, 0, size
);
521 def_file_add_directive (pe_def_file
, buf
, size
);
526 /* If we are not building a DLL, when there are no exports
527 we do not build an export table at all. */
528 if (!pe_dll_export_everything
&& pe_def_file
->num_exports
== 0
532 /* Now, maybe export everything else the default way. */
533 if (pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
535 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
540 symsize
= bfd_get_symtab_upper_bound (b
);
541 symbols
= xmalloc (symsize
);
542 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
544 for (j
= 0; j
< nsyms
; j
++)
546 /* We should export symbols which are either global or not
547 anything at all. (.bss data is the latter)
548 We should not export undefined symbols. */
549 if (symbols
[j
]->section
!= &bfd_und_section
550 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
551 || (symbols
[j
]->flags
== BFD_FORT_COMM_DEFAULT_VALUE
)))
553 const char *sn
= symbols
[j
]->name
;
555 /* We should not re-export imported stuff. */
557 char *name
= xmalloc (strlen (sn
) + 2 + 6);
558 sprintf (name
, "%s%s", U("_imp_"), sn
);
560 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
561 FALSE
, FALSE
, FALSE
);
564 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
571 if (auto_export (b
, pe_def_file
, sn
))
574 p
=def_file_add_export (pe_def_file
, sn
, 0, -1);
575 /* Fill data flag properly, from dlltool.c. */
576 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
584 #define NE pe_def_file->num_exports
586 /* Canonicalize the export list. */
589 for (i
= 0; i
< NE
; i
++)
591 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
593 /* This will preserve internal_name, which may have been
594 pointing to the same memory as name, or might not
596 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
597 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
599 *(strchr (tmp
, '@')) = 0;
600 pe_def_file
->exports
[i
].name
= tmp
;
605 if (pe_dll_stdcall_aliases
)
607 for (i
= 0; i
< NE
; i
++)
609 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
611 int lead_at
= (*pe_def_file
->exports
[i
].name
== '@');
612 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
+ lead_at
);
614 *(strchr (tmp
, '@')) = 0;
615 if (auto_export (NULL
, pe_def_file
, tmp
))
616 def_file_add_export (pe_def_file
, tmp
,
617 pe_def_file
->exports
[i
].internal_name
,
625 /* Convenience, but watch out for it changing. */
626 e
= pe_def_file
->exports
;
628 exported_symbol_offsets
= xmalloc (NE
* sizeof (bfd_vma
));
629 exported_symbol_sections
= xmalloc (NE
* sizeof (struct bfd_section
*));
631 memset (exported_symbol_sections
, 0, NE
* sizeof (struct bfd_section
*));
635 count_exported_byname
= 0;
636 count_with_ordinals
= 0;
638 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]),
640 for (i
= 0, j
= 0; i
< NE
; i
++)
642 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
644 /* This is a duplicate. */
645 if (e
[j
- 1].ordinal
!= -1
646 && e
[i
].ordinal
!= -1
647 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
649 if (pe_dll_warn_dup_exports
)
650 /* xgettext:c-format */
651 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
652 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
656 if (pe_dll_warn_dup_exports
)
657 /* xgettext:c-format */
658 einfo (_("Warning, duplicate EXPORT: %s\n"),
662 if (e
[i
].ordinal
!= -1)
663 e
[j
- 1].ordinal
= e
[i
].ordinal
;
664 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
665 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
666 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
667 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
676 pe_def_file
->num_exports
= j
; /* == NE */
678 for (i
= 0; i
< NE
; i
++)
682 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
683 if (pe_details
->underscored
684 && (*pe_def_file
->exports
[i
].internal_name
!= '@'))
687 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
690 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
692 blhe
= bfd_link_hash_lookup (info
->hash
,
697 && (blhe
->type
== bfd_link_hash_defined
698 || (blhe
->type
== bfd_link_hash_common
)))
701 if (!pe_def_file
->exports
[i
].flag_noname
)
702 count_exported_byname
++;
704 /* Only fill in the sections. The actual offsets are computed
705 in fill_exported_offsets() after common symbols are laid
707 if (blhe
->type
== bfd_link_hash_defined
)
708 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
710 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
712 if (pe_def_file
->exports
[i
].ordinal
!= -1)
714 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
715 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
716 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
717 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
718 count_with_ordinals
++;
721 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
723 /* xgettext:c-format */
724 einfo (_("%XCannot export %s: symbol not defined\n"),
725 pe_def_file
->exports
[i
].internal_name
);
729 /* xgettext:c-format */
730 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
731 pe_def_file
->exports
[i
].internal_name
,
732 blhe
->type
, bfd_link_hash_defined
);
736 /* xgettext:c-format */
737 einfo (_("%XCannot export %s: symbol not found\n"),
738 pe_def_file
->exports
[i
].internal_name
);
744 /* Build the bfd that will contain .edata and .reloc sections. */
747 build_filler_bfd (int include_edata
)
749 lang_input_statement_type
*filler_file
;
750 filler_file
= lang_add_input_file ("dll stuff",
751 lang_input_file_is_fake_enum
,
753 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff", output_bfd
);
754 if (filler_bfd
== NULL
755 || !bfd_set_arch_mach (filler_bfd
,
756 bfd_get_arch (output_bfd
),
757 bfd_get_mach (output_bfd
)))
759 einfo ("%X%P: can not create BFD %E\n");
765 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
767 || !bfd_set_section_flags (filler_bfd
, edata_s
,
774 einfo ("%X%P: can not create .edata section: %E\n");
777 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
780 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
782 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
789 einfo ("%X%P: can not create .reloc section: %E\n");
793 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
795 ldlang_add_file (filler_file
);
798 /* Gather all the exported symbols and build the .edata section. */
801 generate_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
804 int name_table_size
= 0;
807 /* First, we need to know how many exported symbols there are,
808 and what the range of ordinals is. */
809 if (pe_def_file
->name
)
810 dll_name
= pe_def_file
->name
;
813 dll_name
= abfd
->filename
;
815 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
816 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
820 if (count_with_ordinals
&& max_ordinal
> count_exported
)
822 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
823 min_ordinal
= max_ordinal
- count_exported
+ 1;
828 max_ordinal
= count_exported
;
831 export_table_size
= max_ordinal
- min_ordinal
+ 1;
832 exported_symbols
= xmalloc (export_table_size
* sizeof (int));
833 for (i
= 0; i
< export_table_size
; i
++)
834 exported_symbols
[i
] = -1;
836 /* Now we need to assign ordinals to those that don't have them. */
837 for (i
= 0; i
< NE
; i
++)
839 if (exported_symbol_sections
[i
])
841 if (pe_def_file
->exports
[i
].ordinal
!= -1)
843 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
844 int pi
= exported_symbols
[ei
];
848 /* xgettext:c-format */
849 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
850 pe_def_file
->exports
[i
].ordinal
,
851 pe_def_file
->exports
[i
].name
,
852 pe_def_file
->exports
[pi
].name
);
854 exported_symbols
[ei
] = i
;
856 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
860 next_ordinal
= min_ordinal
;
861 for (i
= 0; i
< NE
; i
++)
862 if (exported_symbol_sections
[i
])
863 if (pe_def_file
->exports
[i
].ordinal
== -1)
865 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
868 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
869 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
872 /* OK, now we can allocate some memory. */
873 edata_sz
= (40 /* directory */
874 + 4 * export_table_size
/* addresses */
875 + 4 * count_exported_byname
/* name ptrs */
876 + 2 * count_exported_byname
/* ordinals */
877 + name_table_size
+ strlen (dll_name
) + 1);
880 /* Fill the exported symbol offsets. The preliminary work has already
881 been done in process_def_file(). */
884 fill_exported_offsets (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
887 struct bfd_link_hash_entry
*blhe
;
889 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
893 name
= xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
894 if (pe_details
->underscored
895 && *pe_def_file
->exports
[i
].internal_name
!= '@')
898 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
901 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
903 blhe
= bfd_link_hash_lookup (info
->hash
,
907 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
908 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
915 fill_edata (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
918 unsigned char *edirectory
;
919 unsigned long *eaddresses
;
920 unsigned long *enameptrs
;
921 unsigned short *eordinals
;
922 unsigned char *enamestr
;
927 edata_d
= xmalloc (edata_sz
);
929 /* Note use of array pointer math here. */
930 edirectory
= edata_d
;
931 eaddresses
= (unsigned long *) (edata_d
+ 40);
932 enameptrs
= eaddresses
+ export_table_size
;
933 eordinals
= (unsigned short *) (enameptrs
+ count_exported_byname
);
934 enamestr
= (char *) (eordinals
+ count_exported_byname
);
936 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
937 + edata_s->output_section->vma - image_base)
939 memset (edata_d
, 0, edata_sz
);
940 bfd_put_32 (abfd
, now
, edata_d
+ 4);
941 if (pe_def_file
->version_major
!= -1)
943 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
944 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
947 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
948 strcpy (enamestr
, dll_name
);
949 enamestr
+= strlen (enamestr
) + 1;
950 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
951 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
952 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
953 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
954 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
955 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
957 fill_exported_offsets (abfd
, info
);
959 /* Ok, now for the filling in part.
960 Scan alphabetically - ie the ordering in the exports[] table,
961 rather than by ordinal - the ordering in the exported_symbol[]
962 table. See dlltool.c and:
963 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
964 for more information. */
966 for (s
= 0; s
< NE
; s
++)
968 if (pe_def_file
->exports
[s
].ordinal
!= -1)
970 struct bfd_section
*ssec
= exported_symbol_sections
[s
];
971 unsigned long srva
= (exported_symbol_offsets
[s
]
972 + ssec
->output_section
->vma
973 + ssec
->output_offset
);
974 int ord
= pe_def_file
->exports
[s
].ordinal
;
976 bfd_put_32 (abfd
, srva
- image_base
,
977 (void *) (eaddresses
+ ord
- min_ordinal
));
979 if (!pe_def_file
->exports
[s
].flag_noname
)
981 char *ename
= pe_def_file
->exports
[s
].name
;
983 bfd_put_32 (abfd
, ERVA (enamestr
), (void *) enameptrs
);
985 strcpy (enamestr
, ename
);
986 enamestr
+= strlen (enamestr
) + 1;
987 bfd_put_16 (abfd
, ord
- min_ordinal
, (void *) eordinals
);
989 pe_def_file
->exports
[s
].hint
= hint
++;
996 static struct bfd_section
*current_sec
;
999 pe_walk_relocs_of_symbol (struct bfd_link_info
*info
,
1001 int (*cb
) (arelent
*, asection
*))
1006 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1011 symsize
= bfd_get_symtab_upper_bound (b
);
1012 symbols
= xmalloc (symsize
);
1013 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1015 for (s
= b
->sections
; s
; s
= s
->next
)
1018 int relsize
, nrelocs
, i
;
1019 int flags
= bfd_get_section_flags (b
, s
);
1021 /* Skip discarded linkonce sections. */
1022 if (flags
& SEC_LINK_ONCE
1023 && s
->output_section
== bfd_abs_section_ptr
)
1028 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1029 relocs
= xmalloc (relsize
);
1030 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1032 for (i
= 0; i
< nrelocs
; i
++)
1034 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1036 if (!strcmp (name
, sym
->name
))
1042 /* Warning: the allocated symbols are remembered in BFD and reused
1043 later, so don't free them! */
1044 /* free (symbols); */
1049 /* Gather all the relocations and build the .reloc section. */
1052 generate_reloc (bfd
*abfd
, struct bfd_link_info
*info
)
1055 /* For .reloc stuff. */
1056 reloc_data_type
*reloc_data
;
1057 int total_relocs
= 0;
1059 unsigned long sec_page
= (unsigned long) -1;
1060 unsigned long page_ptr
, page_count
;
1063 struct bfd_section
*s
;
1066 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1067 for (s
= b
->sections
; s
; s
= s
->next
)
1068 total_relocs
+= s
->reloc_count
;
1070 reloc_data
= xmalloc (total_relocs
* sizeof (reloc_data_type
));
1074 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1077 int relsize
, nrelocs
, i
;
1079 for (s
= b
->sections
; s
; s
= s
->next
)
1081 unsigned long sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1085 /* If it's not loaded, we don't need to relocate it this way. */
1086 if (!(s
->output_section
->flags
& SEC_LOAD
))
1089 /* I don't know why there would be a reloc for these, but I've
1090 seen it happen - DJ */
1091 if (s
->output_section
== &bfd_abs_section
)
1094 if (s
->output_section
->vma
== 0)
1096 /* Huh? Shouldn't happen, but punt if it does. */
1097 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1098 s
->output_section
->name
, s
->output_section
->index
,
1099 s
->output_section
->flags
);
1103 symsize
= bfd_get_symtab_upper_bound (b
);
1104 symbols
= xmalloc (symsize
);
1105 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1107 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1108 relocs
= xmalloc (relsize
);
1109 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1111 for (i
= 0; i
< nrelocs
; i
++)
1113 if (pe_dll_extra_pe_debug
)
1115 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1116 printf ("rel: %s\n", sym
->name
);
1118 if (!relocs
[i
]->howto
->pc_relative
1119 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1122 struct bfd_symbol
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1124 sym_vma
= (relocs
[i
]->addend
1127 + sym
->section
->output_offset
1128 + sym
->section
->output_section
->vma
);
1129 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1131 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1133 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1134 relocs
[i
]->howto
->rightshift
)
1136 case BITS_AND_SHIFT (32, 0):
1137 reloc_data
[total_relocs
].type
= 3;
1140 case BITS_AND_SHIFT (16, 0):
1141 reloc_data
[total_relocs
].type
= 2;
1144 case BITS_AND_SHIFT (16, 16):
1145 reloc_data
[total_relocs
].type
= 4;
1146 /* FIXME: we can't know the symbol's right value
1147 yet, but we probably can safely assume that
1148 CE will relocate us in 64k blocks, so leaving
1150 reloc_data
[total_relocs
].extra
= 0;
1153 case BITS_AND_SHIFT (26, 2):
1154 reloc_data
[total_relocs
].type
= 5;
1157 case BITS_AND_SHIFT (24, 2):
1158 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1159 Those ARM_xxx definitions should go in proper
1161 if (relocs
[i
]->howto
->type
== 0
1162 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1163 || relocs
[i
]->howto
->type
== 5)
1164 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1165 that has already been fully processed during a
1166 previous link stage, so ignore it here. */
1170 /* xgettext:c-format */
1171 einfo (_("%XError: %d-bit reloc in dll\n"),
1172 relocs
[i
]->howto
->bitsize
);
1178 /* Warning: the allocated symbols are remembered in BFD and
1179 reused later, so don't free them! */
1186 /* At this point, we have total_relocs relocation addresses in
1187 reloc_addresses, which are all suitable for the .reloc section.
1188 We must now create the new sections. */
1189 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1191 for (i
= 0; i
< total_relocs
; i
++)
1193 unsigned long this_page
= (reloc_data
[i
].vma
>> 12);
1195 if (this_page
!= sec_page
)
1197 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1199 sec_page
= this_page
;
1204 if (reloc_data
[i
].type
== 4)
1208 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1209 reloc_d
= xmalloc (reloc_sz
);
1210 sec_page
= (unsigned long) -1;
1212 page_ptr
= (unsigned long) -1;
1215 for (i
= 0; i
< total_relocs
; i
++)
1217 unsigned long rva
= reloc_data
[i
].vma
- image_base
;
1218 unsigned long this_page
= (rva
& ~0xfff);
1220 if (this_page
!= sec_page
)
1222 while (reloc_sz
& 3)
1223 reloc_d
[reloc_sz
++] = 0;
1225 if (page_ptr
!= (unsigned long) -1)
1226 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1228 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1229 page_ptr
= reloc_sz
;
1231 sec_page
= this_page
;
1235 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1236 reloc_d
+ reloc_sz
);
1239 if (reloc_data
[i
].type
== 4)
1241 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1248 while (reloc_sz
& 3)
1249 reloc_d
[reloc_sz
++] = 0;
1251 if (page_ptr
!= (unsigned long) -1)
1252 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1254 while (reloc_sz
< reloc_s
->_raw_size
)
1255 reloc_d
[reloc_sz
++] = 0;
1258 /* Given the exiting def_file structure, print out a .DEF file that
1259 corresponds to it. */
1262 quoteput (char *s
, FILE *f
, int needs_quotes
)
1266 for (cp
= s
; *cp
; cp
++)
1281 if (*s
== '"' || *s
== '\\')
1295 pe_dll_generate_def_file (const char *pe_out_def_filename
)
1298 FILE *out
= fopen (pe_out_def_filename
, "w");
1301 /* xgettext:c-format */
1302 einfo (_("%s: Can't open output def file %s\n"),
1303 program_name
, pe_out_def_filename
);
1307 if (pe_def_file
->name
)
1309 if (pe_def_file
->is_dll
)
1310 fprintf (out
, "LIBRARY ");
1312 fprintf (out
, "NAME ");
1314 quoteput (pe_def_file
->name
, out
, 1);
1316 if (pe_data (output_bfd
)->pe_opthdr
.ImageBase
)
1317 fprintf (out
, " BASE=0x%lx",
1318 (unsigned long) pe_data (output_bfd
)->pe_opthdr
.ImageBase
);
1319 fprintf (out
, "\n");
1322 if (pe_def_file
->description
)
1324 fprintf (out
, "DESCRIPTION ");
1325 quoteput (pe_def_file
->description
, out
, 1);
1326 fprintf (out
, "\n");
1329 if (pe_def_file
->version_minor
!= -1)
1330 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1331 pe_def_file
->version_minor
);
1332 else if (pe_def_file
->version_major
!= -1)
1333 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1335 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1336 fprintf (out
, "\n");
1338 if (pe_def_file
->stack_commit
!= -1)
1339 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1340 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1341 else if (pe_def_file
->stack_reserve
!= -1)
1342 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1344 if (pe_def_file
->heap_commit
!= -1)
1345 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1346 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1347 else if (pe_def_file
->heap_reserve
!= -1)
1348 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1350 if (pe_def_file
->num_section_defs
> 0)
1352 fprintf (out
, "\nSECTIONS\n\n");
1354 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1357 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1359 if (pe_def_file
->section_defs
[i
].class)
1361 fprintf (out
, " CLASS ");
1362 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1365 if (pe_def_file
->section_defs
[i
].flag_read
)
1366 fprintf (out
, " READ");
1368 if (pe_def_file
->section_defs
[i
].flag_write
)
1369 fprintf (out
, " WRITE");
1371 if (pe_def_file
->section_defs
[i
].flag_execute
)
1372 fprintf (out
, " EXECUTE");
1374 if (pe_def_file
->section_defs
[i
].flag_shared
)
1375 fprintf (out
, " SHARED");
1377 fprintf (out
, "\n");
1381 if (pe_def_file
->num_exports
> 0)
1383 fprintf (out
, "EXPORTS\n");
1385 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1387 def_file_export
*e
= pe_def_file
->exports
+ i
;
1389 quoteput (e
->name
, out
, 0);
1391 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1393 fprintf (out
, " = ");
1394 quoteput (e
->internal_name
, out
, 0);
1397 if (e
->ordinal
!= -1)
1398 fprintf (out
, " @%d", e
->ordinal
);
1400 if (e
->flag_private
)
1401 fprintf (out
, " PRIVATE");
1403 if (e
->flag_constant
)
1404 fprintf (out
, " CONSTANT");
1407 fprintf (out
, " NONAME");
1410 fprintf (out
, " DATA");
1412 fprintf (out
, "\n");
1416 if (pe_def_file
->num_imports
> 0)
1418 fprintf (out
, "\nIMPORTS\n\n");
1420 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1422 def_file_import
*im
= pe_def_file
->imports
+ i
;
1425 if (im
->internal_name
1426 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1428 quoteput (im
->internal_name
, out
, 0);
1429 fprintf (out
, " = ");
1432 quoteput (im
->module
->name
, out
, 0);
1436 quoteput (im
->name
, out
, 0);
1438 fprintf (out
, "%d", im
->ordinal
);
1440 fprintf (out
, "\n");
1445 fprintf (out
, _("; no contents available\n"));
1447 if (fclose (out
) == EOF
)
1448 /* xgettext:c-format */
1449 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1452 /* Generate the import library. */
1454 static asymbol
**symtab
;
1457 static const char *dll_filename
;
1458 static char *dll_symname
;
1460 #define UNDSEC (asection *) &bfd_und_section
1463 quick_section (bfd
*abfd
, const char *name
, int flags
, int align
)
1468 sec
= bfd_make_section_old_way (abfd
, name
);
1469 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1470 bfd_set_section_alignment (abfd
, sec
, align
);
1471 /* Remember to undo this before trying to link internally! */
1472 sec
->output_section
= sec
;
1474 sym
= bfd_make_empty_symbol (abfd
);
1475 symtab
[symptr
++] = sym
;
1476 sym
->name
= sec
->name
;
1478 sym
->flags
= BSF_LOCAL
;
1485 quick_symbol (bfd
*abfd
,
1494 char *name
= xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1499 sym
= bfd_make_empty_symbol (abfd
);
1504 symtab
[symptr
++] = sym
;
1507 static arelent
*reltab
= 0;
1508 static int relcount
= 0, relsize
= 0;
1511 quick_reloc (bfd
*abfd
, int address
, int which_howto
, int symidx
)
1513 if (relcount
>= relsize
- 1)
1517 reltab
= xrealloc (reltab
, relsize
* sizeof (arelent
));
1519 reltab
= xmalloc (relsize
* sizeof (arelent
));
1521 reltab
[relcount
].address
= address
;
1522 reltab
[relcount
].addend
= 0;
1523 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1524 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1529 save_relocs (asection
*sec
)
1533 sec
->relocation
= reltab
;
1534 sec
->reloc_count
= relcount
;
1535 sec
->orelocation
= xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1536 for (i
= 0; i
< relcount
; i
++)
1537 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1538 sec
->orelocation
[relcount
] = 0;
1539 sec
->flags
|= SEC_RELOC
;
1541 relcount
= relsize
= 0;
1544 /* .section .idata$2
1545 .global __head_my_dll
1562 make_head (bfd
*parent
)
1564 asection
*id2
, *id5
, *id4
;
1565 unsigned char *d2
, *d5
, *d4
;
1569 oname
= xmalloc (20);
1570 sprintf (oname
, "d%06d.o", tmp_seq
);
1573 abfd
= bfd_create (oname
, parent
);
1574 bfd_find_target (pe_details
->object_target
, abfd
);
1575 bfd_make_writable (abfd
);
1577 bfd_set_format (abfd
, bfd_object
);
1578 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1581 symtab
= xmalloc (6 * sizeof (asymbol
*));
1582 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1583 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1584 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1585 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1586 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1588 /* OK, pay attention here. I got confused myself looking back at
1589 it. We create a four-byte section to mark the beginning of the
1590 list, and we include an offset of 4 in the section, so that the
1591 pointer to the list points to the *end* of this section, which is
1592 the start of the list of sections from other objects. */
1594 bfd_set_section_size (abfd
, id2
, 20);
1598 d2
[0] = d2
[16] = 4; /* Reloc addend. */
1599 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1600 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1601 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1604 bfd_set_section_size (abfd
, id5
, 4);
1609 bfd_set_section_size (abfd
, id4
, 4);
1614 bfd_set_symtab (abfd
, symtab
, symptr
);
1616 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1617 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1618 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1620 bfd_make_readable (abfd
);
1624 /* .section .idata$4
1629 .global __my_dll_iname
1634 make_tail (bfd
*parent
)
1636 asection
*id4
, *id5
, *id7
;
1637 unsigned char *d4
, *d5
, *d7
;
1642 oname
= xmalloc (20);
1643 sprintf (oname
, "d%06d.o", tmp_seq
);
1646 abfd
= bfd_create (oname
, parent
);
1647 bfd_find_target (pe_details
->object_target
, abfd
);
1648 bfd_make_writable (abfd
);
1650 bfd_set_format (abfd
, bfd_object
);
1651 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1654 symtab
= xmalloc (5 * sizeof (asymbol
*));
1655 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1656 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1657 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1658 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1660 bfd_set_section_size (abfd
, id4
, 4);
1665 bfd_set_section_size (abfd
, id5
, 4);
1670 len
= strlen (dll_filename
) + 1;
1673 bfd_set_section_size (abfd
, id7
, len
);
1676 strcpy (d7
, dll_filename
);
1678 bfd_set_symtab (abfd
, symtab
, symptr
);
1680 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1681 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1682 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1684 bfd_make_readable (abfd
);
1690 .global ___imp_function
1691 .global __imp__function
1693 jmp *__imp__function:
1707 .asciz "function" xlate? (add underscore, kill at) */
1709 static unsigned char jmp_ix86_bytes
[] =
1711 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1719 .dw __imp_function */
1721 static unsigned char jmp_sh_bytes
[] =
1723 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1727 lui $t0,<high:__imp_function>
1728 lw $t0,<low:__imp_function>
1732 static unsigned char jmp_mips_bytes
[] =
1734 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1735 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1739 make_one (def_file_export
*exp
, bfd
*parent
)
1741 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1742 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1746 unsigned char *jmp_bytes
= NULL
;
1747 int jmp_byte_count
= 0;
1749 switch (pe_details
->pe_arch
)
1752 jmp_bytes
= jmp_ix86_bytes
;
1753 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1756 jmp_bytes
= jmp_sh_bytes
;
1757 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1760 jmp_bytes
= jmp_mips_bytes
;
1761 jmp_byte_count
= sizeof (jmp_mips_bytes
);
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 (11 * sizeof (asymbol
*));
1780 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1781 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1782 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1783 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1784 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1786 if (*exp
->internal_name
== '@')
1788 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1790 if (! exp
->flag_data
)
1791 quick_symbol (abfd
, "", exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1792 quick_symbol (abfd
, U ("_imp_"), exp
->internal_name
, "", id5
,
1794 /* Fastcall applies only to functions,
1795 so no need for auto-import symbol. */
1799 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
,
1801 if (! exp
->flag_data
)
1802 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
,
1804 quick_symbol (abfd
, U ("_imp__"), exp
->internal_name
, "", id5
,
1806 /* Symbol to reference ord/name of imported
1807 data symbol, used to implement auto-import. */
1809 quick_symbol (abfd
, U("_nm__"), exp
->internal_name
, "", id6
,
1812 if (pe_dll_compat_implib
)
1813 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "", id5
,
1816 if (! exp
->flag_data
)
1818 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
1819 td
= xmalloc (jmp_byte_count
);
1821 memcpy (td
, jmp_bytes
, jmp_byte_count
);
1823 switch (pe_details
->pe_arch
)
1826 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
1829 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
1832 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
1833 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
1834 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
1842 bfd_set_section_size (abfd
, id7
, 4);
1846 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 5);
1849 bfd_set_section_size (abfd
, id5
, 4);
1854 if (exp
->flag_noname
)
1856 d5
[0] = exp
->ordinal
;
1857 d5
[1] = exp
->ordinal
>> 8;
1862 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1866 bfd_set_section_size (abfd
, id4
, 4);
1871 if (exp
->flag_noname
)
1873 d4
[0] = exp
->ordinal
;
1874 d4
[1] = exp
->ordinal
>> 8;
1879 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1883 if (exp
->flag_noname
)
1886 bfd_set_section_size (abfd
, id6
, 0);
1890 len
= strlen (exp
->name
) + 3;
1893 bfd_set_section_size (abfd
, id6
, len
);
1896 memset (d6
, 0, len
);
1897 d6
[0] = exp
->hint
& 0xff;
1898 d6
[1] = exp
->hint
>> 8;
1899 strcpy (d6
+ 2, exp
->name
);
1902 bfd_set_symtab (abfd
, symtab
, symptr
);
1904 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
1905 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
1906 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1907 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1908 if (!exp
->flag_noname
)
1909 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
1911 bfd_make_readable (abfd
);
1916 make_singleton_name_thunk (const char *import
, bfd
*parent
)
1918 /* Name thunks go to idata$4. */
1924 oname
= xmalloc (20);
1925 sprintf (oname
, "nmth%06d.o", tmp_seq
);
1928 abfd
= bfd_create (oname
, parent
);
1929 bfd_find_target (pe_details
->object_target
, abfd
);
1930 bfd_make_writable (abfd
);
1932 bfd_set_format (abfd
, bfd_object
);
1933 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1936 symtab
= xmalloc (3 * sizeof (asymbol
*));
1937 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1938 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
1939 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
1941 bfd_set_section_size (abfd
, id4
, 8);
1945 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1948 bfd_set_symtab (abfd
, symtab
, symptr
);
1950 bfd_set_section_contents (abfd
, id4
, d4
, 0, 8);
1952 bfd_make_readable (abfd
);
1957 make_import_fixup_mark (arelent
*rel
)
1959 /* We convert reloc to symbol, for later reference. */
1961 static char *fixup_name
= NULL
;
1962 static size_t buffer_len
= 0;
1964 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
1966 bfd
*abfd
= bfd_asymbol_bfd (sym
);
1967 struct bfd_link_hash_entry
*bh
;
1971 fixup_name
= xmalloc (384);
1975 if (strlen (sym
->name
) + 25 > buffer_len
)
1976 /* Assume 25 chars for "__fu" + counter + "_". If counter is
1977 bigger than 20 digits long, we've got worse problems than
1978 overflowing this buffer... */
1981 /* New buffer size is length of symbol, plus 25, but
1982 then rounded up to the nearest multiple of 128. */
1983 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
1984 fixup_name
= xmalloc (buffer_len
);
1987 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
1990 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
1991 current_sec
, /* sym->section, */
1992 rel
->address
, NULL
, TRUE
, FALSE
, &bh
);
1996 struct coff_link_hash_entry
*myh
;
1998 myh
= (struct coff_link_hash_entry
*) bh
;
1999 printf ("type:%d\n", myh
->type
);
2000 printf ("%s\n", myh
->root
.u
.def
.section
->name
);
2006 /* .section .idata$3
2007 .rva __nm_thnk_SYM (singleton thunk with name of func)
2010 .rva __my_dll_iname (name of dll)
2011 .rva __fuNN_SYM (pointer to reference (address) in text) */
2014 make_import_fixup_entry (const char *name
,
2015 const char *fixup_name
,
2016 const char *dll_symname
,
2024 oname
= xmalloc (20);
2025 sprintf (oname
, "fu%06d.o", tmp_seq
);
2028 abfd
= bfd_create (oname
, parent
);
2029 bfd_find_target (pe_details
->object_target
, abfd
);
2030 bfd_make_writable (abfd
);
2032 bfd_set_format (abfd
, bfd_object
);
2033 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2036 symtab
= xmalloc (6 * sizeof (asymbol
*));
2037 id3
= quick_section (abfd
, ".idata$3", SEC_HAS_CONTENTS
, 2);
2040 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2042 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2043 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2044 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2046 bfd_set_section_size (abfd
, id3
, 20);
2051 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2052 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2053 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2056 bfd_set_symtab (abfd
, symtab
, symptr
);
2058 bfd_set_section_contents (abfd
, id3
, d3
, 0, 20);
2060 bfd_make_readable (abfd
);
2064 /* .section .rdata_runtime_pseudo_reloc
2066 .rva __fuNN_SYM (pointer to reference (address) in text) */
2069 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED
,
2070 const char *fixup_name
,
2075 unsigned char *rt_rel_d
;
2079 oname
= xmalloc (20);
2080 sprintf (oname
, "rtr%06d.o", tmp_seq
);
2083 abfd
= bfd_create (oname
, parent
);
2084 bfd_find_target (pe_details
->object_target
, abfd
);
2085 bfd_make_writable (abfd
);
2087 bfd_set_format (abfd
, bfd_object
);
2088 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2091 symtab
= xmalloc (2 * sizeof (asymbol
*));
2092 rt_rel
= quick_section (abfd
, ".rdata_runtime_pseudo_reloc",
2093 SEC_HAS_CONTENTS
, 2);
2095 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2097 bfd_set_section_size (abfd
, rt_rel
, 8);
2098 rt_rel_d
= xmalloc (8);
2099 rt_rel
->contents
= rt_rel_d
;
2100 memset (rt_rel_d
, 0, 8);
2101 bfd_put_32 (abfd
, addend
, rt_rel_d
);
2103 quick_reloc (abfd
, 4, BFD_RELOC_RVA
, 1);
2104 save_relocs (rt_rel
);
2106 bfd_set_symtab (abfd
, symtab
, symptr
);
2108 bfd_set_section_contents (abfd
, rt_rel
, rt_rel_d
, 0, 8);
2110 bfd_make_readable (abfd
);
2115 .rva __pei386_runtime_relocator */
2118 pe_create_runtime_relocator_reference (bfd
*parent
)
2120 asection
*extern_rt_rel
;
2121 unsigned char *extern_rt_rel_d
;
2125 oname
= xmalloc (20);
2126 sprintf (oname
, "ertr%06d.o", tmp_seq
);
2129 abfd
= bfd_create (oname
, parent
);
2130 bfd_find_target (pe_details
->object_target
, abfd
);
2131 bfd_make_writable (abfd
);
2133 bfd_set_format (abfd
, bfd_object
);
2134 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2137 symtab
= xmalloc (2 * sizeof (asymbol
*));
2138 extern_rt_rel
= quick_section (abfd
, ".rdata", SEC_HAS_CONTENTS
, 2);
2140 quick_symbol (abfd
, "", "__pei386_runtime_relocator", "", UNDSEC
,
2143 bfd_set_section_size (abfd
, extern_rt_rel
, 4);
2144 extern_rt_rel_d
= xmalloc (4);
2145 extern_rt_rel
->contents
= extern_rt_rel_d
;
2147 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2148 save_relocs (extern_rt_rel
);
2150 bfd_set_symtab (abfd
, symtab
, symptr
);
2152 bfd_set_section_contents (abfd
, extern_rt_rel
, extern_rt_rel_d
, 0, 4);
2154 bfd_make_readable (abfd
);
2159 pe_create_import_fixup (arelent
*rel
, asection
*s
, int addend
)
2162 struct bfd_symbol
*sym
= *rel
->sym_ptr_ptr
;
2163 struct bfd_link_hash_entry
*name_thunk_sym
;
2164 const char *name
= sym
->name
;
2165 char *fixup_name
= make_import_fixup_mark (rel
);
2168 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2170 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2172 if (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
)
2174 bfd
*b
= make_singleton_name_thunk (name
, output_bfd
);
2175 add_bfd_to_link (b
, b
->filename
, &link_info
);
2177 /* If we ever use autoimport, we have to cast text section writable. */
2178 config
.text_read_only
= FALSE
;
2181 if (addend
== 0 || link_info
.pei386_runtime_pseudo_reloc
)
2183 extern char * pe_data_import_dll
;
2184 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2186 b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
, output_bfd
);
2187 add_bfd_to_link (b
, b
->filename
, &link_info
);
2192 if (link_info
.pei386_runtime_pseudo_reloc
)
2194 if (pe_dll_extra_pe_debug
)
2195 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2196 fixup_name
, addend
);
2197 b
= make_runtime_pseudo_reloc (name
, fixup_name
, addend
, output_bfd
);
2198 add_bfd_to_link (b
, b
->filename
, &link_info
);
2200 if (runtime_pseudo_relocs_created
== 0)
2202 b
= pe_create_runtime_relocator_reference (output_bfd
);
2203 add_bfd_to_link (b
, b
->filename
, &link_info
);
2205 runtime_pseudo_relocs_created
++;
2209 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2210 s
->owner
, s
, rel
->address
, sym
->name
);
2218 pe_dll_generate_implib (def_file
*def
, const char *impfilename
)
2226 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2227 dll_symname
= xstrdup (dll_filename
);
2228 for (i
= 0; dll_symname
[i
]; i
++)
2229 if (!ISALNUM (dll_symname
[i
]))
2230 dll_symname
[i
] = '_';
2232 unlink (impfilename
);
2234 outarch
= bfd_openw (impfilename
, 0);
2238 /* xgettext:c-format */
2239 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2243 /* xgettext:c-format */
2244 einfo (_("Creating library file: %s\n"), impfilename
);
2246 bfd_set_format (outarch
, bfd_archive
);
2247 outarch
->has_armap
= 1;
2249 /* Work out a reasonable size of things to put onto one line. */
2250 ar_head
= make_head (outarch
);
2252 for (i
= 0; i
< def
->num_exports
; i
++)
2254 /* The import library doesn't know about the internal name. */
2255 char *internal
= def
->exports
[i
].internal_name
;
2258 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2259 n
= make_one (def
->exports
+ i
, outarch
);
2262 def
->exports
[i
].internal_name
= internal
;
2265 ar_tail
= make_tail (outarch
);
2267 if (ar_head
== NULL
|| ar_tail
== NULL
)
2270 /* Now stick them all into the archive. */
2271 ar_head
->next
= head
;
2272 ar_tail
->next
= ar_head
;
2275 if (! bfd_set_archive_head (outarch
, head
))
2276 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
2278 if (! bfd_close (outarch
))
2279 einfo ("%Xbfd_close %s: %s\n", impfilename
, bfd_errmsg (bfd_get_error ()));
2281 while (head
!= NULL
)
2283 bfd
*n
= head
->next
;
2290 add_bfd_to_link (bfd
*abfd
, const char *name
, struct bfd_link_info
*link_info
)
2292 lang_input_statement_type
*fake_file
;
2294 fake_file
= lang_add_input_file (name
,
2295 lang_input_file_is_fake_enum
,
2297 fake_file
->the_bfd
= abfd
;
2298 ldlang_add_file (fake_file
);
2300 if (!bfd_link_add_symbols (abfd
, link_info
))
2301 einfo ("%Xaddsym %s: %s\n", name
, bfd_errmsg (bfd_get_error ()));
2305 pe_process_import_defs (bfd
*output_bfd
, struct bfd_link_info
*link_info
)
2307 def_file_module
*module
;
2309 pe_dll_id_target (bfd_get_target (output_bfd
));
2314 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2318 dll_filename
= module
->name
;
2319 dll_symname
= xstrdup (module
->name
);
2320 for (i
= 0; dll_symname
[i
]; i
++)
2321 if (!ISALNUM (dll_symname
[i
]))
2322 dll_symname
[i
] = '_';
2326 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2327 if (pe_def_file
->imports
[i
].module
== module
)
2329 def_file_export exp
;
2330 struct bfd_link_hash_entry
*blhe
;
2331 int lead_at
= (*pe_def_file
->imports
[i
].internal_name
== '@');
2332 /* See if we need this import. */
2333 size_t len
= strlen (pe_def_file
->imports
[i
].internal_name
);
2334 char *name
= xmalloc (len
+ 2 + 6);
2337 sprintf (name
, "%s%s", "",
2338 pe_def_file
->imports
[i
].internal_name
);
2340 sprintf (name
, "%s%s",U (""),
2341 pe_def_file
->imports
[i
].internal_name
);
2343 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2344 FALSE
, FALSE
, FALSE
);
2346 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2349 sprintf (name
, "%s%s", U ("_imp_"),
2350 pe_def_file
->imports
[i
].internal_name
);
2352 sprintf (name
, "%s%s", U ("_imp__"),
2353 pe_def_file
->imports
[i
].internal_name
);
2355 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2356 FALSE
, FALSE
, FALSE
);
2360 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2366 bfd
*ar_head
= make_head (output_bfd
);
2367 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2370 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2371 exp
.name
= pe_def_file
->imports
[i
].name
;
2372 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2373 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2374 exp
.flag_private
= 0;
2375 exp
.flag_constant
= 0;
2376 exp
.flag_data
= pe_def_file
->imports
[i
].data
;
2377 exp
.flag_noname
= exp
.name
? 0 : 1;
2378 one
= make_one (&exp
, output_bfd
);
2379 add_bfd_to_link (one
, one
->filename
, link_info
);
2384 bfd
*ar_tail
= make_tail (output_bfd
);
2385 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2392 /* We were handed a *.DLL file. Parse it and turn it into a set of
2393 IMPORTS directives in the def file. Return TRUE if the file was
2394 handled, FALSE if not. */
2397 pe_get16 (bfd
*abfd
, int where
)
2401 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2402 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2403 return b
[0] + (b
[1] << 8);
2407 pe_get32 (bfd
*abfd
, int where
)
2411 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2412 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2413 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2416 #if 0 /* This is not currently used. */
2421 unsigned char *b
= ptr
;
2423 return b
[0] + (b
[1] << 8);
2431 unsigned char *b
= ptr
;
2433 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2437 pe_implied_import_dll (const char *filename
)
2440 unsigned long pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2441 unsigned long export_rva
, export_size
, nsections
, secptr
, expptr
;
2442 unsigned long exp_funcbase
;
2443 unsigned char *expdata
, *erva
;
2444 unsigned long name_rvas
, ordinals
, nexp
, ordbase
;
2445 const char *dll_name
;
2446 /* Initialization with start > end guarantees that is_data
2447 will not be set by mistake, and avoids compiler warning. */
2448 unsigned long data_start
= 1;
2449 unsigned long data_end
= 0;
2450 unsigned long rdata_start
= 1;
2451 unsigned long rdata_end
= 0;
2452 unsigned long bss_start
= 1;
2453 unsigned long bss_end
= 0;
2455 /* No, I can't use bfd here. kernel32.dll puts its export table in
2456 the middle of the .rdata section. */
2457 dll
= bfd_openr (filename
, pe_details
->target_name
);
2460 einfo ("%Xopen %s: %s\n", filename
, bfd_errmsg (bfd_get_error ()));
2464 /* PEI dlls seem to be bfd_objects. */
2465 if (!bfd_check_format (dll
, bfd_object
))
2467 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2471 /* Get pe_header, optional header and numbers of export entries. */
2472 pe_header_offset
= pe_get32 (dll
, 0x3c);
2473 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2474 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2476 if (num_entries
< 1) /* No exports. */
2479 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2480 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2481 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2482 secptr
= (pe_header_offset
+ 4 + 20 +
2483 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2486 /* Get the rva and size of the export section. */
2487 for (i
= 0; i
< nsections
; i
++)
2490 unsigned long secptr1
= secptr
+ 40 * i
;
2491 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
2492 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 16);
2493 unsigned long fptr
= pe_get32 (dll
, secptr1
+ 20);
2495 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2496 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2498 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2500 expptr
= fptr
+ (export_rva
- vaddr
);
2501 if (export_rva
+ export_size
> vaddr
+ vsize
)
2502 export_size
= vsize
- (export_rva
- vaddr
);
2507 /* Scan sections and store the base and size of the
2508 data and bss segments in data/base_start/end. */
2509 for (i
= 0; i
< nsections
; i
++)
2511 unsigned long secptr1
= secptr
+ 40 * i
;
2512 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 8);
2513 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
2514 unsigned long flags
= pe_get32 (dll
, secptr1
+ 36);
2518 bfd_seek (dll
, (file_ptr
) secptr1
+ 0, SEEK_SET
);
2519 bfd_bread (sec_name
, (bfd_size_type
) 8, dll
);
2521 if (strcmp(sec_name
,".data") == 0)
2524 data_end
= vaddr
+ vsize
;
2526 if (pe_dll_extra_pe_debug
)
2527 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2528 __FUNCTION__
, sec_name
, vaddr
, vaddr
+ vsize
, flags
);
2530 else if (strcmp(sec_name
,".rdata") == 0)
2532 rdata_start
= vaddr
;
2533 rdata_end
= vaddr
+ vsize
;
2535 if (pe_dll_extra_pe_debug
)
2536 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2537 __FUNCTION__
, sec_name
, vaddr
, vaddr
+ vsize
, flags
);
2539 else if (strcmp (sec_name
,".bss") == 0)
2542 bss_end
= vaddr
+ vsize
;
2544 if (pe_dll_extra_pe_debug
)
2545 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2546 __FUNCTION__
, sec_name
, vaddr
, vaddr
+ vsize
, flags
);
2550 expdata
= xmalloc (export_size
);
2551 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2552 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2553 erva
= expdata
- export_rva
;
2555 if (pe_def_file
== 0)
2556 pe_def_file
= def_file_empty ();
2558 nexp
= pe_as32 (expdata
+ 24);
2559 name_rvas
= pe_as32 (expdata
+ 32);
2560 ordinals
= pe_as32 (expdata
+ 36);
2561 ordbase
= pe_as32 (expdata
+ 16);
2562 exp_funcbase
= pe_as32 (expdata
+ 28);
2564 /* Use internal dll name instead of filename
2565 to enable symbolic dll linking. */
2566 dll_name
= pe_as32 (expdata
+ 12) + erva
;
2568 /* Check to see if the dll has already been added to
2569 the definition list and if so return without error.
2570 This avoids multiple symbol definitions. */
2571 if (def_get_module (pe_def_file
, dll_name
))
2573 if (pe_dll_extra_pe_debug
)
2574 printf ("%s is already loaded\n", dll_name
);
2578 /* Iterate through the list of symbols. */
2579 for (i
= 0; i
< nexp
; i
++)
2581 /* Pointer to the names vector. */
2582 unsigned long name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
2583 def_file_import
*imp
;
2584 /* Pointer to the function address vector. */
2585 unsigned long func_rva
= pe_as32 (erva
+ exp_funcbase
+ i
* 4);
2588 /* Skip unwanted symbols, which are
2589 exported in buggy auto-import releases. */
2590 if (strncmp (erva
+ name_rva
, "_nm_", 4) != 0)
2592 /* is_data is true if the address is in the data, rdata or bss
2595 (func_rva
>= data_start
&& func_rva
< data_end
)
2596 || (func_rva
>= rdata_start
&& func_rva
< rdata_end
)
2597 || (func_rva
>= bss_start
&& func_rva
< bss_end
);
2599 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
,
2601 /* Mark symbol type. */
2602 imp
->data
= is_data
;
2604 if (pe_dll_extra_pe_debug
)
2605 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2606 __FUNCTION__
, dll_name
, erva
+ name_rva
,
2607 func_rva
, is_data
? "(data)" : "");
2614 /* These are the main functions, called from the emulation. The first
2615 is called after the bfds are read, so we can guess at how much space
2616 we need. The second is called after everything is placed, so we
2617 can put the right values in place. */
2620 pe_dll_build_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2622 pe_dll_id_target (bfd_get_target (abfd
));
2623 process_def_file (abfd
, info
);
2625 if (pe_def_file
->num_exports
== 0 && !info
->shared
)
2628 generate_edata (abfd
, info
);
2629 build_filler_bfd (1);
2633 pe_exe_build_sections (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2635 pe_dll_id_target (bfd_get_target (abfd
));
2636 build_filler_bfd (0);
2640 pe_dll_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2642 pe_dll_id_target (bfd_get_target (abfd
));
2643 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2645 generate_reloc (abfd
, info
);
2648 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2650 /* Resize the sections. */
2651 lang_size_sections (stat_ptr
->head
, abs_output_section
,
2652 &stat_ptr
->head
, 0, 0, NULL
, TRUE
);
2654 /* Redo special stuff. */
2655 ldemul_after_allocation ();
2657 /* Do the assignments again. */
2658 lang_do_assignments (stat_ptr
->head
, abs_output_section
, NULL
, 0);
2661 fill_edata (abfd
, info
);
2664 pe_data (abfd
)->dll
= 1;
2666 edata_s
->contents
= edata_d
;
2667 reloc_s
->contents
= reloc_d
;
2671 pe_exe_fill_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2673 pe_dll_id_target (bfd_get_target (abfd
));
2674 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2676 generate_reloc (abfd
, info
);
2679 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2681 /* Resize the sections. */
2682 lang_size_sections (stat_ptr
->head
, abs_output_section
,
2683 &stat_ptr
->head
, 0, 0, NULL
, TRUE
);
2685 /* Redo special stuff. */
2686 ldemul_after_allocation ();
2688 /* Do the assignments again. */
2689 lang_do_assignments (stat_ptr
->head
, abs_output_section
, NULL
, 0);
2691 reloc_s
->contents
= reloc_d
;