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