* pe-dll.c (auto_export): Use bsearch to speed up scan of exports
[deliverable/binutils-gdb.git] / ld / pe-dll.c
... / ...
CommitLineData
1/* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 Written by DJ Delorie <dj@cygnus.com>
5
6 This file is part of the GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23#include "sysdep.h"
24#include "bfd.h"
25#include "bfdlink.h"
26#include "libiberty.h"
27#include "filenames.h"
28#include "safe-ctype.h"
29
30#include <time.h>
31
32#include "ld.h"
33#include "ldexp.h"
34#include "ldlang.h"
35#include "ldwrite.h"
36#include "ldmisc.h"
37#include <ldgram.h>
38#include "ldmain.h"
39#include "ldfile.h"
40#include "ldemul.h"
41#include "coff/internal.h"
42#include "../bfd/libcoff.h"
43#include "deffile.h"
44
45#ifdef pe_use_x86_64
46
47#define PE_IDATA4_SIZE 8
48#define PE_IDATA5_SIZE 8
49#include "pep-dll.h"
50#undef AOUTSZ
51#define AOUTSZ PEPAOUTSZ
52#define PEAOUTHDR PEPAOUTHDR
53
54#else
55
56#include "pe-dll.h"
57
58#endif
59
60#ifndef PE_IDATA4_SIZE
61#define PE_IDATA4_SIZE 4
62#endif
63
64#ifndef PE_IDATA5_SIZE
65#define PE_IDATA5_SIZE 4
66#endif
67
68/* This file turns a regular Windows PE image into a DLL. Because of
69 the complexity of this operation, it has been broken down into a
70 number of separate modules which are all called by the main function
71 at the end of this file. This function is not re-entrant and is
72 normally only called once, so static variables are used to reduce
73 the number of parameters and return values required.
74
75 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
76
77/* Auto-import feature by Paul Sokolovsky
78
79 Quick facts:
80
81 1. With this feature on, DLL clients can import variables from DLL
82 without any concern from their side (for example, without any source
83 code modifications).
84
85 2. This is done completely in bounds of the PE specification (to be fair,
86 there's a place where it pokes nose out of, but in practice it works).
87 So, resulting module can be used with any other PE compiler/linker.
88
89 3. Auto-import is fully compatible with standard import method and they
90 can be mixed together.
91
92 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
93 reference to it; load time: negligible; virtual/physical memory: should be
94 less than effect of DLL relocation, and I sincerely hope it doesn't affect
95 DLL sharability (too much).
96
97 Idea
98
99 The obvious and only way to get rid of dllimport insanity is to make client
100 access variable directly in the DLL, bypassing extra dereference. I.e.,
101 whenever client contains something like
102
103 mov dll_var,%eax,
104
105 address of dll_var in the command should be relocated to point into loaded
106 DLL. The aim is to make OS loader do so, and than make ld help with that.
107 Import section of PE made following way: there's a vector of structures
108 each describing imports from particular DLL. Each such structure points
109 to two other parallel vectors: one holding imported names, and one which
110 will hold address of corresponding imported name. So, the solution is
111 de-vectorize these structures, making import locations be sparse and
112 pointing directly into code. Before continuing, it is worth a note that,
113 while authors strives to make PE act ELF-like, there're some other people
114 make ELF act PE-like: elfvector, ;-) .
115
116 Implementation
117
118 For each reference of data symbol to be imported from DLL (to set of which
119 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
120 import fixup entry is generated. That entry is of type
121 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
122 fixup entry contains pointer to symbol's address within .text section
123 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
124 (so, DLL name is referenced by multiple entries), and pointer to symbol
125 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
126 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
127 containing imported name. Here comes that "on the edge" problem mentioned
128 above: PE specification rambles that name vector (OriginalFirstThunk)
129 should run in parallel with addresses vector (FirstThunk), i.e. that they
130 should have same number of elements and terminated with zero. We violate
131 this, since FirstThunk points directly into machine code. But in practice,
132 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
133 puts addresses to FirstThunk, not something else. It once again should be
134 noted that dll and symbol name structures are reused across fixup entries
135 and should be there anyway to support standard import stuff, so sustained
136 overhead is 20 bytes per reference. Other question is whether having several
137 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
138 done even by native compiler/linker (libth32's functions are in fact reside
139 in windows9x kernel32.dll, so if you use it, you have two
140 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
141 referencing the same PE structures several times is valid. The answer is why
142 not, prohibiting that (detecting violation) would require more work on
143 behalf of loader than not doing it.
144
145 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
146
147static void add_bfd_to_link (bfd *, const char *, struct bfd_link_info *);
148
149/* For emultempl/pe.em. */
150
151def_file * pe_def_file = 0;
152int pe_dll_export_everything = 0;
153int pe_dll_exclude_all_symbols = 0;
154int pe_dll_do_default_excludes = 1;
155int pe_dll_kill_ats = 0;
156int pe_dll_stdcall_aliases = 0;
157int pe_dll_warn_dup_exports = 0;
158int pe_dll_compat_implib = 0;
159int pe_dll_extra_pe_debug = 0;
160int pe_use_nul_prefixed_import_tables = 0;
161int pe_use_coff_long_section_names = -1;
162int pe_leading_underscore = -1;
163
164/* Static variables and types. */
165
166static bfd_vma image_base;
167static bfd *filler_bfd;
168static struct bfd_section *edata_s, *reloc_s;
169static unsigned char *edata_d, *reloc_d;
170static size_t edata_sz, reloc_sz;
171static int runtime_pseudo_relocs_created = 0;
172static int runtime_pseudp_reloc_v2_init = 0;
173
174typedef struct
175{
176 const char *name;
177 int len;
178}
179autofilter_entry_type;
180
181typedef struct
182{
183 const char *target_name;
184 const char *object_target;
185 unsigned int imagebase_reloc;
186 int pe_arch;
187 int bfd_arch;
188 bfd_boolean underscored;
189 const autofilter_entry_type* autofilter_symbollist;
190}
191pe_details_type;
192
193static const autofilter_entry_type autofilter_symbollist_generic[] =
194{
195 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
196 /* Entry point symbols. */
197 { STRING_COMMA_LEN ("DllMain") },
198 { STRING_COMMA_LEN ("DllMainCRTStartup") },
199 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
200 /* Runtime pseudo-reloc. */
201 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
202 { STRING_COMMA_LEN ("do_pseudo_reloc") },
203 { NULL, 0 }
204};
205
206static const autofilter_entry_type autofilter_symbollist_i386[] =
207{
208 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
209 /* Entry point symbols, and entry hooks. */
210 { STRING_COMMA_LEN ("cygwin_crt0") },
211#ifdef pe_use_x86_64
212 { STRING_COMMA_LEN ("DllMain") },
213 { STRING_COMMA_LEN ("DllEntryPoint") },
214 { STRING_COMMA_LEN ("DllMainCRTStartup") },
215 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
216 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
217 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
218#else
219 { STRING_COMMA_LEN ("DllMain@12") },
220 { STRING_COMMA_LEN ("DllEntryPoint@0") },
221 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
222 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
223 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
224 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
225 { STRING_COMMA_LEN ("cygwin_attach_dll") },
226#endif
227 { STRING_COMMA_LEN ("cygwin_premain0") },
228 { STRING_COMMA_LEN ("cygwin_premain1") },
229 { STRING_COMMA_LEN ("cygwin_premain2") },
230 { STRING_COMMA_LEN ("cygwin_premain3") },
231 /* Runtime pseudo-reloc. */
232 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
233 { STRING_COMMA_LEN ("do_pseudo_reloc") },
234 /* Global vars that should not be exported. */
235 { STRING_COMMA_LEN ("impure_ptr") },
236 { STRING_COMMA_LEN ("_impure_ptr") },
237 { STRING_COMMA_LEN ("_fmode") },
238 { STRING_COMMA_LEN ("environ") },
239 { NULL, 0 }
240};
241
242#define PE_ARCH_i386 1
243#define PE_ARCH_sh 2
244#define PE_ARCH_mips 3
245#define PE_ARCH_arm 4
246#define PE_ARCH_arm_epoc 5
247#define PE_ARCH_arm_wince 6
248
249/* Don't make it constant as underscore mode gets possibly overriden
250 by target or -(no-)leading-underscore option. */
251static pe_details_type pe_detail_list[] =
252{
253 {
254#ifdef pe_use_x86_64
255 "pei-x86-64",
256 "pe-x86-64",
257 3 /* R_IMAGEBASE */,
258#else
259 "pei-i386",
260 "pe-i386",
261 7 /* R_IMAGEBASE */,
262#endif
263 PE_ARCH_i386,
264 bfd_arch_i386,
265#ifdef pe_use_x86_64
266 FALSE,
267#else
268 TRUE,
269#endif
270 autofilter_symbollist_i386
271 },
272 {
273 "pei-shl",
274 "pe-shl",
275 16 /* R_SH_IMAGEBASE */,
276 PE_ARCH_sh,
277 bfd_arch_sh,
278 TRUE,
279 autofilter_symbollist_generic
280 },
281 {
282 "pei-mips",
283 "pe-mips",
284 34 /* MIPS_R_RVA */,
285 PE_ARCH_mips,
286 bfd_arch_mips,
287 FALSE,
288 autofilter_symbollist_generic
289 },
290 {
291 "pei-arm-little",
292 "pe-arm-little",
293 11 /* ARM_RVA32 */,
294 PE_ARCH_arm,
295 bfd_arch_arm,
296 TRUE,
297 autofilter_symbollist_generic
298 },
299 {
300 "epoc-pei-arm-little",
301 "epoc-pe-arm-little",
302 11 /* ARM_RVA32 */,
303 PE_ARCH_arm_epoc,
304 bfd_arch_arm,
305 FALSE,
306 autofilter_symbollist_generic
307 },
308 {
309 "pei-arm-wince-little",
310 "pe-arm-wince-little",
311 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
312 PE_ARCH_arm_wince,
313 bfd_arch_arm,
314 FALSE,
315 autofilter_symbollist_generic
316 },
317 { NULL, NULL, 0, 0, 0, FALSE, NULL }
318};
319
320static const pe_details_type *pe_details;
321
322/* Do not specify library suffix explicitly, to allow for dllized versions. */
323static const autofilter_entry_type autofilter_liblist[] =
324{
325 { STRING_COMMA_LEN ("libcegcc") },
326 { STRING_COMMA_LEN ("libcygwin") },
327 { STRING_COMMA_LEN ("libgcc") },
328 { STRING_COMMA_LEN ("libgcc_s") },
329 { STRING_COMMA_LEN ("libstdc++") },
330 { STRING_COMMA_LEN ("libmingw32") },
331 { STRING_COMMA_LEN ("libmingwex") },
332 { STRING_COMMA_LEN ("libg2c") },
333 { STRING_COMMA_LEN ("libsupc++") },
334 { STRING_COMMA_LEN ("libobjc") },
335 { STRING_COMMA_LEN ("libgcj") },
336 { NULL, 0 }
337};
338
339/* Regardless of the suffix issue mentioned above, we must ensure that
340 we do not falsely match on a leading substring, such as when libtool
341 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
342 This routine ensures that the leading part of the name matches and that
343 it is followed by only an optional version suffix and a file extension,
344 returning zero if so or -1 if not. */
345static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
346{
347 if (filename_ncmp (libname, afptr->name, afptr->len))
348 return -1;
349
350 libname += afptr->len;
351
352 /* Be liberal in interpreting what counts as a version suffix; we
353 accept anything that has a dash to separate it from the name and
354 begins with a digit. */
355 if (libname[0] == '-')
356 {
357 if (!ISDIGIT (*++libname))
358 return -1;
359 /* Ensure the filename has an extension. */
360 while (*++libname != '.')
361 if (!*libname)
362 return -1;
363 }
364 else if (libname[0] != '.')
365 return -1;
366
367 return 0;
368}
369
370static const autofilter_entry_type autofilter_objlist[] =
371{
372 { STRING_COMMA_LEN ("crt0.o") },
373 { STRING_COMMA_LEN ("crt1.o") },
374 { STRING_COMMA_LEN ("crt2.o") },
375 { STRING_COMMA_LEN ("dllcrt1.o") },
376 { STRING_COMMA_LEN ("dllcrt2.o") },
377 { STRING_COMMA_LEN ("gcrt0.o") },
378 { STRING_COMMA_LEN ("gcrt1.o") },
379 { STRING_COMMA_LEN ("gcrt2.o") },
380 { STRING_COMMA_LEN ("crtbegin.o") },
381 { STRING_COMMA_LEN ("crtend.o") },
382 { NULL, 0 }
383};
384
385static const autofilter_entry_type autofilter_symbolprefixlist[] =
386{
387 /* _imp_ is treated specially, as it is always underscored. */
388 /* { STRING_COMMA_LEN ("_imp_") }, */
389 /* Don't export some c++ symbols. */
390 { STRING_COMMA_LEN ("__rtti_") },
391 { STRING_COMMA_LEN ("__builtin_") },
392 /* Don't re-export auto-imported symbols. */
393 { STRING_COMMA_LEN ("__nm_") },
394 /* Don't export symbols specifying internal DLL layout. */
395 { STRING_COMMA_LEN ("_head_") },
396 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
397 /* Don't export section labels or artificial symbols
398 (eg ".weak.foo". */
399 { STRING_COMMA_LEN (".") },
400 { NULL, 0 }
401};
402
403static const autofilter_entry_type autofilter_symbolsuffixlist[] =
404{
405 { STRING_COMMA_LEN ("_iname") },
406 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
407 { NULL, 0 }
408};
409
410#define U(str) (pe_details->underscored ? "_" str : str)
411
412void
413pe_dll_id_target (const char *target)
414{
415 int i;
416
417 for (i = 0; pe_detail_list[i].target_name; i++)
418 if (strcmp (pe_detail_list[i].target_name, target) == 0
419 || strcmp (pe_detail_list[i].object_target, target) == 0)
420 {
421 int u = pe_leading_underscore; /* Underscoring mode. -1 for use default. */
422 if (u == -1)
423 bfd_get_target_info (target, NULL, NULL, &u, NULL);
424 if (u == -1)
425 abort ();
426 pe_detail_list[i].underscored = (u != 0 ? TRUE : FALSE);
427 pe_details = pe_detail_list + i;
428 pe_leading_underscore = (u != 0 ? 1 : 0);
429 return;
430 }
431 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
432 exit (1);
433}
434
435/* Helper functions for qsort. Relocs must be sorted so that we can write
436 them out by pages. */
437
438typedef struct
439 {
440 bfd_vma vma;
441 char type;
442 short extra;
443 }
444reloc_data_type;
445
446static int
447reloc_sort (const void *va, const void *vb)
448{
449 bfd_vma a = ((const reloc_data_type *) va)->vma;
450 bfd_vma b = ((const reloc_data_type *) vb)->vma;
451
452 return (a > b) ? 1 : ((a < b) ? -1 : 0);
453}
454
455static int
456pe_export_sort (const void *va, const void *vb)
457{
458 const def_file_export *a = va;
459 const def_file_export *b = vb;
460 char *an = a->name;
461 char *bn = b->name;
462 if (a->its_name)
463 an = a->its_name;
464 if (b->its_name)
465 bn = b->its_name;
466
467 return strcmp (an, bn);
468}
469
470/* Read and process the .DEF file. */
471
472/* These correspond to the entries in pe_def_file->exports[]. I use
473 exported_symbol_sections[i] to tag whether or not the symbol was
474 defined, since we can't export symbols we don't have. */
475
476static bfd_vma *exported_symbol_offsets;
477static struct bfd_section **exported_symbol_sections;
478static int export_table_size;
479static int count_exported;
480static int count_exported_byname;
481static int count_with_ordinals;
482static const char *dll_name;
483static int min_ordinal, max_ordinal;
484static int *exported_symbols;
485
486typedef struct exclude_list_struct
487 {
488 char *string;
489 struct exclude_list_struct *next;
490 exclude_type type;
491 }
492exclude_list_struct;
493
494static struct exclude_list_struct *excludes = 0;
495
496void
497pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
498{
499 char *local_copy;
500 char *exclude_string;
501
502 local_copy = xstrdup (new_excludes);
503
504 exclude_string = strtok (local_copy, ",:");
505 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
506 {
507 struct exclude_list_struct *new_exclude;
508
509 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
510 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
511 strcpy (new_exclude->string, exclude_string);
512 new_exclude->type = type;
513 new_exclude->next = excludes;
514 excludes = new_exclude;
515 }
516
517 free (local_copy);
518}
519
520static bfd_boolean
521is_import (const char* n)
522{
523 return (CONST_STRNEQ (n, "__imp_"));
524}
525
526/* abfd is a bfd containing n (or NULL)
527 It can be used for contextual checks. */
528
529static int
530auto_export (bfd *abfd, def_file *d, const char *n)
531{
532 def_file_export key;
533 struct exclude_list_struct *ex;
534 const autofilter_entry_type *afptr;
535 const char * libname = NULL;
536
537 if (abfd && abfd->my_archive)
538 libname = lbasename (abfd->my_archive->filename);
539
540 key.name = key.its_name = (char *) n;
541
542 /* Return false if n is in the d->exports table. */
543 if (bsearch (&key, d->exports, d->num_exports,
544 sizeof (pe_def_file->exports[0]), pe_export_sort))
545 return 0;
546
547 if (pe_dll_do_default_excludes)
548 {
549 const char * p;
550 int len;
551
552 if (pe_dll_extra_pe_debug)
553 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
554 n, abfd, abfd->my_archive);
555
556 /* First of all, make context checks:
557 Don't export anything from standard libs. */
558 if (libname)
559 {
560 afptr = autofilter_liblist;
561
562 while (afptr->name)
563 {
564 if (libnamencmp (libname, afptr) == 0 )
565 return 0;
566 afptr++;
567 }
568 }
569
570 /* Next, exclude symbols from certain startup objects. */
571
572 if (abfd && (p = lbasename (abfd->filename)))
573 {
574 afptr = autofilter_objlist;
575 while (afptr->name)
576 {
577 if (strcmp (p, afptr->name) == 0)
578 return 0;
579 afptr++;
580 }
581 }
582
583 /* Don't try to blindly exclude all symbols
584 that begin with '__'; this was tried and
585 it is too restrictive. Instead we have
586 a target specific list to use: */
587 afptr = pe_details->autofilter_symbollist;
588
589 while (afptr->name)
590 {
591 if (strcmp (n, afptr->name) == 0)
592 return 0;
593
594 afptr++;
595 }
596
597 /* Next, exclude symbols starting with ... */
598 afptr = autofilter_symbolprefixlist;
599 while (afptr->name)
600 {
601 if (strncmp (n, afptr->name, afptr->len) == 0)
602 return 0;
603
604 afptr++;
605 }
606
607 /* Finally, exclude symbols ending with ... */
608 len = strlen (n);
609 afptr = autofilter_symbolsuffixlist;
610 while (afptr->name)
611 {
612 if ((len >= afptr->len)
613 /* Add 1 to insure match with trailing '\0'. */
614 && strncmp (n + len - afptr->len, afptr->name,
615 afptr->len + 1) == 0)
616 return 0;
617
618 afptr++;
619 }
620 }
621
622 for (ex = excludes; ex; ex = ex->next)
623 {
624 if (ex->type == EXCLUDELIBS)
625 {
626 if (libname
627 && ((filename_cmp (libname, ex->string) == 0)
628 || (strcasecmp ("ALL", ex->string) == 0)))
629 return 0;
630 }
631 else if (ex->type == EXCLUDEFORIMPLIB)
632 {
633 if (filename_cmp (abfd->filename, ex->string) == 0)
634 return 0;
635 }
636 else if (strcmp (n, ex->string) == 0)
637 return 0;
638 }
639
640 return 1;
641}
642
643static void
644process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
645{
646 int i, j;
647 struct bfd_link_hash_entry *blhe;
648 bfd *b;
649 struct bfd_section *s;
650 def_file_export *e = 0;
651 bfd_boolean resort_needed;
652
653 if (!pe_def_file)
654 pe_def_file = def_file_empty ();
655
656 /* First, run around to all the objects looking for the .drectve
657 sections, and push those into the def file too. */
658 for (b = info->input_bfds; b; b = b->link_next)
659 {
660 s = bfd_get_section_by_name (b, ".drectve");
661 if (s)
662 {
663 long size = s->size;
664 char *buf = xmalloc (size);
665
666 bfd_get_section_contents (b, s, buf, 0, size);
667 def_file_add_directive (pe_def_file, buf, size);
668 free (buf);
669 }
670 }
671
672 /* Process aligned common symbol information from the
673 .drectve sections now; common symbol allocation is
674 done before final link, so it will be too late to
675 process them in process_embedded_commands() called
676 from _bfd_coff_link_input_bfd(). */
677 if (pe_def_file->aligncomms)
678 {
679 def_file_aligncomm *ac = pe_def_file->aligncomms;
680 while (ac)
681 {
682 struct coff_link_hash_entry *sym_hash;
683 sym_hash = coff_link_hash_lookup (coff_hash_table (info),
684 ac->symbol_name, FALSE, FALSE, FALSE);
685 if (sym_hash && sym_hash->root.type == bfd_link_hash_common
686 && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
687 {
688 sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
689 }
690 ac = ac->next;
691 }
692 }
693
694 /* If we are building an executable and there is nothing
695 to export, we do not build an export table at all. */
696 if (info->executable && pe_def_file->num_exports == 0
697 && (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
698 return;
699
700 /* Now, maybe export everything else the default way. */
701 if ((pe_dll_export_everything || pe_def_file->num_exports == 0)
702 && !pe_dll_exclude_all_symbols)
703 {
704 for (b = info->input_bfds; b; b = b->link_next)
705 {
706 asymbol **symbols;
707 int nsyms;
708
709 if (!bfd_generic_link_read_symbols (b))
710 {
711 einfo (_("%B%F: could not read symbols: %E\n"), b);
712 return;
713 }
714
715 symbols = bfd_get_outsymbols (b);
716 nsyms = bfd_get_symcount (b);
717
718 for (j = 0; j < nsyms; j++)
719 {
720 /* We should export symbols which are either global or not
721 anything at all. (.bss data is the latter)
722 We should not export undefined symbols. */
723 bfd_boolean would_export = symbols[j]->section != &bfd_und_section
724 && ((symbols[j]->flags & BSF_GLOBAL)
725 || (symbols[j]->flags == 0));
726 if (link_info.version_info && would_export)
727 would_export
728 = !bfd_hide_sym_by_version (link_info.version_info,
729 symbols[j]->name);
730 if (would_export)
731 {
732 const char *sn = symbols[j]->name;
733
734 /* We should not re-export imported stuff. */
735 {
736 char *name;
737 if (is_import (sn))
738 continue;
739
740 name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
741 sprintf (name, "%s%s", "__imp_", sn);
742
743 blhe = bfd_link_hash_lookup (info->hash, name,
744 FALSE, FALSE, FALSE);
745 free (name);
746
747 if (blhe && blhe->type == bfd_link_hash_defined)
748 continue;
749 }
750
751 if (pe_details->underscored && *sn == '_')
752 sn++;
753
754 if (auto_export (b, pe_def_file, sn))
755 {
756 int is_dup = 0;
757 def_file_export *p;
758
759 p = def_file_add_export (pe_def_file, sn, 0, -1,
760 NULL, &is_dup);
761 /* Fill data flag properly, from dlltool.c. */
762 if (!is_dup)
763 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
764 }
765 }
766 }
767 }
768 }
769
770#undef NE
771#define NE pe_def_file->num_exports
772
773 /* Don't create an empty export table. */
774 if (NE == 0)
775 return;
776
777 resort_needed = FALSE;
778
779 /* Canonicalize the export list. */
780 if (pe_dll_kill_ats)
781 {
782 for (i = 0; i < NE; i++)
783 {
784 if (strchr (pe_def_file->exports[i].name, '@'))
785 {
786 /* This will preserve internal_name, which may have been
787 pointing to the same memory as name, or might not
788 have. */
789 int lead_at = (*pe_def_file->exports[i].name == '@');
790 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
791 char *tmp_at = strchr (tmp, '@');
792
793 if (tmp_at)
794 *tmp_at = 0;
795 else
796 einfo (_("%XCannot export %s: invalid export name\n"),
797 pe_def_file->exports[i].name);
798 pe_def_file->exports[i].name = tmp;
799 resort_needed = TRUE;
800 }
801 }
802 }
803
804 /* Re-sort the exports table as we have possibly changed the order
805 by removing leading @. */
806 if (resort_needed)
807 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
808 pe_export_sort);
809
810 if (pe_dll_stdcall_aliases)
811 {
812 for (i = 0; i < NE; i++)
813 {
814 if (is_import (pe_def_file->exports[i].name))
815 continue;
816
817 if (strchr (pe_def_file->exports[i].name, '@'))
818 {
819 int is_dup = 1;
820 int lead_at = (*pe_def_file->exports[i].name == '@');
821 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
822
823 *(strchr (tmp, '@')) = 0;
824 if (auto_export (NULL, pe_def_file, tmp))
825 def_file_add_export (pe_def_file, tmp,
826 pe_def_file->exports[i].internal_name,
827 -1, NULL, &is_dup);
828 if (is_dup)
829 free (tmp);
830 }
831 }
832 }
833
834 /* Convenience, but watch out for it changing. */
835 e = pe_def_file->exports;
836
837 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
838 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
839
840 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
841 max_ordinal = 0;
842 min_ordinal = 65536;
843 count_exported = 0;
844 count_exported_byname = 0;
845 count_with_ordinals = 0;
846
847 for (i = 0, j = 0; i < NE; i++)
848 {
849 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
850 {
851 /* This is a duplicate. */
852 if (e[j - 1].ordinal != -1
853 && e[i].ordinal != -1
854 && e[j - 1].ordinal != e[i].ordinal)
855 {
856 if (pe_dll_warn_dup_exports)
857 /* xgettext:c-format */
858 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
859 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
860 }
861 else
862 {
863 if (pe_dll_warn_dup_exports)
864 /* xgettext:c-format */
865 einfo (_("Warning, duplicate EXPORT: %s\n"),
866 e[j - 1].name);
867 }
868
869 if (e[i].ordinal != -1)
870 e[j - 1].ordinal = e[i].ordinal;
871 e[j - 1].flag_private |= e[i].flag_private;
872 e[j - 1].flag_constant |= e[i].flag_constant;
873 e[j - 1].flag_noname |= e[i].flag_noname;
874 e[j - 1].flag_data |= e[i].flag_data;
875 }
876 else
877 {
878 if (i != j)
879 e[j] = e[i];
880 j++;
881 }
882 }
883 pe_def_file->num_exports = j; /* == NE */
884
885 for (i = 0; i < NE; i++)
886 {
887 char *name;
888 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
889 if (pe_details->underscored
890 && (*pe_def_file->exports[i].internal_name != '@'))
891 {
892 *name = '_';
893 strcpy (name + 1, pe_def_file->exports[i].internal_name);
894 }
895 else
896 strcpy (name, pe_def_file->exports[i].internal_name);
897
898 blhe = bfd_link_hash_lookup (info->hash,
899 name,
900 FALSE, FALSE, TRUE);
901
902 if (blhe
903 && (blhe->type == bfd_link_hash_defined
904 || (blhe->type == bfd_link_hash_common)))
905 {
906 count_exported++;
907 if (!pe_def_file->exports[i].flag_noname)
908 count_exported_byname++;
909
910 /* Only fill in the sections. The actual offsets are computed
911 in fill_exported_offsets() after common symbols are laid
912 out. */
913 if (blhe->type == bfd_link_hash_defined)
914 exported_symbol_sections[i] = blhe->u.def.section;
915 else
916 exported_symbol_sections[i] = blhe->u.c.p->section;
917
918 if (pe_def_file->exports[i].ordinal != -1)
919 {
920 if (max_ordinal < pe_def_file->exports[i].ordinal)
921 max_ordinal = pe_def_file->exports[i].ordinal;
922 if (min_ordinal > pe_def_file->exports[i].ordinal)
923 min_ordinal = pe_def_file->exports[i].ordinal;
924 count_with_ordinals++;
925 }
926 }
927 /* Check for forward exports. These are indicated in DEF files by an
928 export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
929 but we must take care not to be fooled when the user wants to export
930 a symbol that actually really has a dot in it, so we only check
931 for them here, after real defined symbols have already been matched. */
932 else if (strchr (pe_def_file->exports[i].internal_name, '.'))
933 {
934 count_exported++;
935 if (!pe_def_file->exports[i].flag_noname)
936 count_exported_byname++;
937
938 pe_def_file->exports[i].flag_forward = 1;
939
940 if (pe_def_file->exports[i].ordinal != -1)
941 {
942 if (max_ordinal < pe_def_file->exports[i].ordinal)
943 max_ordinal = pe_def_file->exports[i].ordinal;
944 if (min_ordinal > pe_def_file->exports[i].ordinal)
945 min_ordinal = pe_def_file->exports[i].ordinal;
946 count_with_ordinals++;
947 }
948 }
949 else if (blhe && blhe->type == bfd_link_hash_undefined)
950 {
951 /* xgettext:c-format */
952 einfo (_("%XCannot export %s: symbol not defined\n"),
953 pe_def_file->exports[i].internal_name);
954 }
955 else if (blhe)
956 {
957 /* xgettext:c-format */
958 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
959 pe_def_file->exports[i].internal_name,
960 blhe->type, bfd_link_hash_defined);
961 }
962 else
963 {
964 /* xgettext:c-format */
965 einfo (_("%XCannot export %s: symbol not found\n"),
966 pe_def_file->exports[i].internal_name);
967 }
968 free (name);
969 }
970}
971
972/* Build the bfd that will contain .edata and .reloc sections. */
973
974static void
975build_filler_bfd (int include_edata)
976{
977 lang_input_statement_type *filler_file;
978 filler_file = lang_add_input_file ("dll stuff",
979 lang_input_file_is_fake_enum,
980 NULL);
981 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff",
982 link_info.output_bfd);
983 if (filler_bfd == NULL
984 || !bfd_set_arch_mach (filler_bfd,
985 bfd_get_arch (link_info.output_bfd),
986 bfd_get_mach (link_info.output_bfd)))
987 {
988 einfo ("%X%P: can not create BFD: %E\n");
989 return;
990 }
991
992 if (include_edata)
993 {
994 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
995 if (edata_s == NULL
996 || !bfd_set_section_flags (filler_bfd, edata_s,
997 (SEC_HAS_CONTENTS
998 | SEC_ALLOC
999 | SEC_LOAD
1000 | SEC_KEEP
1001 | SEC_IN_MEMORY)))
1002 {
1003 einfo ("%X%P: can not create .edata section: %E\n");
1004 return;
1005 }
1006 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
1007 }
1008
1009 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
1010 if (reloc_s == NULL
1011 || !bfd_set_section_flags (filler_bfd, reloc_s,
1012 (SEC_HAS_CONTENTS
1013 | SEC_ALLOC
1014 | SEC_LOAD
1015 | SEC_KEEP
1016 | SEC_IN_MEMORY)))
1017 {
1018 einfo ("%X%P: can not create .reloc section: %E\n");
1019 return;
1020 }
1021
1022 bfd_set_section_size (filler_bfd, reloc_s, 0);
1023
1024 ldlang_add_file (filler_file);
1025}
1026
1027/* Gather all the exported symbols and build the .edata section. */
1028
1029static void
1030generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1031{
1032 int i, next_ordinal;
1033 int name_table_size = 0;
1034 const char *dlnp;
1035
1036 /* First, we need to know how many exported symbols there are,
1037 and what the range of ordinals is. */
1038 if (pe_def_file->name)
1039 dll_name = pe_def_file->name;
1040 else
1041 {
1042 dll_name = abfd->filename;
1043
1044 for (dlnp = dll_name; *dlnp; dlnp++)
1045 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
1046 dll_name = dlnp + 1;
1047 }
1048
1049 if (count_with_ordinals && max_ordinal > count_exported)
1050 {
1051 if (min_ordinal > max_ordinal - count_exported + 1)
1052 min_ordinal = max_ordinal - count_exported + 1;
1053 }
1054 else
1055 {
1056 min_ordinal = 1;
1057 max_ordinal = count_exported;
1058 }
1059
1060 export_table_size = max_ordinal - min_ordinal + 1;
1061 exported_symbols = xmalloc (export_table_size * sizeof (int));
1062 for (i = 0; i < export_table_size; i++)
1063 exported_symbols[i] = -1;
1064
1065 /* Now we need to assign ordinals to those that don't have them. */
1066 for (i = 0; i < NE; i++)
1067 {
1068 if (exported_symbol_sections[i] ||
1069 pe_def_file->exports[i].flag_forward)
1070 {
1071 if (pe_def_file->exports[i].ordinal != -1)
1072 {
1073 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
1074 int pi = exported_symbols[ei];
1075
1076 if (pi != -1)
1077 {
1078 /* xgettext:c-format */
1079 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1080 pe_def_file->exports[i].ordinal,
1081 pe_def_file->exports[i].name,
1082 pe_def_file->exports[pi].name);
1083 }
1084 exported_symbols[ei] = i;
1085 }
1086 if (pe_def_file->exports[i].its_name)
1087 name_table_size += strlen (pe_def_file->exports[i].its_name) + 1;
1088 else
1089 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
1090 }
1091
1092 /* Reserve space for the forward name. */
1093 if (pe_def_file->exports[i].flag_forward)
1094 {
1095 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
1096 }
1097 }
1098
1099 next_ordinal = min_ordinal;
1100 for (i = 0; i < NE; i++)
1101 if ((exported_symbol_sections[i] ||
1102 pe_def_file->exports[i].flag_forward) &&
1103 pe_def_file->exports[i].ordinal == -1)
1104 {
1105 while (exported_symbols[next_ordinal - min_ordinal] != -1)
1106 next_ordinal++;
1107
1108 exported_symbols[next_ordinal - min_ordinal] = i;
1109 pe_def_file->exports[i].ordinal = next_ordinal;
1110 }
1111
1112 /* OK, now we can allocate some memory. */
1113 edata_sz = (40 /* directory */
1114 + 4 * export_table_size /* addresses */
1115 + 4 * count_exported_byname /* name ptrs */
1116 + 2 * count_exported_byname /* ordinals */
1117 + name_table_size + strlen (dll_name) + 1);
1118}
1119
1120/* Fill the exported symbol offsets. The preliminary work has already
1121 been done in process_def_file_and_drectve(). */
1122
1123static void
1124fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
1125{
1126 int i;
1127 struct bfd_link_hash_entry *blhe;
1128
1129 for (i = 0; i < pe_def_file->num_exports; i++)
1130 {
1131 char *name;
1132
1133 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
1134 if (pe_details->underscored
1135 && *pe_def_file->exports[i].internal_name != '@')
1136 {
1137 *name = '_';
1138 strcpy (name + 1, pe_def_file->exports[i].internal_name);
1139 }
1140 else
1141 strcpy (name, pe_def_file->exports[i].internal_name);
1142
1143 blhe = bfd_link_hash_lookup (info->hash,
1144 name,
1145 FALSE, FALSE, TRUE);
1146
1147 if (blhe && blhe->type == bfd_link_hash_defined)
1148 exported_symbol_offsets[i] = blhe->u.def.value;
1149
1150 free (name);
1151 }
1152}
1153
1154static void
1155fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1156{
1157 int s, hint;
1158 unsigned char *edirectory;
1159 unsigned char *eaddresses;
1160 unsigned char *enameptrs;
1161 unsigned char *eordinals;
1162 char *enamestr;
1163 time_t now;
1164
1165 time (&now);
1166
1167 edata_d = xmalloc (edata_sz);
1168
1169 /* Note use of array pointer math here. */
1170 edirectory = edata_d;
1171 eaddresses = edirectory + 40;
1172 enameptrs = eaddresses + 4 * export_table_size;
1173 eordinals = enameptrs + 4 * count_exported_byname;
1174 enamestr = (char *) eordinals + 2 * count_exported_byname;
1175
1176#define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1177 + edata_s->output_section->vma - image_base)
1178
1179 memset (edata_d, 0, edata_sz);
1180 bfd_put_32 (abfd, now, edata_d + 4);
1181 if (pe_def_file->version_major != -1)
1182 {
1183 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1184 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1185 }
1186
1187 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1188 strcpy (enamestr, dll_name);
1189 enamestr += strlen (enamestr) + 1;
1190 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1191 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1192 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1193 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1194 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1195 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1196
1197 fill_exported_offsets (abfd, info);
1198
1199 /* Ok, now for the filling in part.
1200 Scan alphabetically - ie the ordering in the exports[] table,
1201 rather than by ordinal - the ordering in the exported_symbol[]
1202 table. See dlltool.c and:
1203 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1204 for more information. */
1205 hint = 0;
1206 for (s = 0; s < NE; s++)
1207 {
1208 struct bfd_section *ssec = exported_symbol_sections[s];
1209 if (pe_def_file->exports[s].ordinal != -1 &&
1210 (pe_def_file->exports[s].flag_forward || ssec != NULL))
1211 {
1212 int ord = pe_def_file->exports[s].ordinal;
1213
1214 if (pe_def_file->exports[s].flag_forward)
1215 {
1216 bfd_put_32 (abfd, ERVA (enamestr),
1217 eaddresses + 4 * (ord - min_ordinal));
1218
1219 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1220 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1221 }
1222 else
1223 {
1224 bfd_vma srva = (exported_symbol_offsets[s]
1225 + ssec->output_section->vma
1226 + ssec->output_offset);
1227
1228 bfd_put_32 (abfd, srva - image_base,
1229 eaddresses + 4 * (ord - min_ordinal));
1230 }
1231
1232 if (!pe_def_file->exports[s].flag_noname)
1233 {
1234 char *ename = pe_def_file->exports[s].name;
1235 if (pe_def_file->exports[s].its_name)
1236 ename = pe_def_file->exports[s].its_name;
1237
1238 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1239 enameptrs += 4;
1240 strcpy (enamestr, ename);
1241 enamestr += strlen (enamestr) + 1;
1242 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1243 eordinals += 2;
1244 pe_def_file->exports[s].hint = hint++;
1245 }
1246 }
1247 }
1248}
1249
1250
1251static struct bfd_section *current_sec;
1252
1253void
1254pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1255 const char *name,
1256 int (*cb) (arelent *, asection *))
1257{
1258 bfd *b;
1259 asection *s;
1260
1261 for (b = info->input_bfds; b; b = b->link_next)
1262 {
1263 asymbol **symbols;
1264
1265 if (!bfd_generic_link_read_symbols (b))
1266 {
1267 einfo (_("%B%F: could not read symbols: %E\n"), b);
1268 return;
1269 }
1270
1271 symbols = bfd_get_outsymbols (b);
1272
1273 for (s = b->sections; s; s = s->next)
1274 {
1275 arelent **relocs;
1276 int relsize, nrelocs, i;
1277 int flags = bfd_get_section_flags (b, s);
1278
1279 /* Skip discarded linkonce sections. */
1280 if (flags & SEC_LINK_ONCE
1281 && s->output_section == bfd_abs_section_ptr)
1282 continue;
1283
1284 current_sec = s;
1285
1286 relsize = bfd_get_reloc_upper_bound (b, s);
1287 relocs = xmalloc (relsize);
1288 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1289
1290 for (i = 0; i < nrelocs; i++)
1291 {
1292 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1293
1294 if (!strcmp (name, sym->name))
1295 cb (relocs[i], s);
1296 }
1297
1298 free (relocs);
1299
1300 /* Warning: the allocated symbols are remembered in BFD and reused
1301 later, so don't free them! */
1302 /* free (symbols); */
1303 }
1304 }
1305}
1306
1307/* Gather all the relocations and build the .reloc section. */
1308
1309static void
1310generate_reloc (bfd *abfd, struct bfd_link_info *info)
1311{
1312
1313 /* For .reloc stuff. */
1314 reloc_data_type *reloc_data;
1315 int total_relocs = 0;
1316 int i;
1317 bfd_vma sec_page = (bfd_vma) -1;
1318 bfd_vma page_ptr, page_count;
1319 int bi;
1320 bfd *b;
1321 struct bfd_section *s;
1322
1323 total_relocs = 0;
1324 for (b = info->input_bfds; b; b = b->link_next)
1325 for (s = b->sections; s; s = s->next)
1326 total_relocs += s->reloc_count;
1327
1328 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1329
1330 total_relocs = 0;
1331 bi = 0;
1332 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1333 {
1334 arelent **relocs;
1335 int relsize, nrelocs;
1336
1337 for (s = b->sections; s; s = s->next)
1338 {
1339 bfd_vma sec_vma = s->output_section->vma + s->output_offset;
1340 asymbol **symbols;
1341
1342 /* If it's not loaded, we don't need to relocate it this way. */
1343 if (!(s->output_section->flags & SEC_LOAD))
1344 continue;
1345
1346 /* I don't know why there would be a reloc for these, but I've
1347 seen it happen - DJ */
1348 if (s->output_section == &bfd_abs_section)
1349 continue;
1350
1351 if (s->output_section->vma == 0)
1352 {
1353 /* Huh? Shouldn't happen, but punt if it does. */
1354 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1355 s->output_section->name, s->output_section->index,
1356 s->output_section->flags);
1357 continue;
1358 }
1359
1360 if (!bfd_generic_link_read_symbols (b))
1361 {
1362 einfo (_("%B%F: could not read symbols: %E\n"), b);
1363 return;
1364 }
1365
1366 symbols = bfd_get_outsymbols (b);
1367 relsize = bfd_get_reloc_upper_bound (b, s);
1368 relocs = xmalloc (relsize);
1369 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1370
1371 for (i = 0; i < nrelocs; i++)
1372 {
1373 if (pe_dll_extra_pe_debug)
1374 {
1375 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1376 printf ("rel: %s\n", sym->name);
1377 }
1378 if (!relocs[i]->howto->pc_relative
1379 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1380 {
1381 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1382
1383 /* Don't create relocs for undefined weak symbols. */
1384 if (sym->flags == BSF_WEAK)
1385 {
1386 struct bfd_link_hash_entry *blhe
1387 = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
1388 FALSE, FALSE, FALSE);
1389 if (blhe && blhe->type == bfd_link_hash_undefweak)
1390 {
1391 /* Check aux sym and see if it is defined or not. */
1392 struct coff_link_hash_entry *h, *h2;
1393 h = (struct coff_link_hash_entry *)blhe;
1394 if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
1395 continue;
1396 h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
1397 [h->aux->x_sym.x_tagndx.l];
1398 /* We don't want a base reloc if the aux sym is not
1399 found, undefined, or if it is the constant ABS
1400 zero default value. (We broaden that slightly by
1401 not testing the value, just the section; there's
1402 no reason we'd want a reference to any absolute
1403 address to get relocated during rebasing). */
1404 if (!h2 || h2->root.type == bfd_link_hash_undefined
1405 || h2->root.u.def.section == &bfd_abs_section)
1406 continue;
1407 }
1408 else if (!blhe || blhe->type != bfd_link_hash_defined)
1409 continue;
1410 }
1411 /* Nor for Dwarf FDE references to discarded sections. */
1412 else if (bfd_is_abs_section (sym->section->output_section))
1413 {
1414 /* We only ignore relocs from .eh_frame sections, as
1415 they are discarded by the final link rather than
1416 resolved against the kept section. */
1417 if (!strcmp (s->name, ".eh_frame"))
1418 continue;
1419 }
1420
1421 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1422
1423#define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1424
1425 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1426 relocs[i]->howto->rightshift)
1427 {
1428#ifdef pe_use_x86_64
1429 case BITS_AND_SHIFT (64, 0):
1430 reloc_data[total_relocs].type = 10;
1431 total_relocs++;
1432 break;
1433#endif
1434 case BITS_AND_SHIFT (32, 0):
1435 reloc_data[total_relocs].type = 3;
1436 total_relocs++;
1437 break;
1438 case BITS_AND_SHIFT (16, 0):
1439 reloc_data[total_relocs].type = 2;
1440 total_relocs++;
1441 break;
1442 case BITS_AND_SHIFT (16, 16):
1443 reloc_data[total_relocs].type = 4;
1444 /* FIXME: we can't know the symbol's right value
1445 yet, but we probably can safely assume that
1446 CE will relocate us in 64k blocks, so leaving
1447 it zero is safe. */
1448 reloc_data[total_relocs].extra = 0;
1449 total_relocs++;
1450 break;
1451 case BITS_AND_SHIFT (26, 2):
1452 reloc_data[total_relocs].type = 5;
1453 total_relocs++;
1454 break;
1455 case BITS_AND_SHIFT (24, 2):
1456 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1457 Those ARM_xxx definitions should go in proper
1458 header someday. */
1459 if (relocs[i]->howto->type == 0
1460 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1461 || relocs[i]->howto->type == 5)
1462 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1463 that has already been fully processed during a
1464 previous link stage, so ignore it here. */
1465 break;
1466 /* Fall through. */
1467 default:
1468 /* xgettext:c-format */
1469 einfo (_("%XError: %d-bit reloc in dll\n"),
1470 relocs[i]->howto->bitsize);
1471 break;
1472 }
1473 }
1474 }
1475 free (relocs);
1476 /* Warning: the allocated symbols are remembered in BFD and
1477 reused later, so don't free them! */
1478 }
1479 }
1480
1481 /* At this point, we have total_relocs relocation addresses in
1482 reloc_addresses, which are all suitable for the .reloc section.
1483 We must now create the new sections. */
1484 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1485
1486 for (i = 0; i < total_relocs; i++)
1487 {
1488 bfd_vma this_page = (reloc_data[i].vma >> 12);
1489
1490 if (this_page != sec_page)
1491 {
1492 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1493 reloc_sz += 8;
1494 sec_page = this_page;
1495 }
1496
1497 reloc_sz += 2;
1498
1499 if (reloc_data[i].type == 4)
1500 reloc_sz += 2;
1501 }
1502
1503 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1504 reloc_d = xmalloc (reloc_sz);
1505 sec_page = (bfd_vma) -1;
1506 reloc_sz = 0;
1507 page_ptr = (bfd_vma) -1;
1508 page_count = 0;
1509
1510 for (i = 0; i < total_relocs; i++)
1511 {
1512 bfd_vma rva = reloc_data[i].vma - image_base;
1513 bfd_vma this_page = (rva & ~0xfff);
1514
1515 if (this_page != sec_page)
1516 {
1517 while (reloc_sz & 3)
1518 reloc_d[reloc_sz++] = 0;
1519
1520 if (page_ptr != (bfd_vma) -1)
1521 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1522
1523 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1524 page_ptr = reloc_sz;
1525 reloc_sz += 8;
1526 sec_page = this_page;
1527 page_count = 0;
1528 }
1529
1530 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1531 reloc_d + reloc_sz);
1532 reloc_sz += 2;
1533
1534 if (reloc_data[i].type == 4)
1535 {
1536 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1537 reloc_sz += 2;
1538 }
1539
1540 page_count++;
1541 }
1542
1543 while (reloc_sz & 3)
1544 reloc_d[reloc_sz++] = 0;
1545
1546 if (page_ptr != (bfd_vma) -1)
1547 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1548
1549 while (reloc_sz < reloc_s->size)
1550 reloc_d[reloc_sz++] = 0;
1551}
1552
1553/* Given the exiting def_file structure, print out a .DEF file that
1554 corresponds to it. */
1555
1556static void
1557quoteput (char *s, FILE *f, int needs_quotes)
1558{
1559 char *cp;
1560
1561 for (cp = s; *cp; cp++)
1562 if (*cp == '\''
1563 || *cp == '"'
1564 || *cp == '\\'
1565 || ISSPACE (*cp)
1566 || *cp == ','
1567 || *cp == ';')
1568 needs_quotes = 1;
1569
1570 if (needs_quotes)
1571 {
1572 putc ('"', f);
1573
1574 while (*s)
1575 {
1576 if (*s == '"' || *s == '\\')
1577 putc ('\\', f);
1578
1579 putc (*s, f);
1580 s++;
1581 }
1582
1583 putc ('"', f);
1584 }
1585 else
1586 fputs (s, f);
1587}
1588
1589void
1590pe_dll_generate_def_file (const char *pe_out_def_filename)
1591{
1592 int i;
1593 FILE *out = fopen (pe_out_def_filename, "w");
1594
1595 if (out == NULL)
1596 /* xgettext:c-format */
1597 einfo (_("%s: Can't open output def file %s\n"),
1598 program_name, pe_out_def_filename);
1599
1600 if (pe_def_file)
1601 {
1602 if (pe_def_file->name)
1603 {
1604 if (pe_def_file->is_dll)
1605 fprintf (out, "LIBRARY ");
1606 else
1607 fprintf (out, "NAME ");
1608
1609 quoteput (pe_def_file->name, out, 1);
1610
1611 if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
1612 {
1613 fprintf (out, " BASE=0x");
1614 fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
1615 }
1616 fprintf (out, "\n");
1617 }
1618
1619 if (pe_def_file->description)
1620 {
1621 fprintf (out, "DESCRIPTION ");
1622 quoteput (pe_def_file->description, out, 1);
1623 fprintf (out, "\n");
1624 }
1625
1626 if (pe_def_file->version_minor != -1)
1627 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1628 pe_def_file->version_minor);
1629 else if (pe_def_file->version_major != -1)
1630 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1631
1632 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1633 fprintf (out, "\n");
1634
1635 if (pe_def_file->stack_commit != -1)
1636 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1637 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1638 else if (pe_def_file->stack_reserve != -1)
1639 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1640
1641 if (pe_def_file->heap_commit != -1)
1642 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1643 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1644 else if (pe_def_file->heap_reserve != -1)
1645 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1646
1647 if (pe_def_file->num_section_defs > 0)
1648 {
1649 fprintf (out, "\nSECTIONS\n\n");
1650
1651 for (i = 0; i < pe_def_file->num_section_defs; i++)
1652 {
1653 fprintf (out, " ");
1654 quoteput (pe_def_file->section_defs[i].name, out, 0);
1655
1656 if (pe_def_file->section_defs[i].class)
1657 {
1658 fprintf (out, " CLASS ");
1659 quoteput (pe_def_file->section_defs[i].class, out, 0);
1660 }
1661
1662 if (pe_def_file->section_defs[i].flag_read)
1663 fprintf (out, " READ");
1664
1665 if (pe_def_file->section_defs[i].flag_write)
1666 fprintf (out, " WRITE");
1667
1668 if (pe_def_file->section_defs[i].flag_execute)
1669 fprintf (out, " EXECUTE");
1670
1671 if (pe_def_file->section_defs[i].flag_shared)
1672 fprintf (out, " SHARED");
1673
1674 fprintf (out, "\n");
1675 }
1676 }
1677
1678 if (pe_def_file->num_exports > 0)
1679 {
1680 fprintf (out, "EXPORTS\n");
1681
1682 for (i = 0; i < pe_def_file->num_exports; i++)
1683 {
1684 def_file_export *e = pe_def_file->exports + i;
1685 fprintf (out, " ");
1686 quoteput (e->name, out, 0);
1687
1688 if (e->internal_name && strcmp (e->internal_name, e->name))
1689 {
1690 fprintf (out, " = ");
1691 quoteput (e->internal_name, out, 0);
1692 }
1693
1694 if (e->ordinal != -1)
1695 fprintf (out, " @%d", e->ordinal);
1696
1697 if (e->flag_private)
1698 fprintf (out, " PRIVATE");
1699
1700 if (e->flag_constant)
1701 fprintf (out, " CONSTANT");
1702
1703 if (e->flag_noname)
1704 fprintf (out, " NONAME");
1705
1706 if (e->flag_data)
1707 fprintf (out, " DATA");
1708
1709 fprintf (out, "\n");
1710 }
1711 }
1712
1713 if (pe_def_file->num_imports > 0)
1714 {
1715 fprintf (out, "\nIMPORTS\n\n");
1716
1717 for (i = 0; i < pe_def_file->num_imports; i++)
1718 {
1719 def_file_import *im = pe_def_file->imports + i;
1720 fprintf (out, " ");
1721
1722 if (im->internal_name
1723 && (!im->name || strcmp (im->internal_name, im->name)))
1724 {
1725 quoteput (im->internal_name, out, 0);
1726 fprintf (out, " = ");
1727 }
1728
1729 quoteput (im->module->name, out, 0);
1730 fprintf (out, ".");
1731
1732 if (im->name)
1733 quoteput (im->name, out, 0);
1734 else
1735 fprintf (out, "%d", im->ordinal);
1736
1737 if (im->its_name)
1738 {
1739 fprintf (out, " == ");
1740 quoteput (im->its_name, out, 0);
1741 }
1742
1743 fprintf (out, "\n");
1744 }
1745 }
1746 }
1747 else
1748 fprintf (out, _("; no contents available\n"));
1749
1750 if (fclose (out) == EOF)
1751 /* xgettext:c-format */
1752 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1753}
1754
1755/* Generate the import library. */
1756
1757static asymbol **symtab;
1758static int symptr;
1759static int tmp_seq;
1760static int tmp_seq2;
1761static const char *dll_filename;
1762static char *dll_symname;
1763
1764#define UNDSEC (asection *) &bfd_und_section
1765
1766static asection *
1767quick_section (bfd *abfd, const char *name, int flags, int align)
1768{
1769 asection *sec;
1770 asymbol *sym;
1771
1772 sec = bfd_make_section_old_way (abfd, name);
1773 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1774 bfd_set_section_alignment (abfd, sec, align);
1775 /* Remember to undo this before trying to link internally! */
1776 sec->output_section = sec;
1777
1778 sym = bfd_make_empty_symbol (abfd);
1779 symtab[symptr++] = sym;
1780 sym->name = sec->name;
1781 sym->section = sec;
1782 sym->flags = BSF_LOCAL;
1783 sym->value = 0;
1784
1785 return sec;
1786}
1787
1788static void
1789quick_symbol (bfd *abfd,
1790 const char *n1,
1791 const char *n2,
1792 const char *n3,
1793 asection *sec,
1794 int flags,
1795 int addr)
1796{
1797 asymbol *sym;
1798 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1799
1800 strcpy (name, n1);
1801 strcat (name, n2);
1802 strcat (name, n3);
1803 sym = bfd_make_empty_symbol (abfd);
1804 sym->name = name;
1805 sym->section = sec;
1806 sym->flags = flags;
1807 sym->value = addr;
1808 symtab[symptr++] = sym;
1809}
1810
1811static arelent *reltab = 0;
1812static int relcount = 0, relsize = 0;
1813
1814static void
1815quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
1816{
1817 if (relcount >= relsize - 1)
1818 {
1819 relsize += 10;
1820 if (reltab)
1821 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1822 else
1823 reltab = xmalloc (relsize * sizeof (arelent));
1824 }
1825 reltab[relcount].address = address;
1826 reltab[relcount].addend = 0;
1827 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1828 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1829 relcount++;
1830}
1831
1832static void
1833save_relocs (asection *sec)
1834{
1835 int i;
1836
1837 sec->relocation = reltab;
1838 sec->reloc_count = relcount;
1839 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1840 for (i = 0; i < relcount; i++)
1841 sec->orelocation[i] = sec->relocation + i;
1842 sec->orelocation[relcount] = 0;
1843 sec->flags |= SEC_RELOC;
1844 reltab = 0;
1845 relcount = relsize = 0;
1846}
1847
1848/* .section .idata$2
1849 .global __head_my_dll
1850 __head_my_dll:
1851 .rva hname
1852 .long 0
1853 .long 0
1854 .rva __my_dll_iname
1855 .rva fthunk
1856
1857 .section .idata$5
1858 .long 0
1859 fthunk:
1860
1861 .section .idata$4
1862 .long 0
1863 hname: */
1864
1865static bfd *
1866make_head (bfd *parent)
1867{
1868 asection *id2, *id5, *id4;
1869 unsigned char *d2, *d5, *d4;
1870 char *oname;
1871 bfd *abfd;
1872
1873 oname = xmalloc (20);
1874 sprintf (oname, "d%06d.o", tmp_seq);
1875 tmp_seq++;
1876
1877 abfd = bfd_create (oname, parent);
1878 bfd_find_target (pe_details->object_target, abfd);
1879 bfd_make_writable (abfd);
1880
1881 bfd_set_format (abfd, bfd_object);
1882 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1883
1884 symptr = 0;
1885 symtab = xmalloc (6 * sizeof (asymbol *));
1886 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1887 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1888 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1889 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1890 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1891
1892 /* OK, pay attention here. I got confused myself looking back at
1893 it. We create a four-byte section to mark the beginning of the
1894 list, and we include an offset of 4 in the section, so that the
1895 pointer to the list points to the *end* of this section, which is
1896 the start of the list of sections from other objects. */
1897
1898 bfd_set_section_size (abfd, id2, 20);
1899 d2 = xmalloc (20);
1900 id2->contents = d2;
1901 memset (d2, 0, 20);
1902 if (pe_use_nul_prefixed_import_tables)
1903 d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
1904 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1905 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1906 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1907 save_relocs (id2);
1908
1909 if (pe_use_nul_prefixed_import_tables)
1910 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1911 else
1912 bfd_set_section_size (abfd, id5, 0);
1913 d5 = xmalloc (PE_IDATA5_SIZE);
1914 id5->contents = d5;
1915 memset (d5, 0, PE_IDATA5_SIZE);
1916 if (pe_use_nul_prefixed_import_tables)
1917 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1918 else
1919 bfd_set_section_size (abfd, id4, 0);
1920 d4 = xmalloc (PE_IDATA4_SIZE);
1921 id4->contents = d4;
1922 memset (d4, 0, PE_IDATA4_SIZE);
1923
1924 bfd_set_symtab (abfd, symtab, symptr);
1925
1926 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1927 if (pe_use_nul_prefixed_import_tables)
1928 {
1929 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1930 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1931 }
1932 else
1933 {
1934 bfd_set_section_contents (abfd, id5, d5, 0, 0);
1935 bfd_set_section_contents (abfd, id4, d4, 0, 0);
1936 }
1937
1938 bfd_make_readable (abfd);
1939 return abfd;
1940}
1941
1942/* .section .idata$4
1943 .long 0
1944 [.long 0] for PE+
1945 .section .idata$5
1946 .long 0
1947 [.long 0] for PE+
1948 .section idata$7
1949 .global __my_dll_iname
1950 __my_dll_iname:
1951 .asciz "my.dll" */
1952
1953static bfd *
1954make_tail (bfd *parent)
1955{
1956 asection *id4, *id5, *id7;
1957 unsigned char *d4, *d5, *d7;
1958 int len;
1959 char *oname;
1960 bfd *abfd;
1961
1962 oname = xmalloc (20);
1963 sprintf (oname, "d%06d.o", tmp_seq);
1964 tmp_seq++;
1965
1966 abfd = bfd_create (oname, parent);
1967 bfd_find_target (pe_details->object_target, abfd);
1968 bfd_make_writable (abfd);
1969
1970 bfd_set_format (abfd, bfd_object);
1971 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1972
1973 symptr = 0;
1974 symtab = xmalloc (5 * sizeof (asymbol *));
1975 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1976 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1977 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1978 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1979
1980 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1981 d4 = xmalloc (PE_IDATA4_SIZE);
1982 id4->contents = d4;
1983 memset (d4, 0, PE_IDATA4_SIZE);
1984
1985 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1986 d5 = xmalloc (PE_IDATA5_SIZE);
1987 id5->contents = d5;
1988 memset (d5, 0, PE_IDATA5_SIZE);
1989
1990 len = strlen (dll_filename) + 1;
1991 if (len & 1)
1992 len++;
1993 bfd_set_section_size (abfd, id7, len);
1994 d7 = xmalloc (len);
1995 id7->contents = d7;
1996 strcpy ((char *) d7, dll_filename);
1997 /* If len was odd, the above
1998 strcpy leaves behind an undefined byte. That is harmless,
1999 but we set it to 0 just so the binary dumps are pretty. */
2000 d7[len - 1] = 0;
2001
2002 bfd_set_symtab (abfd, symtab, symptr);
2003
2004 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2005 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2006 bfd_set_section_contents (abfd, id7, d7, 0, len);
2007
2008 bfd_make_readable (abfd);
2009 return abfd;
2010}
2011
2012/* .text
2013 .global _function
2014 .global ___imp_function
2015 .global __imp__function
2016 _function:
2017 jmp *__imp__function:
2018
2019 .section idata$7
2020 .long __head_my_dll
2021
2022 .section .idata$5
2023 ___imp_function:
2024 __imp__function:
2025 iat?
2026 .section .idata$4
2027 iat?
2028 .section .idata$6
2029 ID<ordinal>:
2030 .short <hint>
2031 .asciz "function" xlate? (add underscore, kill at) */
2032
2033static const unsigned char jmp_ix86_bytes[] =
2034{
2035 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2036};
2037
2038/* _function:
2039 mov.l ip+8,r0
2040 mov.l @r0,r0
2041 jmp @r0
2042 nop
2043 .dw __imp_function */
2044
2045static const unsigned char jmp_sh_bytes[] =
2046{
2047 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2048};
2049
2050/* _function:
2051 lui $t0,<high:__imp_function>
2052 lw $t0,<low:__imp_function>
2053 jr $t0
2054 nop */
2055
2056static const unsigned char jmp_mips_bytes[] =
2057{
2058 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2059 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2060};
2061
2062static const unsigned char jmp_arm_bytes[] =
2063{
2064 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2065 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2066 0, 0, 0, 0
2067};
2068
2069
2070static bfd *
2071make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
2072{
2073 asection *tx, *id7, *id5, *id4, *id6;
2074 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
2075 int len;
2076 char *oname;
2077 bfd *abfd;
2078 const unsigned char *jmp_bytes = NULL;
2079 int jmp_byte_count = 0;
2080
2081 /* Include the jump stub section only if it is needed. A jump
2082 stub is needed if the symbol being imported <sym> is a function
2083 symbol and there is at least one undefined reference to that
2084 symbol. In other words, if all the import references to <sym> are
2085 explicitly through _declspec(dllimport) then the jump stub is not
2086 needed. */
2087 if (include_jmp_stub)
2088 {
2089 switch (pe_details->pe_arch)
2090 {
2091 case PE_ARCH_i386:
2092 jmp_bytes = jmp_ix86_bytes;
2093 jmp_byte_count = sizeof (jmp_ix86_bytes);
2094 break;
2095 case PE_ARCH_sh:
2096 jmp_bytes = jmp_sh_bytes;
2097 jmp_byte_count = sizeof (jmp_sh_bytes);
2098 break;
2099 case PE_ARCH_mips:
2100 jmp_bytes = jmp_mips_bytes;
2101 jmp_byte_count = sizeof (jmp_mips_bytes);
2102 break;
2103 case PE_ARCH_arm:
2104 case PE_ARCH_arm_epoc:
2105 case PE_ARCH_arm_wince:
2106 jmp_bytes = jmp_arm_bytes;
2107 jmp_byte_count = sizeof (jmp_arm_bytes);
2108 break;
2109 default:
2110 abort ();
2111 }
2112 }
2113
2114 oname = xmalloc (20);
2115 sprintf (oname, "d%06d.o", tmp_seq);
2116 tmp_seq++;
2117
2118 abfd = bfd_create (oname, parent);
2119 bfd_find_target (pe_details->object_target, abfd);
2120 bfd_make_writable (abfd);
2121
2122 bfd_set_format (abfd, bfd_object);
2123 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2124
2125 symptr = 0;
2126 symtab = xmalloc (12 * sizeof (asymbol *));
2127
2128 tx = quick_section (abfd, ".text", SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY, 2);
2129 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2130 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2131 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2132 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
2133
2134 if (*exp->internal_name == '@')
2135 {
2136 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2137 BSF_GLOBAL, 0);
2138 if (include_jmp_stub)
2139 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
2140 quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
2141 BSF_GLOBAL, 0);
2142 /* Fastcall applies only to functions,
2143 so no need for auto-import symbol. */
2144 }
2145 else
2146 {
2147 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2148 BSF_GLOBAL, 0);
2149 if (include_jmp_stub)
2150 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
2151 BSF_GLOBAL, 0);
2152 quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
2153 BSF_GLOBAL, 0);
2154 /* Symbol to reference ord/name of imported
2155 data symbol, used to implement auto-import. */
2156 if (exp->flag_data)
2157 quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
2158 BSF_GLOBAL,0);
2159 }
2160 if (pe_dll_compat_implib)
2161 quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
2162 BSF_GLOBAL, 0);
2163
2164 if (include_jmp_stub)
2165 {
2166 bfd_set_section_size (abfd, tx, jmp_byte_count);
2167 td = xmalloc (jmp_byte_count);
2168 tx->contents = td;
2169 memcpy (td, jmp_bytes, jmp_byte_count);
2170
2171 switch (pe_details->pe_arch)
2172 {
2173 case PE_ARCH_i386:
2174#ifdef pe_use_x86_64
2175 quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
2176#else
2177 /* Mark this object as SAFESEH compatible. */
2178 quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
2179 BSF_LOCAL, 1);
2180 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
2181#endif
2182 break;
2183 case PE_ARCH_sh:
2184 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2185 break;
2186 case PE_ARCH_mips:
2187 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
2188 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
2189 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2190 break;
2191 case PE_ARCH_arm:
2192 case PE_ARCH_arm_epoc:
2193 case PE_ARCH_arm_wince:
2194 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2195 break;
2196 default:
2197 abort ();
2198 }
2199 save_relocs (tx);
2200 }
2201 else
2202 bfd_set_section_size (abfd, tx, 0);
2203
2204 bfd_set_section_size (abfd, id7, 4);
2205 d7 = xmalloc (4);
2206 id7->contents = d7;
2207 memset (d7, 0, 4);
2208 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2209 save_relocs (id7);
2210
2211 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2212 d5 = xmalloc (PE_IDATA5_SIZE);
2213 id5->contents = d5;
2214 memset (d5, 0, PE_IDATA5_SIZE);
2215
2216 if (exp->flag_noname)
2217 {
2218 d5[0] = exp->ordinal;
2219 d5[1] = exp->ordinal >> 8;
2220 d5[PE_IDATA5_SIZE - 1] = 0x80;
2221 }
2222 else
2223 {
2224 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2225 save_relocs (id5);
2226 }
2227
2228 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2229 d4 = xmalloc (PE_IDATA4_SIZE);
2230 id4->contents = d4;
2231 memset (d4, 0, PE_IDATA4_SIZE);
2232
2233 if (exp->flag_noname)
2234 {
2235 d4[0] = exp->ordinal;
2236 d4[1] = exp->ordinal >> 8;
2237 d4[PE_IDATA4_SIZE - 1] = 0x80;
2238 }
2239 else
2240 {
2241 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2242 save_relocs (id4);
2243 }
2244
2245 if (exp->flag_noname)
2246 {
2247 len = 0;
2248 bfd_set_section_size (abfd, id6, 0);
2249 }
2250 else
2251 {
2252 /* { short, asciz } */
2253 if (exp->its_name)
2254 len = 2 + strlen (exp->its_name) + 1;
2255 else
2256 len = 2 + strlen (exp->name) + 1;
2257 if (len & 1)
2258 len++;
2259 bfd_set_section_size (abfd, id6, len);
2260 d6 = xmalloc (len);
2261 id6->contents = d6;
2262 memset (d6, 0, len);
2263 d6[0] = exp->hint & 0xff;
2264 d6[1] = exp->hint >> 8;
2265 if (exp->its_name)
2266 strcpy ((char*) d6 + 2, exp->its_name);
2267 else
2268 strcpy ((char *) d6 + 2, exp->name);
2269 }
2270
2271 bfd_set_symtab (abfd, symtab, symptr);
2272
2273 if (include_jmp_stub)
2274 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2275 bfd_set_section_contents (abfd, id7, d7, 0, 4);
2276 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2277 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2278 if (!exp->flag_noname)
2279 bfd_set_section_contents (abfd, id6, d6, 0, len);
2280
2281 bfd_make_readable (abfd);
2282 return abfd;
2283}
2284
2285static bfd *
2286make_singleton_name_imp (const char *import, bfd *parent)
2287{
2288 /* Name thunks go to idata$4. */
2289 asection *id5;
2290 unsigned char *d5;
2291 char *oname;
2292 bfd *abfd;
2293
2294 oname = xmalloc (20);
2295 sprintf (oname, "nmimp%06d.o", tmp_seq2);
2296 tmp_seq2++;
2297
2298 abfd = bfd_create (oname, parent);
2299 bfd_find_target (pe_details->object_target, abfd);
2300 bfd_make_writable (abfd);
2301
2302 bfd_set_format (abfd, bfd_object);
2303 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2304
2305 symptr = 0;
2306 symtab = xmalloc (3 * sizeof (asymbol *));
2307 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2308 quick_symbol (abfd, "__imp_", import, "", id5, BSF_GLOBAL, 0);
2309
2310 /* We need space for the real thunk and for the null terminator. */
2311 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
2312 d5 = xmalloc (PE_IDATA5_SIZE * 2);
2313 id5->contents = d5;
2314 memset (d5, 0, PE_IDATA5_SIZE * 2);
2315 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2316 save_relocs (id5);
2317
2318 bfd_set_symtab (abfd, symtab, symptr);
2319
2320 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
2321
2322 bfd_make_readable (abfd);
2323 return abfd;
2324}
2325
2326static bfd *
2327make_singleton_name_thunk (const char *import, bfd *parent)
2328{
2329 /* Name thunks go to idata$4. */
2330 asection *id4;
2331 unsigned char *d4;
2332 char *oname;
2333 bfd *abfd;
2334
2335 oname = xmalloc (20);
2336 sprintf (oname, "nmth%06d.o", tmp_seq);
2337 tmp_seq++;
2338
2339 abfd = bfd_create (oname, parent);
2340 bfd_find_target (pe_details->object_target, abfd);
2341 bfd_make_writable (abfd);
2342
2343 bfd_set_format (abfd, bfd_object);
2344 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2345
2346 symptr = 0;
2347 symtab = xmalloc (3 * sizeof (asymbol *));
2348 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2349 quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
2350 quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
2351
2352 /* We need space for the real thunk and for the null terminator. */
2353 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2354 d4 = xmalloc (PE_IDATA4_SIZE * 2);
2355 id4->contents = d4;
2356 memset (d4, 0, PE_IDATA4_SIZE * 2);
2357 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2358 save_relocs (id4);
2359
2360 bfd_set_symtab (abfd, symtab, symptr);
2361
2362 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2363
2364 bfd_make_readable (abfd);
2365 return abfd;
2366}
2367
2368static char *
2369make_import_fixup_mark (arelent *rel)
2370{
2371 /* We convert reloc to symbol, for later reference. */
2372 static int counter;
2373 static char *fixup_name = NULL;
2374 static size_t buffer_len = 0;
2375
2376 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2377
2378 bfd *abfd = bfd_asymbol_bfd (sym);
2379 struct bfd_link_hash_entry *bh;
2380
2381 if (!fixup_name)
2382 {
2383 fixup_name = xmalloc (384);
2384 buffer_len = 384;
2385 }
2386
2387 if (strlen (sym->name) + 25 > buffer_len)
2388 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2389 bigger than 20 digits long, we've got worse problems than
2390 overflowing this buffer... */
2391 {
2392 free (fixup_name);
2393 /* New buffer size is length of symbol, plus 25, but
2394 then rounded up to the nearest multiple of 128. */
2395 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2396 fixup_name = xmalloc (buffer_len);
2397 }
2398
2399 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2400
2401 bh = NULL;
2402 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2403 current_sec, /* sym->section, */
2404 rel->address, NULL, TRUE, FALSE, &bh);
2405
2406 return fixup_name;
2407}
2408
2409/* .section .idata$2
2410 .rva __nm_thnk_SYM (singleton thunk with name of func)
2411 .long 0
2412 .long 0
2413 .rva __my_dll_iname (name of dll)
2414 .rva __fuNN_SYM (pointer to reference (address) in text) */
2415
2416static bfd *
2417make_import_fixup_entry (const char *name,
2418 const char *fixup_name,
2419 const char *symname,
2420 bfd *parent)
2421{
2422 asection *id2;
2423 unsigned char *d2;
2424 char *oname;
2425 bfd *abfd;
2426
2427 oname = xmalloc (20);
2428 sprintf (oname, "fu%06d.o", tmp_seq);
2429 tmp_seq++;
2430
2431 abfd = bfd_create (oname, parent);
2432 bfd_find_target (pe_details->object_target, abfd);
2433 bfd_make_writable (abfd);
2434
2435 bfd_set_format (abfd, bfd_object);
2436 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2437
2438 symptr = 0;
2439 symtab = xmalloc (6 * sizeof (asymbol *));
2440 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2441
2442 quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
2443 quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2444 /* For relocator v2 we have to use the .idata$5 element and not
2445 fixup_name. */
2446 if (link_info.pei386_runtime_pseudo_reloc == 2)
2447 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2448 else
2449 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2450
2451 bfd_set_section_size (abfd, id2, 20);
2452 d2 = xmalloc (20);
2453 id2->contents = d2;
2454 memset (d2, 0, 20);
2455
2456 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2457 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2458 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2459 save_relocs (id2);
2460
2461 bfd_set_symtab (abfd, symtab, symptr);
2462
2463 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2464
2465 bfd_make_readable (abfd);
2466 return abfd;
2467}
2468
2469/* .section .rdata_runtime_pseudo_reloc
2470 .long addend
2471 .rva __fuNN_SYM (pointer to reference (address) in text) */
2472
2473static bfd *
2474make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2475 const char *fixup_name,
2476 bfd_vma addend ATTRIBUTE_UNUSED,
2477 bfd_vma bitsize,
2478 bfd *parent)
2479{
2480 asection *rt_rel;
2481 unsigned char *rt_rel_d;
2482 char *oname;
2483 bfd *abfd;
2484 oname = xmalloc (20);
2485 sprintf (oname, "rtr%06d.o", tmp_seq);
2486 tmp_seq++;
2487
2488 abfd = bfd_create (oname, parent);
2489 bfd_find_target (pe_details->object_target, abfd);
2490 bfd_make_writable (abfd);
2491
2492 bfd_set_format (abfd, bfd_object);
2493 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2494
2495 symptr = 0;
2496 if (link_info.pei386_runtime_pseudo_reloc == 2)
2497 {
2498 symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
2499 }
2500 else
2501 {
2502 symtab = xmalloc (2 * sizeof (asymbol *));
2503 }
2504 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2505 SEC_HAS_CONTENTS, 2);
2506
2507 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2508
2509 if (link_info.pei386_runtime_pseudo_reloc == 2)
2510 {
2511 size_t size = 12;
2512 if (! runtime_pseudp_reloc_v2_init)
2513 {
2514 size += 12;
2515 runtime_pseudp_reloc_v2_init = 1;
2516 }
2517 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2518
2519 bfd_set_section_size (abfd, rt_rel, size);
2520 rt_rel_d = xmalloc (size);
2521 rt_rel->contents = rt_rel_d;
2522 memset (rt_rel_d, 0, size);
2523 quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
2524 quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
2525 bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
2526 if (size != 12)
2527 bfd_put_32 (abfd, 1, rt_rel_d + 8);
2528 save_relocs (rt_rel);
2529
2530 bfd_set_symtab (abfd, symtab, symptr);
2531
2532 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
2533 }
2534 else
2535 {
2536 bfd_set_section_size (abfd, rt_rel, 8);
2537 rt_rel_d = xmalloc (8);
2538 rt_rel->contents = rt_rel_d;
2539 memset (rt_rel_d, 0, 8);
2540
2541 bfd_put_32 (abfd, addend, rt_rel_d);
2542 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2543
2544 save_relocs (rt_rel);
2545
2546 bfd_set_symtab (abfd, symtab, symptr);
2547
2548 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2549 }
2550 bfd_make_readable (abfd);
2551 return abfd;
2552}
2553
2554/* .section .rdata
2555 .rva __pei386_runtime_relocator */
2556
2557static bfd *
2558pe_create_runtime_relocator_reference (bfd *parent)
2559{
2560 asection *extern_rt_rel;
2561 unsigned char *extern_rt_rel_d;
2562 char *oname;
2563 bfd *abfd;
2564
2565 oname = xmalloc (20);
2566 sprintf (oname, "ertr%06d.o", tmp_seq);
2567 tmp_seq++;
2568
2569 abfd = bfd_create (oname, parent);
2570 bfd_find_target (pe_details->object_target, abfd);
2571 bfd_make_writable (abfd);
2572
2573 bfd_set_format (abfd, bfd_object);
2574 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2575
2576 symptr = 0;
2577 symtab = xmalloc (2 * sizeof (asymbol *));
2578 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2579
2580 quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2581 BSF_NO_FLAGS, 0);
2582
2583 bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
2584 extern_rt_rel_d = xmalloc (PE_IDATA5_SIZE);
2585 extern_rt_rel->contents = extern_rt_rel_d;
2586
2587 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2588 save_relocs (extern_rt_rel);
2589
2590 bfd_set_symtab (abfd, symtab, symptr);
2591
2592 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
2593
2594 bfd_make_readable (abfd);
2595 return abfd;
2596}
2597
2598void
2599pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend)
2600{
2601 char buf[300];
2602 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2603 struct bfd_link_hash_entry *name_thunk_sym;
2604 struct bfd_link_hash_entry *name_imp_sym;
2605 const char *name = sym->name;
2606 char *fixup_name = make_import_fixup_mark (rel);
2607 bfd *b;
2608 int need_import_table = 1;
2609
2610 sprintf (buf, "__imp_%s", name);
2611 name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2612
2613 sprintf (buf, "__nm_thnk_%s", name);
2614
2615 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2616
2617 /* For version 2 pseudo relocation we don't need to add an import
2618 if the import symbol is already present. */
2619 if (link_info.pei386_runtime_pseudo_reloc == 2
2620 && name_imp_sym
2621 && name_imp_sym->type == bfd_link_hash_defined)
2622 need_import_table = 0;
2623
2624 if (need_import_table == 1
2625 && (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined))
2626 {
2627 b = make_singleton_name_thunk (name, link_info.output_bfd);
2628 add_bfd_to_link (b, b->filename, &link_info);
2629
2630 /* If we ever use autoimport, we have to cast text section writable.
2631 But not for version 2. */
2632 if (link_info.pei386_runtime_pseudo_reloc != 2)
2633 {
2634 config.text_read_only = FALSE;
2635 link_info.output_bfd->flags &= ~WP_TEXT;
2636 }
2637 if (link_info.pei386_runtime_pseudo_reloc == 2)
2638 {
2639 b = make_singleton_name_imp (name, link_info.output_bfd);
2640 add_bfd_to_link (b, b->filename, &link_info);
2641 }
2642 }
2643
2644 if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2645 && need_import_table == 1)
2646 {
2647 extern char * pe_data_import_dll;
2648 char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2649
2650 b = make_import_fixup_entry (name, fixup_name, symname,
2651 link_info.output_bfd);
2652 add_bfd_to_link (b, b->filename, &link_info);
2653 }
2654
2655 if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
2656 || link_info.pei386_runtime_pseudo_reloc == 2)
2657 {
2658 if (pe_dll_extra_pe_debug)
2659 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2660 fixup_name, (int) addend);
2661
2662 b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
2663 link_info.output_bfd);
2664 add_bfd_to_link (b, b->filename, &link_info);
2665
2666 if (runtime_pseudo_relocs_created == 0)
2667 {
2668 b = pe_create_runtime_relocator_reference (link_info.output_bfd);
2669 add_bfd_to_link (b, b->filename, &link_info);
2670 }
2671 runtime_pseudo_relocs_created++;
2672 }
2673 else if (addend != 0)
2674 {
2675 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2676 s->owner, s, rel->address, sym->name);
2677 einfo ("%X");
2678 }
2679}
2680
2681
2682void
2683pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
2684{
2685 int i;
2686 bfd *ar_head;
2687 bfd *ar_tail;
2688 bfd *outarch;
2689 bfd *ibfd;
2690 bfd *head = 0;
2691
2692 dll_filename = (def->name) ? def->name : dll_name;
2693 dll_symname = xstrdup (dll_filename);
2694 for (i = 0; dll_symname[i]; i++)
2695 if (!ISALNUM (dll_symname[i]))
2696 dll_symname[i] = '_';
2697
2698 unlink_if_ordinary (impfilename);
2699
2700 outarch = bfd_openw (impfilename, 0);
2701
2702 if (!outarch)
2703 {
2704 /* xgettext:c-format */
2705 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2706 return;
2707 }
2708
2709 /* xgettext:c-format */
2710 info_msg (_("Creating library file: %s\n"), impfilename);
2711
2712 bfd_set_format (outarch, bfd_archive);
2713 outarch->has_armap = 1;
2714
2715 /* Work out a reasonable size of things to put onto one line. */
2716 ar_head = make_head (outarch);
2717
2718 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2719 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next)
2720 {
2721 /* Iterate the exclude list. */
2722 struct exclude_list_struct *ex;
2723 char found;
2724 for (ex = excludes, found = 0; ex && !found; ex = ex->next)
2725 {
2726 if (ex->type != EXCLUDEFORIMPLIB)
2727 continue;
2728 found = (filename_cmp (ex->string, ibfd->filename) == 0);
2729 }
2730 /* If it matched, we must open a fresh BFD for it (the original
2731 input BFD is still needed for the DLL's final link) and add
2732 it into the archive member chain. */
2733 if (found)
2734 {
2735 bfd *newbfd = bfd_openr (ibfd->my_archive
2736 ? ibfd->my_archive->filename : ibfd->filename, NULL);
2737 if (!newbfd)
2738 {
2739 einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
2740 return;
2741 }
2742 if (ibfd->my_archive)
2743 {
2744 /* Must now iterate through archive until we find the
2745 required member. A minor shame that we'll open the
2746 archive once per member that we require from it, and
2747 leak those archive bfds rather than reuse them. */
2748 bfd *arbfd = newbfd;
2749 if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
2750 {
2751 einfo (_("%X%s(%s): can't find member in non-archive file"),
2752 ibfd->my_archive->filename, ibfd->filename);
2753 return;
2754 }
2755 newbfd = NULL;
2756 while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
2757 {
2758 if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
2759 break;
2760 }
2761 if (!newbfd)
2762 {
2763 einfo (_("%X%s(%s): can't find member in archive"),
2764 ibfd->my_archive->filename, ibfd->filename);
2765 return;
2766 }
2767 }
2768 newbfd->archive_next = head;
2769 head = newbfd;
2770 }
2771 }
2772
2773 for (i = 0; i < def->num_exports; i++)
2774 {
2775 /* The import library doesn't know about the internal name. */
2776 char *internal = def->exports[i].internal_name;
2777 bfd *n;
2778
2779 /* Don't add PRIVATE entries to import lib. */
2780 if (pe_def_file->exports[i].flag_private)
2781 continue;
2782 def->exports[i].internal_name = def->exports[i].name;
2783 n = make_one (def->exports + i, outarch,
2784 ! (def->exports + i)->flag_data);
2785 n->archive_next = head;
2786 head = n;
2787 def->exports[i].internal_name = internal;
2788 }
2789
2790 ar_tail = make_tail (outarch);
2791
2792 if (ar_head == NULL || ar_tail == NULL)
2793 return;
2794
2795 /* Now stick them all into the archive. */
2796 ar_head->archive_next = head;
2797 ar_tail->archive_next = ar_head;
2798 head = ar_tail;
2799
2800 if (! bfd_set_archive_head (outarch, head))
2801 einfo ("%Xbfd_set_archive_head: %E\n");
2802
2803 if (! bfd_close (outarch))
2804 einfo ("%Xbfd_close %s: %E\n", impfilename);
2805
2806 while (head != NULL)
2807 {
2808 bfd *n = head->archive_next;
2809 bfd_close (head);
2810 head = n;
2811 }
2812}
2813
2814static struct bfd_link_hash_entry *found_sym;
2815
2816static bfd_boolean
2817pe_undef_alias_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
2818{
2819 int sl;
2820 char *string = inf;
2821 const char *hs = h->root.string;
2822
2823 sl = strlen (string);
2824 if (h->type == bfd_link_hash_undefined
2825 && ((*hs == '@' && (!pe_details->underscored || *string == '_')
2826 && strncmp (hs + 1, string + (pe_details->underscored != 0),
2827 sl - (pe_details->underscored != 0)) == 0)
2828 || strncmp (hs, string, sl) == 0)
2829 && h->root.string[sl] == '@')
2830 {
2831 found_sym = h;
2832 return FALSE;
2833 }
2834 return TRUE;
2835}
2836
2837static struct bfd_link_hash_entry *
2838pe_find_cdecl_alias_match (char *name)
2839{
2840 found_sym = 0;
2841 bfd_link_hash_traverse (link_info.hash, pe_undef_alias_cdecl_match,
2842 (char *) name);
2843 return found_sym;
2844}
2845
2846static void
2847add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
2848{
2849 lang_input_statement_type *fake_file;
2850
2851 fake_file = lang_add_input_file (name,
2852 lang_input_file_is_fake_enum,
2853 NULL);
2854 fake_file->the_bfd = abfd;
2855 ldlang_add_file (fake_file);
2856
2857 if (!bfd_link_add_symbols (abfd, linfo))
2858 einfo ("%Xaddsym %s: %E\n", name);
2859}
2860
2861void
2862pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
2863{
2864 def_file_module *module;
2865
2866 pe_dll_id_target (bfd_get_target (output_bfd));
2867
2868 if (!pe_def_file)
2869 return;
2870
2871 for (module = pe_def_file->modules; module; module = module->next)
2872 {
2873 int i, do_this_dll;
2874
2875 dll_filename = module->name;
2876 dll_symname = xstrdup (module->name);
2877 for (i = 0; dll_symname[i]; i++)
2878 if (!ISALNUM (dll_symname[i]))
2879 dll_symname[i] = '_';
2880
2881 do_this_dll = 0;
2882
2883 for (i = 0; i < pe_def_file->num_imports; i++)
2884 if (pe_def_file->imports[i].module == module)
2885 {
2886 def_file_export exp;
2887 struct bfd_link_hash_entry *blhe;
2888 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2889 /* See if we need this import. */
2890 size_t len = strlen (pe_def_file->imports[i].internal_name);
2891 char *name = xmalloc (len + 2 + 6);
2892 bfd_boolean include_jmp_stub = FALSE;
2893 bfd_boolean is_cdecl = FALSE;
2894 if (!lead_at && strchr (pe_def_file->imports[i].internal_name, '@') == NULL)
2895 is_cdecl = TRUE;
2896
2897 if (lead_at)
2898 sprintf (name, "%s",
2899 pe_def_file->imports[i].internal_name);
2900 else
2901 sprintf (name, "%s%s",U (""),
2902 pe_def_file->imports[i].internal_name);
2903
2904 blhe = bfd_link_hash_lookup (linfo->hash, name,
2905 FALSE, FALSE, FALSE);
2906
2907 /* Include the jump stub for <sym> only if the <sym>
2908 is undefined. */
2909 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2910 {
2911 if (lead_at)
2912 sprintf (name, "%s%s", "__imp_",
2913 pe_def_file->imports[i].internal_name);
2914 else
2915 sprintf (name, "%s%s%s", "__imp_", U (""),
2916 pe_def_file->imports[i].internal_name);
2917
2918 blhe = bfd_link_hash_lookup (linfo->hash, name,
2919 FALSE, FALSE, FALSE);
2920 }
2921 else
2922 include_jmp_stub = TRUE;
2923
2924 if (is_cdecl && !blhe)
2925 {
2926 sprintf (name, "%s%s",U (""),
2927 pe_def_file->imports[i].internal_name);
2928 blhe = pe_find_cdecl_alias_match (name);
2929 include_jmp_stub = TRUE;
2930 }
2931
2932 free (name);
2933
2934 if (blhe && blhe->type == bfd_link_hash_undefined)
2935 {
2936 bfd *one;
2937 /* We do. */
2938 if (!do_this_dll)
2939 {
2940 bfd *ar_head = make_head (output_bfd);
2941 add_bfd_to_link (ar_head, ar_head->filename, linfo);
2942 do_this_dll = 1;
2943 }
2944 exp.internal_name = pe_def_file->imports[i].internal_name;
2945 exp.name = pe_def_file->imports[i].name;
2946 exp.its_name = pe_def_file->imports[i].its_name;
2947 exp.ordinal = pe_def_file->imports[i].ordinal;
2948 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2949 exp.flag_private = 0;
2950 exp.flag_constant = 0;
2951 exp.flag_data = pe_def_file->imports[i].data;
2952 exp.flag_noname = exp.name ? 0 : 1;
2953 one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
2954 add_bfd_to_link (one, one->filename, linfo);
2955 }
2956 }
2957 if (do_this_dll)
2958 {
2959 bfd *ar_tail = make_tail (output_bfd);
2960 add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
2961 }
2962
2963 free (dll_symname);
2964 }
2965}
2966
2967/* We were handed a *.DLL file. Parse it and turn it into a set of
2968 IMPORTS directives in the def file. Return TRUE if the file was
2969 handled, FALSE if not. */
2970
2971static unsigned int
2972pe_get16 (bfd *abfd, int where)
2973{
2974 unsigned char b[2];
2975
2976 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2977 bfd_bread (b, (bfd_size_type) 2, abfd);
2978 return b[0] + (b[1] << 8);
2979}
2980
2981static unsigned int
2982pe_get32 (bfd *abfd, int where)
2983{
2984 unsigned char b[4];
2985
2986 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2987 bfd_bread (b, (bfd_size_type) 4, abfd);
2988 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2989}
2990
2991static unsigned int
2992pe_as32 (void *ptr)
2993{
2994 unsigned char *b = ptr;
2995
2996 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2997}
2998
2999bfd_boolean
3000pe_implied_import_dll (const char *filename)
3001{
3002 bfd *dll;
3003 bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
3004 bfd_vma export_rva, export_size, nsections, secptr, expptr;
3005 bfd_vma exp_funcbase;
3006 unsigned char *expdata;
3007 char *erva;
3008 bfd_vma name_rvas, nexp;
3009 const char *dllname;
3010 /* Initialization with start > end guarantees that is_data
3011 will not be set by mistake, and avoids compiler warning. */
3012 bfd_vma data_start = 1;
3013 bfd_vma data_end = 0;
3014 bfd_vma rdata_start = 1;
3015 bfd_vma rdata_end = 0;
3016 bfd_vma bss_start = 1;
3017 bfd_vma bss_end = 0;
3018
3019 /* No, I can't use bfd here. kernel32.dll puts its export table in
3020 the middle of the .rdata section. */
3021 dll = bfd_openr (filename, pe_details->target_name);
3022 if (!dll)
3023 {
3024 einfo ("%Xopen %s: %E\n", filename);
3025 return FALSE;
3026 }
3027
3028 /* PEI dlls seem to be bfd_objects. */
3029 if (!bfd_check_format (dll, bfd_object))
3030 {
3031 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
3032 return FALSE;
3033 }
3034
3035 /* Get pe_header, optional header and numbers of directory entries. */
3036 pe_header_offset = pe_get32 (dll, 0x3c);
3037 opthdr_ofs = pe_header_offset + 4 + 20;
3038#ifdef pe_use_x86_64
3039 num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3040#else
3041 num_entries = pe_get32 (dll, opthdr_ofs + 92);
3042#endif
3043
3044 /* No import or export directory entry. */
3045 if (num_entries < 1)
3046 return FALSE;
3047
3048#ifdef pe_use_x86_64
3049 export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
3050 export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
3051#else
3052 export_rva = pe_get32 (dll, opthdr_ofs + 96);
3053 export_size = pe_get32 (dll, opthdr_ofs + 100);
3054#endif
3055
3056 /* No export table - nothing to export. */
3057 if (export_size == 0)
3058 return FALSE;
3059
3060 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
3061 secptr = (pe_header_offset + 4 + 20 +
3062 pe_get16 (dll, pe_header_offset + 4 + 16));
3063 expptr = 0;
3064
3065 /* Get the rva and size of the export section. */
3066 for (i = 0; i < nsections; i++)
3067 {
3068 char sname[8];
3069 bfd_vma secptr1 = secptr + 40 * i;
3070 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3071 bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
3072 bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
3073
3074 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
3075 bfd_bread (sname, (bfd_size_type) 8, dll);
3076
3077 if (vaddr <= export_rva && vaddr + vsize > export_rva)
3078 {
3079 expptr = fptr + (export_rva - vaddr);
3080 if (export_rva + export_size > vaddr + vsize)
3081 export_size = vsize - (export_rva - vaddr);
3082 break;
3083 }
3084 }
3085
3086 /* Scan sections and store the base and size of the
3087 data and bss segments in data/base_start/end. */
3088 for (i = 0; i < nsections; i++)
3089 {
3090 bfd_vma secptr1 = secptr + 40 * i;
3091 bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
3092 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3093 bfd_vma flags = pe_get32 (dll, secptr1 + 36);
3094 char sec_name[9];
3095
3096 sec_name[8] = '\0';
3097 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
3098 bfd_bread (sec_name, (bfd_size_type) 8, dll);
3099
3100 if (strcmp(sec_name,".data") == 0)
3101 {
3102 data_start = vaddr;
3103 data_end = vaddr + vsize;
3104
3105 if (pe_dll_extra_pe_debug)
3106 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3107 __FUNCTION__, sec_name, (unsigned long) vaddr,
3108 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3109 }
3110 else if (strcmp(sec_name,".rdata") == 0)
3111 {
3112 rdata_start = vaddr;
3113 rdata_end = vaddr + vsize;
3114
3115 if (pe_dll_extra_pe_debug)
3116 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3117 __FUNCTION__, sec_name, (unsigned long) vaddr,
3118 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3119 }
3120 else if (strcmp (sec_name,".bss") == 0)
3121 {
3122 bss_start = vaddr;
3123 bss_end = vaddr + vsize;
3124
3125 if (pe_dll_extra_pe_debug)
3126 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3127 __FUNCTION__, sec_name, (unsigned long) vaddr,
3128 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3129 }
3130 }
3131
3132 expdata = xmalloc (export_size);
3133 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
3134 bfd_bread (expdata, (bfd_size_type) export_size, dll);
3135 erva = (char *) expdata - export_rva;
3136
3137 if (pe_def_file == 0)
3138 pe_def_file = def_file_empty ();
3139
3140 nexp = pe_as32 (expdata + 24);
3141 name_rvas = pe_as32 (expdata + 32);
3142 exp_funcbase = pe_as32 (expdata + 28);
3143
3144 /* Use internal dll name instead of filename
3145 to enable symbolic dll linking. */
3146 dllname = erva + pe_as32 (expdata + 12);
3147
3148 /* Check to see if the dll has already been added to
3149 the definition list and if so return without error.
3150 This avoids multiple symbol definitions. */
3151 if (def_get_module (pe_def_file, dllname))
3152 {
3153 if (pe_dll_extra_pe_debug)
3154 printf ("%s is already loaded\n", dllname);
3155 return TRUE;
3156 }
3157
3158 /* Iterate through the list of symbols. */
3159 for (i = 0; i < nexp; i++)
3160 {
3161 /* Pointer to the names vector. */
3162 bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3163 def_file_import *imp;
3164 /* Pointer to the function address vector. */
3165 bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3166 int is_data = 0;
3167
3168 /* Skip unwanted symbols, which are
3169 exported in buggy auto-import releases. */
3170 if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
3171 {
3172 int is_dup = 0;
3173 /* is_data is true if the address is in the data, rdata or bss
3174 segment. */
3175 is_data =
3176 (func_rva >= data_start && func_rva < data_end)
3177 || (func_rva >= rdata_start && func_rva < rdata_end)
3178 || (func_rva >= bss_start && func_rva < bss_end);
3179
3180 imp = def_file_add_import (pe_def_file, erva + name_rva,
3181 dllname, i, 0, NULL, &is_dup);
3182 /* Mark symbol type. */
3183 if (!is_dup)
3184 imp->data = is_data;
3185
3186 if (pe_dll_extra_pe_debug)
3187 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3188 __FUNCTION__, dllname, erva + name_rva,
3189 (unsigned long) func_rva, is_data ? "(data)" : "");
3190 }
3191 }
3192
3193 return TRUE;
3194}
3195
3196void
3197pe_output_file_set_long_section_names (bfd *abfd)
3198{
3199 if (pe_use_coff_long_section_names < 0)
3200 return;
3201 if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
3202 einfo (_("%XError: can't use long section names on this arch\n"));
3203}
3204
3205/* These are the main functions, called from the emulation. The first
3206 is called after the bfds are read, so we can guess at how much space
3207 we need. The second is called after everything is placed, so we
3208 can put the right values in place. */
3209
3210void
3211pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
3212{
3213 pe_dll_id_target (bfd_get_target (abfd));
3214 pe_output_file_set_long_section_names (abfd);
3215 process_def_file_and_drectve (abfd, info);
3216
3217 if (pe_def_file->num_exports == 0 && !info->shared)
3218 return;
3219
3220 generate_edata (abfd, info);
3221 build_filler_bfd (1);
3222 pe_output_file_set_long_section_names (filler_bfd);
3223}
3224
3225void
3226pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3227{
3228 pe_dll_id_target (bfd_get_target (abfd));
3229 pe_output_file_set_long_section_names (abfd);
3230 build_filler_bfd (0);
3231 pe_output_file_set_long_section_names (filler_bfd);
3232}
3233
3234void
3235pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
3236{
3237 pe_dll_id_target (bfd_get_target (abfd));
3238 pe_output_file_set_long_section_names (abfd);
3239 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3240
3241 generate_reloc (abfd, info);
3242 if (reloc_sz > 0)
3243 {
3244 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3245
3246 /* Resize the sections. */
3247 lang_reset_memory_regions ();
3248 lang_size_sections (NULL, TRUE);
3249
3250 /* Redo special stuff. */
3251 ldemul_after_allocation ();
3252
3253 /* Do the assignments again. */
3254 lang_do_assignments (lang_final_phase_enum);
3255 }
3256
3257 fill_edata (abfd, info);
3258
3259 if (info->shared && !info->pie)
3260 pe_data (abfd)->dll = 1;
3261
3262 edata_s->contents = edata_d;
3263 reloc_s->contents = reloc_d;
3264}
3265
3266void
3267pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
3268{
3269 pe_dll_id_target (bfd_get_target (abfd));
3270 pe_output_file_set_long_section_names (abfd);
3271 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3272
3273 generate_reloc (abfd, info);
3274 if (reloc_sz > 0)
3275 {
3276 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3277
3278 /* Resize the sections. */
3279 lang_reset_memory_regions ();
3280 lang_size_sections (NULL, TRUE);
3281
3282 /* Redo special stuff. */
3283 ldemul_after_allocation ();
3284
3285 /* Do the assignments again. */
3286 lang_do_assignments (lang_final_phase_enum);
3287 }
3288 reloc_s->contents = reloc_d;
3289}
3290
3291bfd_boolean
3292pe_bfd_is_dll (bfd *abfd)
3293{
3294 return (bfd_get_format (abfd) == bfd_object
3295 && obj_pe (abfd)
3296 && pe_data (abfd)->dll);
3297}
This page took 0.032869 seconds and 4 git commands to generate.