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