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