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