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