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