1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001 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 practise 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 someting 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 parellel 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 practise,
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, prohibitting 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
;
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 },
228 /* Do not specify library suffix explicitly, to allow for dllized versions. */
229 static autofilter_entry_type autofilter_liblist
[] =
232 { "libstdc++.", 10 },
233 { "libmingw32.", 11 },
237 static autofilter_entry_type autofilter_objlist
[] =
247 static autofilter_entry_type autofilter_symbolprefixlist
[] =
249 /* { "__imp_", 6 }, */
250 /* Do __imp_ explicitly to save time. */
252 { "__builtin_", 10 },
253 /* Don't export symbols specifying internal DLL layout. */
256 { "_impure_ptr", 11 },
257 { "cygwin_attach_dll", 17 },
258 { "cygwin_premain0", 15 },
259 { "cygwin_premain1", 15 },
260 { "cygwin_premain2", 15 },
261 { "cygwin_premain3", 15 },
266 static autofilter_entry_type autofilter_symbolsuffixlist
[] =
272 #define U(str) (pe_details->underscored ? "_" str : str)
274 static int reloc_sort
PARAMS ((const void *, const void *));
275 static int pe_export_sort
PARAMS ((const void *, const void *));
276 static int auto_export
PARAMS ((bfd
*, def_file
*, const char *));
277 static void process_def_file
PARAMS ((bfd
*, struct bfd_link_info
*));
278 static void build_filler_bfd
PARAMS ((int));
279 static void generate_edata
PARAMS ((bfd
*, struct bfd_link_info
*));
280 static void fill_exported_offsets
PARAMS ((bfd
*, struct bfd_link_info
*));
281 static void fill_edata
PARAMS ((bfd
*, struct bfd_link_info
*));
282 static void generate_reloc
PARAMS ((bfd
*, struct bfd_link_info
*));
283 static void quoteput
PARAMS ((char *, FILE *, int));
284 static asection
*quick_section
PARAMS ((bfd
*, const char *, int, int));
285 static void quick_symbol
286 PARAMS ((bfd
*, const char *, const char *, const char *,
287 asection
*, int, int));
288 static void quick_reloc
PARAMS ((bfd
*, int, int, int));
289 static bfd
*make_head
PARAMS ((bfd
*));
290 static bfd
*make_tail
PARAMS ((bfd
*));
291 static bfd
*make_one
PARAMS ((def_file_export
*, bfd
*));
292 static bfd
*make_singleton_name_thunk
PARAMS ((const char *, bfd
*));
293 static char *make_import_fixup_mark
PARAMS ((arelent
*));
294 static bfd
*make_import_fixup_entry
295 PARAMS ((const char *, const char *, const char *, bfd
*));
296 static unsigned int pe_get16
PARAMS ((bfd
*, int));
297 static unsigned int pe_get32
PARAMS ((bfd
*, int));
298 static unsigned int pe_as32
PARAMS ((void *));
301 pe_dll_id_target (target
)
306 for (i
= 0; pe_detail_list
[i
].target_name
; i
++)
307 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
308 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
310 pe_details
= pe_detail_list
+ i
;
313 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
317 /* Helper functions for qsort. Relocs must be sorted so that we can write
318 them out by pages. */
332 bfd_vma a
= ((reloc_data_type
*) va
)->vma
;
333 bfd_vma b
= ((reloc_data_type
*) vb
)->vma
;
335 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
339 pe_export_sort (va
, vb
)
342 def_file_export
*a
= (def_file_export
*) va
;
343 def_file_export
*b
= (def_file_export
*) vb
;
345 return strcmp (a
->name
, b
->name
);
348 /* Read and process the .DEF file. */
350 /* These correspond to the entries in pe_def_file->exports[]. I use
351 exported_symbol_sections[i] to tag whether or not the symbol was
352 defined, since we can't export symbols we don't have. */
354 static bfd_vma
*exported_symbol_offsets
;
355 static struct sec
**exported_symbol_sections
;
356 static int export_table_size
;
357 static int count_exported
;
358 static int count_exported_byname
;
359 static int count_with_ordinals
;
360 static const char *dll_name
;
361 static int min_ordinal
, max_ordinal
;
362 static int *exported_symbols
;
364 typedef struct exclude_list_struct
367 struct exclude_list_struct
*next
;
371 static struct exclude_list_struct
*excludes
= 0;
374 pe_dll_add_excludes (new_excludes
)
375 const char *new_excludes
;
378 char *exclude_string
;
380 local_copy
= xstrdup (new_excludes
);
382 exclude_string
= strtok (local_copy
, ",:");
383 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
385 struct exclude_list_struct
*new_exclude
;
387 new_exclude
= ((struct exclude_list_struct
*)
388 xmalloc (sizeof (struct exclude_list_struct
)));
389 new_exclude
->string
= (char *) xmalloc (strlen (exclude_string
) + 1);
390 strcpy (new_exclude
->string
, exclude_string
);
391 new_exclude
->next
= excludes
;
392 excludes
= new_exclude
;
398 /* abfd is a bfd containing n (or NULL)
399 It can be used for contextual checks. */
402 auto_export (abfd
, d
, n
)
408 struct exclude_list_struct
*ex
;
409 autofilter_entry_type
*afptr
;
411 /* We should not re-export imported stuff. */
412 if (strncmp (n
, "_imp__", 6) == 0)
415 for (i
= 0; i
< d
->num_exports
; i
++)
416 if (strcmp (d
->exports
[i
].name
, n
) == 0)
419 if (pe_dll_do_default_excludes
)
424 if (pe_dll_extra_pe_debug
)
425 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
426 n
, abfd
, abfd
->my_archive
);
428 /* First of all, make context checks:
429 Don't export anything from libgcc. */
430 if (abfd
&& abfd
->my_archive
)
432 afptr
= autofilter_liblist
;
436 if (strstr (abfd
->my_archive
->filename
, afptr
->name
))
442 /* Next, exclude symbols from certain startup objects. */
443 afptr
= autofilter_objlist
;
448 (p
= strstr (abfd
->filename
, afptr
->name
)) &&
449 (*(p
+ afptr
->len
- 1) == 0))
455 /* Don't try to blindly exclude all symbols
456 that begin with '__'; this was tried and
457 it is too restrictive. */
459 /* Then, exclude specific symbols. */
460 afptr
= autofilter_symbollist
;
463 if (strcmp (n
, afptr
->name
) == 0)
469 /* Next, exclude symbols starting with ... */
470 afptr
= autofilter_symbolprefixlist
;
473 if (strncmp (n
, afptr
->name
, afptr
->len
) == 0)
479 /* Finally, exclude symbols ending with ... */
481 afptr
= autofilter_symbolsuffixlist
;
484 if ((len
>= afptr
->len
) &&
485 /* Add 1 to insure match with trailing '\0'. */
486 strncmp (n
+ len
- afptr
->len
, afptr
->name
,
487 afptr
->len
+ 1) == 0)
494 for (ex
= excludes
; ex
; ex
= ex
->next
)
495 if (strcmp (n
, ex
->string
) == 0)
502 process_def_file (abfd
, info
)
503 bfd
*abfd ATTRIBUTE_UNUSED
;
504 struct bfd_link_info
*info
;
507 struct bfd_link_hash_entry
*blhe
;
510 def_file_export
*e
= 0;
513 pe_def_file
= def_file_empty ();
515 /* First, run around to all the objects looking for the .drectve
516 sections, and push those into the def file too. */
517 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
519 s
= bfd_get_section_by_name (b
, ".drectve");
522 int size
= bfd_get_section_size_before_reloc (s
);
523 char *buf
= xmalloc (size
);
525 bfd_get_section_contents (b
, s
, buf
, 0, size
);
526 def_file_add_directive (pe_def_file
, buf
, size
);
531 /* Now, maybe export everything else the default way. */
532 if (pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
534 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
539 symsize
= bfd_get_symtab_upper_bound (b
);
540 symbols
= (asymbol
**) xmalloc (symsize
);
541 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
543 for (j
= 0; j
< nsyms
; j
++)
545 /* We should export symbols which are either global or not
546 anything at all. (.bss data is the latter)
547 We should not export undefined symbols. */
548 if (symbols
[j
]->section
!= &bfd_und_section
549 && ((symbols
[j
]->flags
& BSF_GLOBAL
)
550 || (symbols
[j
]->flags
== BFD_FORT_COMM_DEFAULT_VALUE
)))
552 const char *sn
= symbols
[j
]->name
;
554 /* We should not re-export imported stuff. */
556 char *name
= (char *) xmalloc (strlen (sn
) + 2 + 6);
557 sprintf (name
, "%s%s", U("_imp_"), sn
);
559 blhe
= bfd_link_hash_lookup (info
->hash
, name
,
560 false, false, false);
563 if (blhe
&& blhe
->type
== bfd_link_hash_defined
)
570 if (auto_export (b
, pe_def_file
, sn
))
573 p
=def_file_add_export (pe_def_file
, sn
, 0, -1);
574 /* Fill data flag properly, from dlltool.c. */
575 p
->flag_data
= !(symbols
[j
]->flags
& BSF_FUNCTION
);
583 #define NE pe_def_file->num_exports
585 /* Canonicalize the export list. */
588 for (i
= 0; i
< NE
; i
++)
590 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
592 /* This will preserve internal_name, which may have been
593 pointing to the same memory as name, or might not
595 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
);
597 *(strchr (tmp
, '@')) = 0;
598 pe_def_file
->exports
[i
].name
= tmp
;
603 if (pe_dll_stdcall_aliases
)
605 for (i
= 0; i
< NE
; i
++)
607 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
609 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
);
611 *(strchr (tmp
, '@')) = 0;
612 if (auto_export (NULL
, pe_def_file
, tmp
))
613 def_file_add_export (pe_def_file
, tmp
,
614 pe_def_file
->exports
[i
].internal_name
,
622 /* Convenience, but watch out for it changing. */
623 e
= pe_def_file
->exports
;
625 exported_symbol_offsets
= (bfd_vma
*) xmalloc (NE
* sizeof (bfd_vma
));
626 exported_symbol_sections
= (struct sec
**) xmalloc (NE
* sizeof (struct sec
*));
628 memset (exported_symbol_sections
, 0, NE
* sizeof (struct sec
*));
632 count_exported_byname
= 0;
633 count_with_ordinals
= 0;
635 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]), pe_export_sort
);
636 for (i
= 0, j
= 0; i
< NE
; i
++)
638 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
640 /* This is a duplicate. */
641 if (e
[j
- 1].ordinal
!= -1
642 && e
[i
].ordinal
!= -1
643 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
645 if (pe_dll_warn_dup_exports
)
646 /* xgettext:c-format */
647 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
648 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
652 if (pe_dll_warn_dup_exports
)
653 /* xgettext:c-format */
654 einfo (_("Warning, duplicate EXPORT: %s\n"),
658 if (e
[i
].ordinal
!= -1)
659 e
[j
- 1].ordinal
= e
[i
].ordinal
;
660 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
661 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
662 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
663 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
672 pe_def_file
->num_exports
= j
; /* == NE */
674 for (i
= 0; i
< NE
; i
++)
676 char *name
= (char *) xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
678 if (pe_details
->underscored
)
681 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
684 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
686 blhe
= bfd_link_hash_lookup (info
->hash
,
691 && (blhe
->type
== bfd_link_hash_defined
692 || (blhe
->type
== bfd_link_hash_common
)))
695 if (!pe_def_file
->exports
[i
].flag_noname
)
696 count_exported_byname
++;
698 /* Only fill in the sections. The actual offsets are computed
699 in fill_exported_offsets() after common symbols are laid
701 if (blhe
->type
== bfd_link_hash_defined
)
702 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
704 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
706 if (pe_def_file
->exports
[i
].ordinal
!= -1)
708 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
709 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
710 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
711 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
712 count_with_ordinals
++;
715 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
717 /* xgettext:c-format */
718 einfo (_("%XCannot export %s: symbol not defined\n"),
719 pe_def_file
->exports
[i
].internal_name
);
723 /* xgettext:c-format */
724 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
725 pe_def_file
->exports
[i
].internal_name
,
726 blhe
->type
, bfd_link_hash_defined
);
730 /* xgettext:c-format */
731 einfo (_("%XCannot export %s: symbol not found\n"),
732 pe_def_file
->exports
[i
].internal_name
);
738 /* Build the bfd that will contain .edata and .reloc sections. */
741 build_filler_bfd (include_edata
)
744 lang_input_statement_type
*filler_file
;
745 filler_file
= lang_add_input_file ("dll stuff",
746 lang_input_file_is_fake_enum
,
748 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff", output_bfd
);
749 if (filler_bfd
== NULL
750 || !bfd_set_arch_mach (filler_bfd
,
751 bfd_get_arch (output_bfd
),
752 bfd_get_mach (output_bfd
)))
754 einfo ("%X%P: can not create BFD %E\n");
760 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
762 || !bfd_set_section_flags (filler_bfd
, edata_s
,
769 einfo ("%X%P: can not create .edata section: %E\n");
772 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
775 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
777 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
784 einfo ("%X%P: can not create .reloc section: %E\n");
788 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
790 ldlang_add_file (filler_file
);
793 /* Gather all the exported symbols and build the .edata section. */
796 generate_edata (abfd
, info
)
798 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
801 int name_table_size
= 0;
804 /* First, we need to know how many exported symbols there are,
805 and what the range of ordinals is. */
806 if (pe_def_file
->name
)
807 dll_name
= pe_def_file
->name
;
810 dll_name
= abfd
->filename
;
812 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
813 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
817 if (count_with_ordinals
&& max_ordinal
> count_exported
)
819 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
820 min_ordinal
= max_ordinal
- count_exported
+ 1;
825 max_ordinal
= count_exported
;
828 export_table_size
= max_ordinal
- min_ordinal
+ 1;
829 exported_symbols
= (int *) xmalloc (export_table_size
* sizeof (int));
830 for (i
= 0; i
< export_table_size
; i
++)
831 exported_symbols
[i
] = -1;
833 /* Now we need to assign ordinals to those that don't have them. */
834 for (i
= 0; i
< NE
; i
++)
836 if (exported_symbol_sections
[i
])
838 if (pe_def_file
->exports
[i
].ordinal
!= -1)
840 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
841 int pi
= exported_symbols
[ei
];
845 /* xgettext:c-format */
846 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
847 pe_def_file
->exports
[i
].ordinal
,
848 pe_def_file
->exports
[i
].name
,
849 pe_def_file
->exports
[pi
].name
);
851 exported_symbols
[ei
] = i
;
853 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
857 next_ordinal
= min_ordinal
;
858 for (i
= 0; i
< NE
; i
++)
859 if (exported_symbol_sections
[i
])
860 if (pe_def_file
->exports
[i
].ordinal
== -1)
862 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
865 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
866 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
869 /* OK, now we can allocate some memory. */
870 edata_sz
= (40 /* directory */
871 + 4 * export_table_size
/* addresses */
872 + 4 * count_exported_byname
/* name ptrs */
873 + 2 * count_exported_byname
/* ordinals */
874 + name_table_size
+ strlen (dll_name
) + 1);
877 /* Fill the exported symbol offsets. The preliminary work has already
878 been done in process_def_file(). */
881 fill_exported_offsets (abfd
, info
)
882 bfd
*abfd ATTRIBUTE_UNUSED
;
883 struct bfd_link_info
*info
;
886 struct bfd_link_hash_entry
*blhe
;
888 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
890 char *name
= (char *) xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
892 if (pe_details
->underscored
)
895 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
898 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
900 blhe
= bfd_link_hash_lookup (info
->hash
,
904 if (blhe
&& (blhe
->type
== bfd_link_hash_defined
))
905 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
912 fill_edata (abfd
, info
)
914 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
917 unsigned char *edirectory
;
918 unsigned long *eaddresses
;
919 unsigned long *enameptrs
;
920 unsigned short *eordinals
;
921 unsigned char *enamestr
;
926 edata_d
= (unsigned char *) xmalloc (edata_sz
);
928 /* Note use of array pointer math here. */
929 edirectory
= edata_d
;
930 eaddresses
= (unsigned long *) (edata_d
+ 40);
931 enameptrs
= eaddresses
+ export_table_size
;
932 eordinals
= (unsigned short *) (enameptrs
+ count_exported_byname
);
933 enamestr
= (char *) (eordinals
+ count_exported_byname
);
935 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
937 memset (edata_d
, 0, edata_sz
);
938 bfd_put_32 (abfd
, now
, edata_d
+ 4);
939 if (pe_def_file
->version_major
!= -1)
941 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
942 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
945 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
946 strcpy (enamestr
, dll_name
);
947 enamestr
+= strlen (enamestr
) + 1;
948 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
949 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
950 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
951 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
952 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
953 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
955 fill_exported_offsets (abfd
, info
);
957 /* Ok, now for the filling in part. */
959 for (i
= 0; i
< export_table_size
; i
++)
961 int s
= exported_symbols
[i
];
965 struct sec
*ssec
= exported_symbol_sections
[s
];
966 unsigned long srva
= (exported_symbol_offsets
[s
]
967 + ssec
->output_section
->vma
968 + ssec
->output_offset
);
969 int ord
= pe_def_file
->exports
[s
].ordinal
;
971 bfd_put_32 (abfd
, srva
- image_base
,
972 (void *) (eaddresses
+ ord
- min_ordinal
));
974 if (!pe_def_file
->exports
[s
].flag_noname
)
976 char *ename
= pe_def_file
->exports
[s
].name
;
977 bfd_put_32 (abfd
, ERVA (enamestr
), (void *) enameptrs
);
979 strcpy (enamestr
, ename
);
980 enamestr
+= strlen (enamestr
) + 1;
981 bfd_put_16 (abfd
, ord
- min_ordinal
, (void *) eordinals
);
983 pe_def_file
->exports
[s
].hint
= hint
++;
990 static struct sec
*current_sec
;
993 pe_walk_relocs_of_symbol (info
, name
, cb
)
994 struct bfd_link_info
*info
;
996 int (*cb
) (arelent
*, asection
*);
1001 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1006 symsize
= bfd_get_symtab_upper_bound (b
);
1007 symbols
= (asymbol
**) xmalloc (symsize
);
1008 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1010 for (s
= b
->sections
; s
; s
= s
->next
)
1013 int relsize
, nrelocs
, i
;
1014 int flags
= bfd_get_section_flags (b
, s
);
1016 /* Skip discarded linkonce sections. */
1017 if (flags
& SEC_LINK_ONCE
1018 && s
->output_section
== bfd_abs_section_ptr
)
1023 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1024 relocs
= (arelent
**) xmalloc ((size_t) relsize
);
1025 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1027 for (i
= 0; i
< nrelocs
; i
++)
1029 struct symbol_cache_entry
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1031 if (!strcmp (name
, sym
->name
))
1037 /* Warning: the allocated symbols are remembered in BFD and reused
1038 later, so don't free them! */
1039 /* free (symbols); */
1044 /* Gather all the relocations and build the .reloc section. */
1047 generate_reloc (abfd
, info
)
1049 struct bfd_link_info
*info
;
1052 /* For .reloc stuff. */
1053 reloc_data_type
*reloc_data
;
1054 int total_relocs
= 0;
1056 unsigned long sec_page
= (unsigned long) (-1);
1057 unsigned long page_ptr
, page_count
;
1063 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1064 for (s
= b
->sections
; s
; s
= s
->next
)
1065 total_relocs
+= s
->reloc_count
;
1068 (reloc_data_type
*) xmalloc (total_relocs
* sizeof (reloc_data_type
));
1072 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
1075 int relsize
, nrelocs
, i
;
1077 for (s
= b
->sections
; s
; s
= s
->next
)
1079 unsigned long sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
1083 /* If it's not loaded, we don't need to relocate it this way. */
1084 if (!(s
->output_section
->flags
& SEC_LOAD
))
1087 /* I don't know why there would be a reloc for these, but I've
1088 seen it happen - DJ */
1089 if (s
->output_section
== &bfd_abs_section
)
1092 if (s
->output_section
->vma
== 0)
1094 /* Huh? Shouldn't happen, but punt if it does. */
1095 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1096 s
->output_section
->name
, s
->output_section
->index
,
1097 s
->output_section
->flags
);
1101 symsize
= bfd_get_symtab_upper_bound (b
);
1102 symbols
= (asymbol
**) xmalloc (symsize
);
1103 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
1105 relsize
= bfd_get_reloc_upper_bound (b
, s
);
1106 relocs
= (arelent
**) xmalloc ((size_t) relsize
);
1107 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
1109 for (i
= 0; i
< nrelocs
; i
++)
1111 if (pe_dll_extra_pe_debug
)
1113 struct symbol_cache_entry
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1114 printf("rel: %s\n",sym
->name
);
1116 if (!relocs
[i
]->howto
->pc_relative
1117 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
1120 struct symbol_cache_entry
*sym
= *relocs
[i
]->sym_ptr_ptr
;
1122 sym_vma
= (relocs
[i
]->addend
1125 + sym
->section
->output_offset
1126 + sym
->section
->output_section
->vma
);
1127 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
1129 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1131 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
1132 relocs
[i
]->howto
->rightshift
)
1134 case BITS_AND_SHIFT (32, 0):
1135 reloc_data
[total_relocs
].type
= 3;
1138 case BITS_AND_SHIFT (16, 0):
1139 reloc_data
[total_relocs
].type
= 2;
1142 case BITS_AND_SHIFT (16, 16):
1143 reloc_data
[total_relocs
].type
= 4;
1144 /* FIXME: we can't know the symbol's right value
1145 yet, but we probably can safely assume that
1146 CE will relocate us in 64k blocks, so leaving
1148 reloc_data
[total_relocs
].extra
= 0;
1151 case BITS_AND_SHIFT (26, 2):
1152 reloc_data
[total_relocs
].type
= 5;
1156 /* xgettext:c-format */
1157 einfo (_("%XError: %d-bit reloc in dll\n"),
1158 relocs
[i
]->howto
->bitsize
);
1164 /* Warning: the allocated symbols are remembered in BFD and
1165 reused later, so don't free them! */
1172 /* At this point, we have total_relocs relocation addresses in
1173 reloc_addresses, which are all suitable for the .reloc section.
1174 We must now create the new sections. */
1175 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
1177 for (i
= 0; i
< total_relocs
; i
++)
1179 unsigned long this_page
= (reloc_data
[i
].vma
>> 12);
1181 if (this_page
!= sec_page
)
1183 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1185 sec_page
= this_page
;
1190 if (reloc_data
[i
].type
== 4)
1194 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align. */
1195 reloc_d
= (unsigned char *) xmalloc (reloc_sz
);
1196 sec_page
= (unsigned long) (-1);
1198 page_ptr
= (unsigned long) (-1);
1201 for (i
= 0; i
< total_relocs
; i
++)
1203 unsigned long rva
= reloc_data
[i
].vma
- image_base
;
1204 unsigned long this_page
= (rva
& ~0xfff);
1206 if (this_page
!= sec_page
)
1208 while (reloc_sz
& 3)
1209 reloc_d
[reloc_sz
++] = 0;
1211 if (page_ptr
!= (unsigned long) (-1))
1212 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1214 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
1215 page_ptr
= reloc_sz
;
1217 sec_page
= this_page
;
1221 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<< 12),
1222 reloc_d
+ reloc_sz
);
1225 if (reloc_data
[i
].type
== 4)
1227 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
1234 while (reloc_sz
& 3)
1235 reloc_d
[reloc_sz
++] = 0;
1237 if (page_ptr
!= (unsigned long) (-1))
1238 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
1240 while (reloc_sz
< reloc_s
->_raw_size
)
1241 reloc_d
[reloc_sz
++] = 0;
1244 /* Given the exiting def_file structure, print out a .DEF file that
1245 corresponds to it. */
1248 quoteput (s
, f
, needs_quotes
)
1255 for (cp
= s
; *cp
; cp
++)
1270 if (*s
== '"' || *s
== '\\')
1284 pe_dll_generate_def_file (pe_out_def_filename
)
1285 const char *pe_out_def_filename
;
1288 FILE *out
= fopen (pe_out_def_filename
, "w");
1291 /* xgettext:c-format */
1292 einfo (_("%s: Can't open output def file %s\n"),
1293 program_name
, pe_out_def_filename
);
1297 if (pe_def_file
->name
)
1299 if (pe_def_file
->is_dll
)
1300 fprintf (out
, "LIBRARY ");
1302 fprintf (out
, "NAME ");
1304 quoteput (pe_def_file
->name
, out
, 1);
1306 if (pe_data (output_bfd
)->pe_opthdr
.ImageBase
)
1307 fprintf (out
, " BASE=0x%lx",
1308 (unsigned long) pe_data (output_bfd
)->pe_opthdr
.ImageBase
);
1309 fprintf (out
, "\n");
1312 if (pe_def_file
->description
)
1314 fprintf (out
, "DESCRIPTION ");
1315 quoteput (pe_def_file
->description
, out
, 1);
1316 fprintf (out
, "\n");
1319 if (pe_def_file
->version_minor
!= -1)
1320 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
1321 pe_def_file
->version_minor
);
1322 else if (pe_def_file
->version_major
!= -1)
1323 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
1325 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
1326 fprintf (out
, "\n");
1328 if (pe_def_file
->stack_commit
!= -1)
1329 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
1330 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
1331 else if (pe_def_file
->stack_reserve
!= -1)
1332 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
1334 if (pe_def_file
->heap_commit
!= -1)
1335 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
1336 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
1337 else if (pe_def_file
->heap_reserve
!= -1)
1338 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1340 if (pe_def_file
->num_section_defs
> 0)
1342 fprintf (out
, "\nSECTIONS\n\n");
1344 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1347 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1349 if (pe_def_file
->section_defs
[i
].class)
1351 fprintf (out
, " CLASS ");
1352 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1355 if (pe_def_file
->section_defs
[i
].flag_read
)
1356 fprintf (out
, " READ");
1358 if (pe_def_file
->section_defs
[i
].flag_write
)
1359 fprintf (out
, " WRITE");
1361 if (pe_def_file
->section_defs
[i
].flag_execute
)
1362 fprintf (out
, " EXECUTE");
1364 if (pe_def_file
->section_defs
[i
].flag_shared
)
1365 fprintf (out
, " SHARED");
1367 fprintf (out
, "\n");
1371 if (pe_def_file
->num_exports
> 0)
1373 fprintf (out
, "EXPORTS\n");
1375 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1377 def_file_export
*e
= pe_def_file
->exports
+ i
;
1379 quoteput (e
->name
, out
, 0);
1381 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1383 fprintf (out
, " = ");
1384 quoteput (e
->internal_name
, out
, 0);
1387 if (e
->ordinal
!= -1)
1388 fprintf (out
, " @%d", e
->ordinal
);
1390 if (e
->flag_private
)
1391 fprintf (out
, " PRIVATE");
1393 if (e
->flag_constant
)
1394 fprintf (out
, " CONSTANT");
1397 fprintf (out
, " NONAME");
1400 fprintf (out
, " DATA");
1402 fprintf (out
, "\n");
1406 if (pe_def_file
->num_imports
> 0)
1408 fprintf (out
, "\nIMPORTS\n\n");
1410 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1412 def_file_import
*im
= pe_def_file
->imports
+ i
;
1415 if (im
->internal_name
1416 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1418 quoteput (im
->internal_name
, out
, 0);
1419 fprintf (out
, " = ");
1422 quoteput (im
->module
->name
, out
, 0);
1426 quoteput (im
->name
, out
, 0);
1428 fprintf (out
, "%d", im
->ordinal
);
1430 fprintf (out
, "\n");
1435 fprintf (out
, _("; no contents available\n"));
1437 if (fclose (out
) == EOF
)
1438 /* xgettext:c-format */
1439 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1442 /* Generate the import library. */
1444 static asymbol
**symtab
;
1447 static const char *dll_filename
;
1448 static char *dll_symname
;
1450 #define UNDSEC (asection *) &bfd_und_section
1453 quick_section (abfd
, name
, flags
, align
)
1462 sec
= bfd_make_section_old_way (abfd
, name
);
1463 bfd_set_section_flags (abfd
, sec
, flags
| SEC_ALLOC
| SEC_LOAD
| SEC_KEEP
);
1464 bfd_set_section_alignment (abfd
, sec
, align
);
1465 /* Remember to undo this before trying to link internally! */
1466 sec
->output_section
= sec
;
1468 sym
= bfd_make_empty_symbol (abfd
);
1469 symtab
[symptr
++] = sym
;
1470 sym
->name
= sec
->name
;
1472 sym
->flags
= BSF_LOCAL
;
1479 quick_symbol (abfd
, n1
, n2
, n3
, sec
, flags
, addr
)
1489 char *name
= (char *) xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1494 sym
= bfd_make_empty_symbol (abfd
);
1499 symtab
[symptr
++] = sym
;
1502 static arelent
*reltab
= 0;
1503 static int relcount
= 0, relsize
= 0;
1506 quick_reloc (abfd
, address
, which_howto
, symidx
)
1512 if (relcount
>= (relsize
- 1))
1516 reltab
= (arelent
*) xrealloc (reltab
, relsize
* sizeof (arelent
));
1518 reltab
= (arelent
*) xmalloc (relsize
* sizeof (arelent
));
1520 reltab
[relcount
].address
= address
;
1521 reltab
[relcount
].addend
= 0;
1522 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1523 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1528 save_relocs (asection
*sec
)
1532 sec
->relocation
= reltab
;
1533 sec
->reloc_count
= relcount
;
1534 sec
->orelocation
= (arelent
**) xmalloc ((relcount
+ 1) * sizeof (arelent
*));
1535 for (i
= 0; i
< relcount
; i
++)
1536 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1537 sec
->orelocation
[relcount
] = 0;
1538 sec
->flags
|= SEC_RELOC
;
1540 relcount
= relsize
= 0;
1543 /* .section .idata$2
1544 .global __head_my_dll
1564 asection
*id2
, *id5
, *id4
;
1565 unsigned char *d2
, *d5
, *d4
;
1569 oname
= (char *) 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
= (asymbol
**) 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);
1595 d2
= (unsigned char *) xmalloc (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);
1605 d5
= (unsigned char *) xmalloc (4);
1609 bfd_set_section_size (abfd
, id4
, 4);
1610 d4
= (unsigned char *) xmalloc (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
1637 asection
*id4
, *id5
, *id7
;
1638 unsigned char *d4
, *d5
, *d7
;
1643 oname
= (char *) xmalloc (20);
1644 sprintf (oname
, "d%06d.o", tmp_seq
);
1647 abfd
= bfd_create (oname
, parent
);
1648 bfd_find_target (pe_details
->object_target
, abfd
);
1649 bfd_make_writable (abfd
);
1651 bfd_set_format (abfd
, bfd_object
);
1652 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1655 symtab
= (asymbol
**) xmalloc (5 * sizeof (asymbol
*));
1656 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1657 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1658 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1659 quick_symbol (abfd
, U (""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1661 bfd_set_section_size (abfd
, id4
, 4);
1662 d4
= (unsigned char *) xmalloc (4);
1666 bfd_set_section_size (abfd
, id5
, 4);
1667 d5
= (unsigned char *) xmalloc (4);
1671 len
= strlen (dll_filename
) + 1;
1674 bfd_set_section_size (abfd
, id7
, len
);
1675 d7
= (unsigned char *) xmalloc (len
);
1677 strcpy (d7
, dll_filename
);
1679 bfd_set_symtab (abfd
, symtab
, symptr
);
1681 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1682 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1683 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1685 bfd_make_readable (abfd
);
1691 .global ___imp_function
1692 .global __imp__function
1694 jmp *__imp__function:
1708 .asciz "function" xlate? (add underscore, kill at) */
1710 static unsigned char jmp_ix86_bytes
[] =
1712 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1720 .dw __imp_function */
1722 static unsigned char jmp_sh_bytes
[] =
1724 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1728 lui $t0,<high:__imp_function>
1729 lw $t0,<low:__imp_function>
1733 static unsigned char jmp_mips_bytes
[] =
1735 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1736 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1740 make_one (exp
, parent
)
1741 def_file_export
*exp
;
1744 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1745 unsigned char *td
= NULL
, *d7
, *d5
, *d4
, *d6
= NULL
;
1749 unsigned char *jmp_bytes
= NULL
;
1750 int jmp_byte_count
= 0;
1752 switch (pe_details
->pe_arch
)
1755 jmp_bytes
= jmp_ix86_bytes
;
1756 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1759 jmp_bytes
= jmp_sh_bytes
;
1760 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1763 jmp_bytes
= jmp_mips_bytes
;
1764 jmp_byte_count
= sizeof (jmp_mips_bytes
);
1770 oname
= (char *) xmalloc (20);
1771 sprintf (oname
, "d%06d.o", tmp_seq
);
1774 abfd
= bfd_create (oname
, parent
);
1775 bfd_find_target (pe_details
->object_target
, abfd
);
1776 bfd_make_writable (abfd
);
1778 bfd_set_format (abfd
, bfd_object
);
1779 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1782 symtab
= (asymbol
**) xmalloc (11 * sizeof (asymbol
*));
1783 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1784 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1785 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1786 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1787 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1788 if (! exp
->flag_data
)
1789 quick_symbol (abfd
, U (""), exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1790 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", UNDSEC
, BSF_GLOBAL
, 0);
1791 quick_symbol (abfd
, U ("_imp__"), exp
->internal_name
, "", id5
, BSF_GLOBAL
, 0);
1792 /* Symbol to reference ord/name of imported
1793 symbol, used to implement auto-import. */
1794 quick_symbol (abfd
, U("_nm__"), exp
->internal_name
, "", id6
, BSF_GLOBAL
, 0);
1795 if (pe_dll_compat_implib
)
1796 quick_symbol (abfd
, U ("__imp_"), exp
->internal_name
, "",
1797 id5
, BSF_GLOBAL
, 0);
1799 if (! exp
->flag_data
)
1801 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
1802 td
= (unsigned char *) xmalloc (jmp_byte_count
);
1804 memcpy (td
, jmp_bytes
, jmp_byte_count
);
1806 switch (pe_details
->pe_arch
)
1809 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
1812 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
1815 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
1816 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
1817 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
1825 bfd_set_section_size (abfd
, id7
, 4);
1826 d7
= (unsigned char *) xmalloc (4);
1829 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 6);
1832 bfd_set_section_size (abfd
, id5
, 4);
1833 d5
= (unsigned char *) xmalloc (4);
1837 if (exp
->flag_noname
)
1839 d5
[0] = exp
->ordinal
;
1840 d5
[1] = exp
->ordinal
>> 8;
1845 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1849 bfd_set_section_size (abfd
, id4
, 4);
1850 d4
= (unsigned char *) xmalloc (4);
1854 if (exp
->flag_noname
)
1856 d4
[0] = exp
->ordinal
;
1857 d4
[1] = exp
->ordinal
>> 8;
1862 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1866 if (exp
->flag_noname
)
1869 bfd_set_section_size (abfd
, id6
, 0);
1873 len
= strlen (exp
->name
) + 3;
1876 bfd_set_section_size (abfd
, id6
, len
);
1877 d6
= (unsigned char *) xmalloc (len
);
1879 memset (d6
, 0, len
);
1880 d6
[0] = exp
->hint
& 0xff;
1881 d6
[1] = exp
->hint
>> 8;
1882 strcpy (d6
+ 2, exp
->name
);
1885 bfd_set_symtab (abfd
, symtab
, symptr
);
1887 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
1888 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
1889 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1890 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1891 if (!exp
->flag_noname
)
1892 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
1894 bfd_make_readable (abfd
);
1899 make_singleton_name_thunk (import
, parent
)
1903 /* Name thunks go to idata$4. */
1909 oname
= (char *) xmalloc (20);
1910 sprintf (oname
, "nmth%06d.o", tmp_seq
);
1913 abfd
= bfd_create (oname
, parent
);
1914 bfd_find_target (pe_details
->object_target
, abfd
);
1915 bfd_make_writable (abfd
);
1917 bfd_set_format (abfd
, bfd_object
);
1918 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1921 symtab
= (asymbol
**) xmalloc (3 * sizeof (asymbol
*));
1922 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1923 quick_symbol (abfd
, U ("_nm_thnk_"), import
, "", id4
, BSF_GLOBAL
, 0);
1924 quick_symbol (abfd
, U ("_nm_"), import
, "", UNDSEC
, BSF_GLOBAL
, 0);
1926 bfd_set_section_size (abfd
, id4
, 8);
1927 d4
= (unsigned char *) xmalloc (4);
1930 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1933 bfd_set_symtab (abfd
, symtab
, symptr
);
1935 bfd_set_section_contents (abfd
, id4
, d4
, 0, 8);
1937 bfd_make_readable (abfd
);
1942 make_import_fixup_mark (rel
)
1945 /* We convert reloc to symbol, for later reference. */
1947 static char *fixup_name
= NULL
;
1948 static size_t buffer_len
= 0;
1950 struct symbol_cache_entry
*sym
= *rel
->sym_ptr_ptr
;
1952 bfd
*abfd
= bfd_asymbol_bfd (sym
);
1953 struct coff_link_hash_entry
*myh
= NULL
;
1957 fixup_name
= (char *) xmalloc (384);
1961 if (strlen (sym
->name
) + 25 > buffer_len
)
1962 /* Assume 25 chars for "__fu" + counter + "_". If counter is
1963 bigger than 20 digits long, we've got worse problems than
1964 overflowing this buffer... */
1967 /* New buffer size is length of symbol, plus 25, but then
1968 rounded up to the nearest multiple of 128. */
1969 buffer_len
= ((strlen (sym
->name
) + 25) + 127) & ~127;
1970 fixup_name
= (char *) xmalloc (buffer_len
);
1973 sprintf (fixup_name
, "__fu%d_%s", counter
++, sym
->name
);
1975 bfd_coff_link_add_one_symbol (&link_info
, abfd
, fixup_name
, BSF_GLOBAL
,
1976 current_sec
, /* sym->section, */
1977 rel
->address
, NULL
, true, false,
1978 (struct bfd_link_hash_entry
**) &myh
);
1981 printf ("type:%d\n", myh
->type
);
1982 printf ("%s\n", myh
->root
.u
.def
.section
->name
);
1987 /* .section .idata$3
1988 .rva __nm_thnk_SYM (singleton thunk with name of func)
1991 .rva __my_dll_iname (name of dll)
1992 .rva __fuNN_SYM (pointer to reference (address) in text) */
1995 make_import_fixup_entry (name
, fixup_name
, dll_symname
,parent
)
1997 const char *fixup_name
;
1998 const char *dll_symname
;
2006 oname
= (char *) xmalloc (20);
2007 sprintf (oname
, "fu%06d.o", tmp_seq
);
2010 abfd
= bfd_create (oname
, parent
);
2011 bfd_find_target (pe_details
->object_target
, abfd
);
2012 bfd_make_writable (abfd
);
2014 bfd_set_format (abfd
, bfd_object
);
2015 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
2018 symtab
= (asymbol
**) xmalloc (6 * sizeof (asymbol
*));
2019 id3
= quick_section (abfd
, ".idata$3", SEC_HAS_CONTENTS
, 2);
2022 quick_symbol (abfd
, U ("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
2024 quick_symbol (abfd
, U ("_nm_thnk_"), name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2025 quick_symbol (abfd
, U (""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
2026 quick_symbol (abfd
, "", fixup_name
, "", UNDSEC
, BSF_GLOBAL
, 0);
2028 bfd_set_section_size (abfd
, id3
, 20);
2029 d3
= (unsigned char *) xmalloc (20);
2033 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 1);
2034 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 2);
2035 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 3);
2038 bfd_set_symtab (abfd
, symtab
, symptr
);
2040 bfd_set_section_contents (abfd
, id3
, d3
, 0, 20);
2042 bfd_make_readable (abfd
);
2047 pe_create_import_fixup (rel
)
2051 struct symbol_cache_entry
*sym
= *rel
->sym_ptr_ptr
;
2052 struct bfd_link_hash_entry
*name_thunk_sym
;
2053 const char *name
= sym
->name
;
2054 char *fixup_name
= make_import_fixup_mark (rel
);
2056 sprintf (buf
, U ("_nm_thnk_%s"), name
);
2058 name_thunk_sym
= bfd_link_hash_lookup (link_info
.hash
, buf
, 0, 0, 1);
2060 if (!name_thunk_sym
|| name_thunk_sym
->type
!= bfd_link_hash_defined
)
2062 bfd
*b
= make_singleton_name_thunk (name
, output_bfd
);
2063 add_bfd_to_link (b
, b
->filename
, &link_info
);
2065 /* If we ever use autoimport, we have to cast text section writable. */
2066 config
.text_read_only
= false;
2070 extern char * pe_data_import_dll
;
2071 char * dll_symname
= pe_data_import_dll
? pe_data_import_dll
: "unknown";
2073 bfd
*b
= make_import_fixup_entry (name
, fixup_name
, dll_symname
,
2075 add_bfd_to_link (b
, b
->filename
, &link_info
);
2081 pe_dll_generate_implib (def
, impfilename
)
2083 const char *impfilename
;
2091 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
2092 dll_symname
= xstrdup (dll_filename
);
2093 for (i
= 0; dll_symname
[i
]; i
++)
2094 if (!ISALNUM (dll_symname
[i
]))
2095 dll_symname
[i
] = '_';
2097 unlink (impfilename
);
2099 outarch
= bfd_openw (impfilename
, 0);
2103 /* xgettext:c-format */
2104 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
2108 /* xgettext:c-format */
2109 einfo (_("Creating library file: %s\n"), impfilename
);
2111 bfd_set_format (outarch
, bfd_archive
);
2112 outarch
->has_armap
= 1;
2114 /* Work out a reasonable size of things to put onto one line. */
2115 ar_head
= make_head (outarch
);
2117 for (i
= 0; i
< def
->num_exports
; i
++)
2119 /* The import library doesn't know about the internal name. */
2120 char *internal
= def
->exports
[i
].internal_name
;
2123 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
2124 n
= make_one (def
->exports
+ i
, outarch
);
2127 def
->exports
[i
].internal_name
= internal
;
2130 ar_tail
= make_tail (outarch
);
2132 if (ar_head
== NULL
|| ar_tail
== NULL
)
2135 /* Now stick them all into the archive. */
2136 ar_head
->next
= head
;
2137 ar_tail
->next
= ar_head
;
2140 if (! bfd_set_archive_head (outarch
, head
))
2141 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
2143 if (! bfd_close (outarch
))
2144 einfo ("%Xbfd_close %s: %s\n", impfilename
, bfd_errmsg (bfd_get_error ()));
2146 while (head
!= NULL
)
2148 bfd
*n
= head
->next
;
2155 add_bfd_to_link (abfd
, name
, link_info
)
2158 struct bfd_link_info
*link_info
;
2160 lang_input_statement_type
*fake_file
;
2162 fake_file
= lang_add_input_file (name
,
2163 lang_input_file_is_fake_enum
,
2165 fake_file
->the_bfd
= abfd
;
2166 ldlang_add_file (fake_file
);
2168 if (!bfd_link_add_symbols (abfd
, link_info
))
2169 einfo ("%Xaddsym %s: %s\n", name
, bfd_errmsg (bfd_get_error ()));
2173 pe_process_import_defs (output_bfd
, link_info
)
2175 struct bfd_link_info
*link_info
;
2177 def_file_module
*module
;
2179 pe_dll_id_target (bfd_get_target (output_bfd
));
2184 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
2188 dll_filename
= module
->name
;
2189 dll_symname
= xstrdup (module
->name
);
2190 for (i
= 0; dll_symname
[i
]; i
++)
2191 if (!ISALNUM (dll_symname
[i
]))
2192 dll_symname
[i
] = '_';
2196 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
2197 if (pe_def_file
->imports
[i
].module
== module
)
2199 def_file_export exp
;
2200 struct bfd_link_hash_entry
*blhe
;
2202 /* See if we need this import. */
2203 char *name
= (char *) xmalloc (strlen (pe_def_file
->imports
[i
].internal_name
) + 2 + 6);
2204 sprintf (name
, "%s%s", U (""), pe_def_file
->imports
[i
].internal_name
);
2205 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2206 false, false, false);
2207 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
2209 sprintf (name
, "%s%s", U ("_imp__"),
2210 pe_def_file
->imports
[i
].internal_name
);
2211 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
2212 false, false, false);
2215 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
2221 bfd
*ar_head
= make_head (output_bfd
);
2222 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
2225 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
2226 exp
.name
= pe_def_file
->imports
[i
].name
;
2227 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
2228 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
2229 exp
.flag_private
= 0;
2230 exp
.flag_constant
= 0;
2232 exp
.flag_noname
= exp
.name
? 0 : 1;
2233 one
= make_one (&exp
, output_bfd
);
2234 add_bfd_to_link (one
, one
->filename
, link_info
);
2239 bfd
*ar_tail
= make_tail (output_bfd
);
2240 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
2247 /* We were handed a *.DLL file. Parse it and turn it into a set of
2248 IMPORTS directives in the def file. Return true if the file was
2249 handled, false if not. */
2252 pe_get16 (abfd
, where
)
2258 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2259 bfd_bread (b
, (bfd_size_type
) 2, abfd
);
2260 return b
[0] + (b
[1] << 8);
2264 pe_get32 (abfd
, where
)
2270 bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
);
2271 bfd_bread (b
, (bfd_size_type
) 4, abfd
);
2272 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2275 #if 0 /* This is not currently used. */
2281 unsigned char *b
= ptr
;
2283 return b
[0] + (b
[1] << 8);
2292 unsigned char *b
= ptr
;
2294 return b
[0] + (b
[1] << 8) + (b
[2] << 16) + (b
[3] << 24);
2298 pe_implied_import_dll (filename
)
2299 const char *filename
;
2302 unsigned long pe_header_offset
, opthdr_ofs
, num_entries
, i
;
2303 unsigned long export_rva
, export_size
, nsections
, secptr
, expptr
;
2304 unsigned char *expdata
, *erva
;
2305 unsigned long name_rvas
, ordinals
, nexp
, ordbase
;
2306 const char *dll_name
;
2308 /* No, I can't use bfd here. kernel32.dll puts its export table in
2309 the middle of the .rdata section. */
2310 dll
= bfd_openr (filename
, pe_details
->target_name
);
2313 einfo ("%Xopen %s: %s\n", filename
, bfd_errmsg (bfd_get_error ()));
2317 /* PEI dlls seem to be bfd_objects. */
2318 if (!bfd_check_format (dll
, bfd_object
))
2320 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
2324 dll_name
= filename
;
2325 for (i
= 0; filename
[i
]; i
++)
2326 if (filename
[i
] == '/' || filename
[i
] == '\\' || filename
[i
] == ':')
2327 dll_name
= filename
+ i
+ 1;
2329 pe_header_offset
= pe_get32 (dll
, 0x3c);
2330 opthdr_ofs
= pe_header_offset
+ 4 + 20;
2331 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
2333 if (num_entries
< 1) /* No exports. */
2336 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
2337 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
2338 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
2339 secptr
= (pe_header_offset
+ 4 + 20 +
2340 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
2343 for (i
= 0; i
< nsections
; i
++)
2346 unsigned long secptr1
= secptr
+ 40 * i
;
2347 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
2348 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 16);
2349 unsigned long fptr
= pe_get32 (dll
, secptr1
+ 20);
2351 bfd_seek (dll
, (file_ptr
) secptr1
, SEEK_SET
);
2352 bfd_bread (sname
, (bfd_size_type
) 8, dll
);
2354 if (vaddr
<= export_rva
&& vaddr
+ vsize
> export_rva
)
2356 expptr
= fptr
+ (export_rva
- vaddr
);
2357 if (export_rva
+ export_size
> vaddr
+ vsize
)
2358 export_size
= vsize
- (export_rva
- vaddr
);
2363 expdata
= (unsigned char *) xmalloc (export_size
);
2364 bfd_seek (dll
, (file_ptr
) expptr
, SEEK_SET
);
2365 bfd_bread (expdata
, (bfd_size_type
) export_size
, dll
);
2366 erva
= expdata
- export_rva
;
2368 if (pe_def_file
== 0)
2369 pe_def_file
= def_file_empty ();
2371 nexp
= pe_as32 (expdata
+ 24);
2372 name_rvas
= pe_as32 (expdata
+ 32);
2373 ordinals
= pe_as32 (expdata
+ 36);
2374 ordbase
= pe_as32 (expdata
+ 16);
2376 for (i
= 0; i
< nexp
; i
++)
2378 unsigned long name_rva
= pe_as32 (erva
+ name_rvas
+ i
* 4);
2379 def_file_import
*imp
;
2381 imp
= def_file_add_import (pe_def_file
, erva
+ name_rva
, dll_name
,
2388 /* These are the main functions, called from the emulation. The first
2389 is called after the bfds are read, so we can guess at how much space
2390 we need. The second is called after everything is placed, so we
2391 can put the right values in place. */
2394 pe_dll_build_sections (abfd
, info
)
2396 struct bfd_link_info
*info
;
2398 pe_dll_id_target (bfd_get_target (abfd
));
2399 process_def_file (abfd
, info
);
2401 generate_edata (abfd
, info
);
2402 build_filler_bfd (1);
2406 pe_exe_build_sections (abfd
, info
)
2408 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2410 pe_dll_id_target (bfd_get_target (abfd
));
2411 build_filler_bfd (0);
2415 pe_dll_fill_sections (abfd
, info
)
2417 struct bfd_link_info
*info
;
2419 pe_dll_id_target (bfd_get_target (abfd
));
2420 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2422 generate_reloc (abfd
, info
);
2425 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2427 /* Resize the sections. */
2428 lang_size_sections (stat_ptr
->head
, abs_output_section
,
2429 &stat_ptr
->head
, 0, (bfd_vma
) 0, NULL
);
2431 /* Redo special stuff. */
2432 ldemul_after_allocation ();
2434 /* Do the assignments again. */
2435 lang_do_assignments (stat_ptr
->head
,
2437 (fill_type
) 0, (bfd_vma
) 0);
2440 fill_edata (abfd
, info
);
2442 pe_data (abfd
)->dll
= 1;
2444 edata_s
->contents
= edata_d
;
2445 reloc_s
->contents
= reloc_d
;
2449 pe_exe_fill_sections (abfd
, info
)
2451 struct bfd_link_info
*info
;
2453 pe_dll_id_target (bfd_get_target (abfd
));
2454 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
2456 generate_reloc (abfd
, info
);
2459 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
2461 /* Resize the sections. */
2462 lang_size_sections (stat_ptr
->head
, abs_output_section
,
2463 &stat_ptr
->head
, 0, (bfd_vma
) 0, NULL
);
2465 /* Redo special stuff. */
2466 ldemul_after_allocation ();
2468 /* Do the assignments again. */
2469 lang_do_assignments (stat_ptr
->head
,
2471 (fill_type
) 0, (bfd_vma
) 0);
2473 reloc_s
->contents
= reloc_d
;