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