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