1# This shell script emits a C file. -*- C -*- 2# It does some substitutions. 3test -z "${ENTRY}" && ENTRY="_mainCRTStartup" 4if [ -z "$MACHINE" ]; then 5 OUTPUT_ARCH=${ARCH} 6else 7 OUTPUT_ARCH=${ARCH}:${MACHINE} 8fi 9rm -f e${EMULATION_NAME}.c 10(echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-) 11fragment <<EOF 12/* Copyright 2006, 2007, 2008 Free Software Foundation, Inc. 13 Written by Kai Tietz, OneVision Software GmbH&CoKg. 14 15 This file is part of the GNU Binutils. 16 17 This program is free software; you can redistribute it and/or modify 18 it under the terms of the GNU General Public License as published by 19 the Free Software Foundation; either version 3 of the License, or 20 (at your option) any later version. 21 22 This program is distributed in the hope that it will be useful, 23 but WITHOUT ANY WARRANTY; without even the implied warranty of 24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 GNU General Public License for more details. 26 27 You should have received a copy of the GNU General Public License 28 along with this program; if not, write to the Free Software 29 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 30 MA 02110-1301, USA. */ 31 32 33/* For WINDOWS_XP64 and higher */ 34/* Based on pe.em, but modified for 64 bit support. */ 35 36#define TARGET_IS_${EMULATION_NAME} 37 38#define COFF_IMAGE_WITH_PE 39#define COFF_WITH_PE 40#define COFF_WITH_pex64 41 42#include "sysdep.h" 43#include "bfd.h" 44#include "bfdlink.h" 45#include "getopt.h" 46#include "libiberty.h" 47#include "ld.h" 48#include "ldmain.h" 49#include "ldexp.h" 50#include "ldlang.h" 51#include "ldfile.h" 52#include "ldemul.h" 53#include <ldgram.h> 54#include "ldlex.h" 55#include "ldmisc.h" 56#include "ldctor.h" 57#include "coff/internal.h" 58 59/* FIXME: See bfd/peXXigen.c for why we include an architecture specific 60 header in generic PE code. */ 61#include "coff/x86_64.h" 62#include "coff/pe.h" 63 64/* FIXME: This is a BFD internal header file, and we should not be 65 using it here. */ 66#include "../bfd/libcoff.h" 67 68#undef AOUTSZ 69#define AOUTSZ PEPAOUTSZ 70#define PEAOUTHDR PEPAOUTHDR 71 72#include "deffile.h" 73#include "pep-dll.h" 74#include "safe-ctype.h" 75 76/* Permit the emulation parameters to override the default section 77 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes 78 it seem that include/coff/internal.h should not define 79 PE_DEF_SECTION_ALIGNMENT. */ 80#if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT} 81#undef PE_DEF_SECTION_ALIGNMENT 82#define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT} 83#endif 84 85#ifdef TARGET_IS_i386pep 86#define DLL_SUPPORT 87#endif 88 89#if defined(TARGET_IS_i386pep) || ! defined(DLL_SUPPORT) 90#define PE_DEF_SUBSYSTEM 3 91#else 92#undef NT_EXE_IMAGE_BASE 93#define NT_EXE_IMAGE_BASE 0x00010000 94#undef PE_DEF_SECTION_ALIGNMENT 95#define PE_DEF_SUBSYSTEM 2 96#undef PE_DEF_FILE_ALIGNMENT 97#define PE_DEF_FILE_ALIGNMENT 0x00000200 98#define PE_DEF_SECTION_ALIGNMENT 0x00000400 99#endif 100 101 102static struct internal_extra_pe_aouthdr pep; 103static int dll; 104static flagword real_flags = IMAGE_FILE_LARGE_ADDRESS_AWARE; 105static int support_old_code = 0; 106static lang_assignment_statement_type *image_base_statement = 0; 107 108#ifdef DLL_SUPPORT 109static int pep_enable_stdcall_fixup = 1; /* 0=disable 1=enable (default). */ 110static char * pep_out_def_filename = NULL; 111static char * pep_implib_filename = NULL; 112static int pep_enable_auto_image_base = 0; 113static char * pep_dll_search_prefix = NULL; 114#endif 115 116extern const char *output_filename; 117 118static void 119gld_${EMULATION_NAME}_before_parse (void) 120{ 121 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`); 122 output_filename = "${EXECUTABLE_NAME:-a.exe}"; 123#ifdef DLL_SUPPORT 124 config.dynamic_link = TRUE; 125 config.has_shared = 1; 126 link_info.pei386_auto_import = -1; 127 link_info.pei386_runtime_pseudo_reloc = -1; 128 129#if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2) 130 lang_default_entry ("_WinMainCRTStartup"); 131#else 132 lang_default_entry ("${ENTRY}"); 133#endif 134#endif 135} 136 137/* PE format extra command line options. */ 138 139/* Used for setting flags in the PE header. */ 140enum options 141{ 142 OPTION_BASE_FILE = 300 + 1, 143 OPTION_DLL, 144 OPTION_FILE_ALIGNMENT, 145 OPTION_IMAGE_BASE, 146 OPTION_MAJOR_IMAGE_VERSION, 147 OPTION_MAJOR_OS_VERSION, 148 OPTION_MAJOR_SUBSYSTEM_VERSION, 149 OPTION_MINOR_IMAGE_VERSION, 150 OPTION_MINOR_OS_VERSION, 151 OPTION_MINOR_SUBSYSTEM_VERSION, 152 OPTION_SECTION_ALIGNMENT, 153 OPTION_STACK, 154 OPTION_SUBSYSTEM, 155 OPTION_HEAP, 156 OPTION_SUPPORT_OLD_CODE, 157 OPTION_OUT_DEF, 158 OPTION_EXPORT_ALL, 159 OPTION_EXCLUDE_SYMBOLS, 160 OPTION_KILL_ATS, 161 OPTION_STDCALL_ALIASES, 162 OPTION_ENABLE_STDCALL_FIXUP, 163 OPTION_DISABLE_STDCALL_FIXUP, 164 OPTION_IMPLIB_FILENAME, 165 OPTION_WARN_DUPLICATE_EXPORTS, 166 OPTION_IMP_COMPAT, 167 OPTION_ENABLE_AUTO_IMAGE_BASE, 168 OPTION_DISABLE_AUTO_IMAGE_BASE, 169 OPTION_DLL_SEARCH_PREFIX, 170 OPTION_NO_DEFAULT_EXCLUDES, 171 OPTION_DLL_ENABLE_AUTO_IMPORT, 172 OPTION_DLL_DISABLE_AUTO_IMPORT, 173 OPTION_ENABLE_EXTRA_PE_DEBUG, 174 OPTION_EXCLUDE_LIBS, 175 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC, 176 OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC 177}; 178 179static void 180gld${EMULATION_NAME}_add_options 181 (int ns ATTRIBUTE_UNUSED, 182 char **shortopts ATTRIBUTE_UNUSED, 183 int nl, 184 struct option **longopts, 185 int nrl ATTRIBUTE_UNUSED, 186 struct option **really_longopts ATTRIBUTE_UNUSED) 187{ 188 static const struct option xtra_long[] = 189 { 190 /* PE options */ 191 {"base-file", required_argument, NULL, OPTION_BASE_FILE}, 192 {"dll", no_argument, NULL, OPTION_DLL}, 193 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT}, 194 {"heap", required_argument, NULL, OPTION_HEAP}, 195 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE}, 196 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION}, 197 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION}, 198 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION}, 199 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION}, 200 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION}, 201 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION}, 202 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT}, 203 {"stack", required_argument, NULL, OPTION_STACK}, 204 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM}, 205 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE}, 206#ifdef DLL_SUPPORT 207 /* getopt allows abbreviations, so we do this to stop it 208 from treating -o as an abbreviation for this option. */ 209 {"output-def", required_argument, NULL, OPTION_OUT_DEF}, 210 {"output-def", required_argument, NULL, OPTION_OUT_DEF}, 211 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL}, 212 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS}, 213 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS}, 214 {"kill-at", no_argument, NULL, OPTION_KILL_ATS}, 215 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES}, 216 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP}, 217 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP}, 218 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME}, 219 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS}, 220 /* getopt() allows abbreviations, so we do this to stop it from 221 treating -c as an abbreviation for these --compat-implib. */ 222 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT}, 223 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT}, 224 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE}, 225 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE}, 226 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX}, 227 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES}, 228 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT}, 229 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT}, 230 {"enable-extra-pep-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG}, 231 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC}, 232 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC}, 233#endif 234 {NULL, no_argument, NULL, 0} 235 }; 236 237 *longopts = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long)); 238 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); 239} 240 241/* PE/WIN32; added routines to get the subsystem type, heap and/or stack 242 parameters which may be input from the command line. */ 243 244typedef struct 245{ 246 void *ptr; 247 int size; 248 bfd_vma value; 249 char *symbol; 250 int inited; 251} definfo; 252 253#define D(field,symbol,def) {&pep.field,sizeof(pep.field), def, symbol,0} 254 255static definfo init[] = 256{ 257 /* imagebase must be first */ 258#define IMAGEBASEOFF 0 259 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE), 260#define DLLOFF 1 261 {&dll, sizeof(dll), 0, "__dll__", 0}, 262#define MSIMAGEBASEOFF 2 263 D(ImageBase,"___ImageBase", NT_EXE_IMAGE_BASE), 264 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT), 265 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT), 266 D(MajorOperatingSystemVersion,"__major_os_version__", 4), 267 D(MinorOperatingSystemVersion,"__minor_os_version__", 0), 268 D(MajorImageVersion,"__major_image_version__", 0), 269 D(MinorImageVersion,"__minor_image_version__", 0), 270 D(MajorSubsystemVersion,"__major_subsystem_version__", 5), 271 D(MinorSubsystemVersion,"__minor_subsystem_version__", 2), 272 D(Subsystem,"__subsystem__", ${SUBSYSTEM}), 273 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000), 274 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000), 275 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000), 276 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000), 277 D(LoaderFlags,"__loader_flags__", 0x0), 278 { NULL, 0, 0, NULL, 0 } 279}; 280 281 282static void 283gld_${EMULATION_NAME}_list_options (FILE *file) 284{ 285 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n")); 286 fprintf (file, _(" --dll Set image base to the default for DLLs\n")); 287 fprintf (file, _(" --file-alignment <size> Set file alignment\n")); 288 fprintf (file, _(" --heap <size> Set initial size of the heap\n")); 289 fprintf (file, _(" --image-base <address> Set start address of the executable\n")); 290 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n")); 291 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n")); 292 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n")); 293 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n")); 294 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n")); 295 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n")); 296 fprintf (file, _(" --section-alignment <size> Set section alignment\n")); 297 fprintf (file, _(" --stack <size> Set size of the initial stack\n")); 298 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n")); 299 fprintf (file, _(" --support-old-code Support interworking with old code\n")); 300#ifdef DLL_SUPPORT 301 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n")); 302 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n")); 303 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n")); 304 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n")); 305 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n")); 306 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n")); 307 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n")); 308 fprintf (file, _(" --out-implib <file> Generate import library\n")); 309 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n")); 310 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n")); 311 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\ 312 create __imp_<SYMBOL> as well.\n")); 313 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\ 314 unless user specifies one\n")); 315 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n")); 316 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\ 317 an importlib, use <string><basename>.dll\n\ 318 in preference to lib<basename>.dll \n")); 319 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to\n\ 320 __imp_sym for DATA references\n")); 321 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n")); 322 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\ 323 adding pseudo-relocations resolved at\n\ 324 runtime.\n")); 325 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\ 326 auto-imported DATA.\n")); 327 fprintf (file, _(" --enable-extra-pep-debug Enable verbose debug output when building\n\ 328 or linking to DLLs (esp. auto-import)\n")); 329#endif 330} 331 332 333static void 334set_pep_name (char *name, bfd_vma val) 335{ 336 int i; 337 338 /* Find the name and set it. */ 339 for (i = 0; init[i].ptr; i++) 340 { 341 if (strcmp (name, init[i].symbol) == 0) 342 { 343 init[i].value = val; 344 init[i].inited = 1; 345 if (strcmp (name,"__image_base__") == 0) 346 set_pep_name ("___ImageBase", val); 347 return; 348 } 349 } 350 abort (); 351} 352 353 354static void 355set_pep_subsystem (void) 356{ 357 const char *sver; 358 const char *entry; 359 const char *initial_symbol_char; 360 char *end; 361 int len; 362 int i; 363 int subsystem; 364 unsigned long temp_subsystem; 365 static const struct 366 { 367 const char *name; 368 const int value; 369 const char *entry; 370 } 371 v[] = 372 { 373 { "native", 1, "NtProcessStartup" }, 374 { "windows", 2, "WinMainCRTStartup" }, 375 { "console", 3, "mainCRTStartup" }, 376 { "posix", 7, "__PosixProcessStartup"}, 377 { "wince", 9, "_WinMainCRTStartup" }, 378 { "xbox", 14, "mainCRTStartup" }, 379 { NULL, 0, NULL } 380 }; 381 /* Entry point name for arbitrary subsystem numbers. */ 382 static const char default_entry[] = "mainCRTStartup"; 383 384 /* Check for the presence of a version number. */ 385 sver = strchr (optarg, ':'); 386 if (sver == NULL) 387 len = strlen (optarg); 388 else 389 { 390 len = sver - optarg; 391 set_pep_name ("__major_subsystem_version__", 392 strtoul (sver + 1, &end, 0)); 393 if (*end == '.') 394 set_pep_name ("__minor_subsystem_version__", 395 strtoul (end + 1, &end, 0)); 396 if (*end != '\0') 397 einfo (_("%P: warning: bad version number in -subsystem option\n")); 398 } 399 400 /* Check for numeric subsystem. */ 401 temp_subsystem = strtoul (optarg, & end, 0); 402 if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536)) 403 { 404 /* Search list for a numeric match to use its entry point. */ 405 for (i = 0; v[i].name; i++) 406 if (v[i].value == (int) temp_subsystem) 407 break; 408 409 /* If no match, use the default. */ 410 if (v[i].name != NULL) 411 entry = v[i].entry; 412 else 413 entry = default_entry; 414 415 /* Use this subsystem. */ 416 subsystem = (int) temp_subsystem; 417 } 418 else 419 { 420 /* Search for subsystem by name. */ 421 for (i = 0; v[i].name; i++) 422 if (strncmp (optarg, v[i].name, len) == 0 423 && v[i].name[len] == '\0') 424 break; 425 426 if (v[i].name == NULL) 427 { 428 einfo (_("%P%F: invalid subsystem type %s\n"), optarg); 429 return; 430 } 431 432 entry = v[i].entry; 433 subsystem = v[i].value; 434 } 435 436 set_pep_name ("__subsystem__", subsystem); 437 438 initial_symbol_char = ${INITIAL_SYMBOL_CHAR}; 439 if (*initial_symbol_char != '\0') 440 { 441 char *alc_entry; 442 443 /* lang_default_entry expects its argument to be permanently 444 allocated, so we don't free this string. */ 445 alc_entry = xmalloc (strlen (initial_symbol_char) 446 + strlen (entry) 447 + 1); 448 strcpy (alc_entry, initial_symbol_char); 449 strcat (alc_entry, entry); 450 entry = alc_entry; 451 } 452 453 lang_default_entry (entry); 454 455 return; 456} 457 458 459static void 460set_pep_value (char *name) 461{ 462 char *end; 463 464 set_pep_name (name, (bfd_vma) strtoull (optarg, &end, 0)); 465 466 if (end == optarg) 467 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg); 468 469 optarg = end; 470} 471 472 473static void 474set_pep_stack_heap (char *resname, char *comname) 475{ 476 set_pep_value (resname); 477 478 if (*optarg == ',') 479 { 480 optarg++; 481 set_pep_value (comname); 482 } 483 else if (*optarg) 484 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg); 485} 486 487 488static bfd_boolean 489gld${EMULATION_NAME}_handle_option (int optc) 490{ 491 switch (optc) 492 { 493 default: 494 return FALSE; 495 496 case OPTION_BASE_FILE: 497 link_info.base_file = fopen (optarg, FOPEN_WB); 498 if (link_info.base_file == NULL) 499 { 500 /* xgettext:c-format */ 501 fprintf (stderr, _("%s: Can't open base file %s\n"), 502 program_name, optarg); 503 xexit (1); 504 } 505 break; 506 507 /* PE options. */ 508 case OPTION_HEAP: 509 set_pep_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__"); 510 break; 511 case OPTION_STACK: 512 set_pep_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__"); 513 break; 514 case OPTION_SUBSYSTEM: 515 set_pep_subsystem (); 516 break; 517 case OPTION_MAJOR_OS_VERSION: 518 set_pep_value ("__major_os_version__"); 519 break; 520 case OPTION_MINOR_OS_VERSION: 521 set_pep_value ("__minor_os_version__"); 522 break; 523 case OPTION_MAJOR_SUBSYSTEM_VERSION: 524 set_pep_value ("__major_subsystem_version__"); 525 break; 526 case OPTION_MINOR_SUBSYSTEM_VERSION: 527 set_pep_value ("__minor_subsystem_version__"); 528 break; 529 case OPTION_MAJOR_IMAGE_VERSION: 530 set_pep_value ("__major_image_version__"); 531 break; 532 case OPTION_MINOR_IMAGE_VERSION: 533 set_pep_value ("__minor_image_version__"); 534 break; 535 case OPTION_FILE_ALIGNMENT: 536 set_pep_value ("__file_alignment__"); 537 break; 538 case OPTION_SECTION_ALIGNMENT: 539 set_pep_value ("__section_alignment__"); 540 break; 541 case OPTION_DLL: 542 set_pep_name ("__dll__", 1); 543 break; 544 case OPTION_IMAGE_BASE: 545 set_pep_value ("__image_base__"); 546 break; 547 case OPTION_SUPPORT_OLD_CODE: 548 support_old_code = 1; 549 break; 550#ifdef DLL_SUPPORT 551 case OPTION_OUT_DEF: 552 pep_out_def_filename = xstrdup (optarg); 553 break; 554 case OPTION_EXPORT_ALL: 555 pep_dll_export_everything = 1; 556 break; 557 case OPTION_EXCLUDE_SYMBOLS: 558 pep_dll_add_excludes (optarg, 0); 559 break; 560 case OPTION_EXCLUDE_LIBS: 561 pep_dll_add_excludes (optarg, 1); 562 break; 563 case OPTION_KILL_ATS: 564 pep_dll_kill_ats = 1; 565 break; 566 case OPTION_STDCALL_ALIASES: 567 pep_dll_stdcall_aliases = 1; 568 break; 569 case OPTION_ENABLE_STDCALL_FIXUP: 570 pep_enable_stdcall_fixup = 1; 571 break; 572 case OPTION_DISABLE_STDCALL_FIXUP: 573 pep_enable_stdcall_fixup = 0; 574 break; 575 case OPTION_IMPLIB_FILENAME: 576 pep_implib_filename = xstrdup (optarg); 577 break; 578 case OPTION_WARN_DUPLICATE_EXPORTS: 579 pep_dll_warn_dup_exports = 1; 580 break; 581 case OPTION_IMP_COMPAT: 582 pep_dll_compat_implib = 1; 583 break; 584 case OPTION_ENABLE_AUTO_IMAGE_BASE: 585 pep_enable_auto_image_base = 1; 586 break; 587 case OPTION_DISABLE_AUTO_IMAGE_BASE: 588 pep_enable_auto_image_base = 0; 589 break; 590 case OPTION_DLL_SEARCH_PREFIX: 591 pep_dll_search_prefix = xstrdup (optarg); 592 break; 593 case OPTION_NO_DEFAULT_EXCLUDES: 594 pep_dll_do_default_excludes = 0; 595 break; 596 case OPTION_DLL_ENABLE_AUTO_IMPORT: 597 link_info.pei386_auto_import = 1; 598 break; 599 case OPTION_DLL_DISABLE_AUTO_IMPORT: 600 link_info.pei386_auto_import = 0; 601 break; 602 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC: 603 link_info.pei386_runtime_pseudo_reloc = 1; 604 break; 605 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC: 606 link_info.pei386_runtime_pseudo_reloc = 0; 607 break; 608 case OPTION_ENABLE_EXTRA_PE_DEBUG: 609 pep_dll_extra_pe_debug = 1; 610 break; 611#endif 612 } 613 return TRUE; 614} 615 616 617#ifdef DLL_SUPPORT 618static unsigned long 619strhash (const char *str) 620{ 621 const unsigned char *s; 622 unsigned long hash; 623 unsigned int c; 624 unsigned int len; 625 626 hash = 0; 627 len = 0; 628 s = (const unsigned char *) str; 629 while ((c = *s++) != '\0') 630 { 631 hash += c + (c << 17); 632 hash ^= hash >> 2; 633 ++len; 634 } 635 hash += len + (len << 17); 636 hash ^= hash >> 2; 637 638 return hash; 639} 640 641/* Use the output file to create a image base for relocatable DLLs. */ 642 643static bfd_vma 644compute_dll_image_base (const char *ofile) 645{ 646 bfd_vma hash = (bfd_vma) strhash (ofile); 647 return 0x61300000 + ((hash << 16) & 0x0FFC0000); 648} 649#endif 650 651/* Assign values to the special symbols before the linker script is 652 read. */ 653 654static void 655gld_${EMULATION_NAME}_set_symbols (void) 656{ 657 /* Run through and invent symbols for all the 658 names and insert the defaults. */ 659 int j; 660 lang_statement_list_type *save; 661 662 if (!init[IMAGEBASEOFF].inited) 663 { 664 if (link_info.relocatable) 665 init[IMAGEBASEOFF].value = 0; 666 else if (init[DLLOFF].value || (link_info.shared && !link_info.pie)) 667#ifdef DLL_SUPPORT 668 init[IMAGEBASEOFF].value = (pep_enable_auto_image_base) ? 669 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE; 670#else 671 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE; 672#endif 673 else 674 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE; 675 init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value; 676 } 677 678 /* Don't do any symbol assignments if this is a relocatable link. */ 679 if (link_info.relocatable) 680 return; 681 682 /* Glue the assignments into the abs section. */ 683 save = stat_ptr; 684 685 stat_ptr = &(abs_output_section->children); 686 687 for (j = 0; init[j].ptr; j++) 688 { 689 bfd_vma val = init[j].value; 690 lang_assignment_statement_type *rv; 691 rv = lang_add_assignment (exp_assop ('=', init[j].symbol, 692 exp_intop (val))); 693 if (init[j].size == sizeof (short)) 694 *(short *) init[j].ptr = (short) val; 695 else if (init[j].size == sizeof (int)) 696 *(int *) init[j].ptr = (int) val; 697 else if (init[j].size == sizeof (long)) 698 *(long *) init[j].ptr = (long) val; 699 /* This might be a long long or other special type. */ 700 else if (init[j].size == sizeof (bfd_vma)) 701 *(bfd_vma *) init[j].ptr = val; 702 else abort (); 703 if (j == IMAGEBASEOFF) 704 image_base_statement = rv; 705 } 706 /* Restore the pointer. */ 707 stat_ptr = save; 708 709 if (pep.FileAlignment > pep.SectionAlignment) 710 { 711 einfo (_("%P: warning, file alignment > section alignment.\n")); 712 } 713} 714 715/* This is called after the linker script and the command line options 716 have been read. */ 717 718static void 719gld_${EMULATION_NAME}_after_parse (void) 720{ 721 /* The Windows libraries are designed for the linker to treat the 722 entry point as an undefined symbol. Otherwise, the .obj that 723 defines mainCRTStartup is brought in because it is the first 724 encountered in libc.lib and it has other symbols in it which will 725 be pulled in by the link process. To avoid this, we act as 726 though the user specified -u with the entry point symbol. 727 728 This function is called after the linker script and command line 729 options have been read, so at this point we know the right entry 730 point. This function is called before the input files are 731 opened, so registering the symbol as undefined will make a 732 difference. */ 733 734 if (! link_info.relocatable && entry_symbol.name != NULL) 735 ldlang_add_undef (entry_symbol.name); 736} 737 738/* pep-dll.c directly accesses pep_data_import_dll, 739 so it must be defined outside of #ifdef DLL_SUPPORT. 740 Note - this variable is deliberately not initialised. 741 This allows it to be treated as a common varaible, and only 742 exist in one incarnation in a multiple target enabled linker. */ 743char * pep_data_import_dll; 744 745#ifdef DLL_SUPPORT 746static struct bfd_link_hash_entry *pep_undef_found_sym; 747 748static bfd_boolean 749pep_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf) 750{ 751 int sl; 752 char *string = inf; 753 754 sl = strlen (string); 755 if (h->type == bfd_link_hash_defined 756 && strncmp (h->root.string, string, sl) == 0 757 && h->root.string[sl] == '@') 758 { 759 pep_undef_found_sym = h; 760 return FALSE; 761 } 762 return TRUE; 763} 764 765static void 766pep_fixup_stdcalls (void) 767{ 768 static int gave_warning_message = 0; 769 struct bfd_link_hash_entry *undef, *sym; 770 771 if (pep_dll_extra_pe_debug) 772 printf ("%s\n", __FUNCTION__); 773 774 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next) 775 if (undef->type == bfd_link_hash_undefined) 776 { 777 char* at = strchr (undef->root.string, '@'); 778 int lead_at = (*undef->root.string == '@'); 779 /* For now, don't try to fixup fastcall symbols. */ 780 781 if (at && !lead_at) 782 { 783 /* The symbol is a stdcall symbol, so let's look for a 784 cdecl symbol with the same name and resolve to that. */ 785 char *cname = xstrdup (undef->root.string /* + lead_at */); 786 at = strchr (cname, '@'); 787 *at = 0; 788 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1); 789 790 if (sym && sym->type == bfd_link_hash_defined) 791 { 792 undef->type = bfd_link_hash_defined; 793 undef->u.def.value = sym->u.def.value; 794 undef->u.def.section = sym->u.def.section; 795 796 if (pep_enable_stdcall_fixup == -1) 797 { 798 einfo (_("Warning: resolving %s by linking to %s\n"), 799 undef->root.string, cname); 800 if (! gave_warning_message) 801 { 802 gave_warning_message = 1; 803 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n")); 804 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n")); 805 } 806 } 807 } 808 } 809 else 810 { 811 /* The symbol is a cdecl symbol, so we look for stdcall 812 symbols - which means scanning the whole symbol table. */ 813 pep_undef_found_sym = 0; 814 bfd_link_hash_traverse (link_info.hash, pep_undef_cdecl_match, 815 (char *) undef->root.string); 816 sym = pep_undef_found_sym; 817 if (sym) 818 { 819 undef->type = bfd_link_hash_defined; 820 undef->u.def.value = sym->u.def.value; 821 undef->u.def.section = sym->u.def.section; 822 823 if (pep_enable_stdcall_fixup == -1) 824 { 825 einfo (_("Warning: resolving %s by linking to %s\n"), 826 undef->root.string, sym->root.string); 827 if (! gave_warning_message) 828 { 829 gave_warning_message = 1; 830 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n")); 831 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n")); 832 } 833 } 834 } 835 } 836 } 837} 838 839static int 840make_import_fixup (arelent *rel, asection *s) 841{ 842 struct bfd_symbol *sym = *rel->sym_ptr_ptr; 843 char addend[4]; 844 845 if (pep_dll_extra_pe_debug) 846 printf ("arelent: %s@%#lx: add=%li\n", sym->name, 847 (unsigned long) rel->address, (long) rel->addend); 848 849 if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend))) 850 einfo (_("%C: Cannot get section contents - auto-import exception\n"), 851 s->owner, s, rel->address); 852 853 pep_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend)); 854 855 return 1; 856} 857 858static void 859pep_find_data_imports (void) 860{ 861 struct bfd_link_hash_entry *undef, *sym; 862 863 if (link_info.pei386_auto_import == 0) 864 return; 865 866 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next) 867 { 868 if (undef->type == bfd_link_hash_undefined) 869 { 870 /* C++ symbols are *long*. */ 871 char buf[4096]; 872 873 if (pep_dll_extra_pe_debug) 874 printf ("%s:%s\n", __FUNCTION__, undef->root.string); 875 876 sprintf (buf, "__imp_%s", undef->root.string); 877 878 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1); 879 880 if (sym && sym->type == bfd_link_hash_defined) 881 { 882 bfd *b = sym->u.def.section->owner; 883 asymbol **symbols; 884 int nsyms, i; 885 886 if (link_info.pei386_auto_import == -1) 887 { 888 static bfd_boolean warned = FALSE; 889 890 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"), 891 undef->root.string, buf); 892 893 /* PR linker/4844. */ 894 if (! warned) 895 { 896 warned = TRUE; 897 einfo (_("%P: warning: auto-importing has been activated without --enable-auto-import specified on the command line.\n\ 898This should work unless it involves constant data structures referencing symbols from auto-imported DLLs.\n")); 899 } 900 } 901 902 if (!bfd_generic_link_read_symbols (b)) 903 { 904 einfo (_("%B%F: could not read symbols: %E\n"), b); 905 return; 906 } 907 908 symbols = bfd_get_outsymbols (b); 909 nsyms = bfd_get_symcount (b); 910 911 for (i = 0; i < nsyms; i++) 912 { 913 if (! CONST_STRNEQ (symbols[i]->name, "__head_")) 914 continue; 915 916 if (pep_dll_extra_pe_debug) 917 printf ("->%s\n", symbols[i]->name); 918 919 pep_data_import_dll = (char*) (symbols[i]->name + 920 sizeof ("__head_") - 1); 921 break; 922 } 923 924 pep_walk_relocs_of_symbol (&link_info, undef->root.string, 925 make_import_fixup); 926 927 /* Let's differentiate it somehow from defined. */ 928 undef->type = bfd_link_hash_defweak; 929 /* We replace original name with __imp_ prefixed, this 930 1) may trash memory 2) leads to duplicate symbol generation. 931 Still, IMHO it's better than having name poluted. */ 932 undef->root.string = sym->root.string; 933 undef->u.def.value = sym->u.def.value; 934 undef->u.def.section = sym->u.def.section; 935 } 936 } 937 } 938} 939 940static bfd_boolean 941pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED) 942{ 943 if (pep_dll_extra_pe_debug) 944 printf ("+%s\n", h->string); 945 946 return TRUE; 947} 948#endif /* DLL_SUPPORT */ 949 950 951static void 952gld_${EMULATION_NAME}_after_open (void) 953{ 954#ifdef DLL_SUPPORT 955 if (pep_dll_extra_pe_debug) 956 { 957 bfd *a; 958 struct bfd_link_hash_entry *sym; 959 960 printf ("%s()\n", __FUNCTION__); 961 962 for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next) 963 printf ("-%s\n", sym->root.string); 964 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL); 965 966 for (a = link_info.input_bfds; a; a = a->link_next) 967 printf ("*%s\n",a->filename); 968 } 969#endif 970 971 /* Pass the wacky PE command line options into the output bfd. 972 FIXME: This should be done via a function, rather than by 973 including an internal BFD header. */ 974 975 if (coff_data (link_info.output_bfd) == NULL 976 || coff_data (link_info.output_bfd)->pe == 0) 977 einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"), 978 link_info.output_bfd); 979 980 pe_data (link_info.output_bfd)->pe_opthdr = pep; 981 pe_data (link_info.output_bfd)->dll = init[DLLOFF].value; 982 pe_data (link_info.output_bfd)->real_flags |= real_flags; 983 984#ifdef DLL_SUPPORT 985 if (pep_enable_stdcall_fixup) /* -1=warn or 1=disable */ 986 pep_fixup_stdcalls (); 987 988 pep_process_import_defs (link_info.output_bfd, &link_info); 989 990 pep_find_data_imports (); 991 992#ifndef TARGET_IS_i386pep 993 if (link_info.shared) 994#else 995 if (!link_info.relocatable) 996#endif 997 pep_dll_build_sections (link_info.output_bfd, &link_info); 998 999#ifndef TARGET_IS_i386pep 1000 else 1001 pep_exe_build_sections (link_info.output_bfd, &link_info); 1002#endif 1003#endif /* DLL_SUPPORT */ 1004 1005 { 1006 /* This next chunk of code tries to detect the case where you have 1007 two import libraries for the same DLL (specifically, 1008 symbolically linking libm.a and libc.a in cygwin to 1009 libcygwin.a). In those cases, it's possible for function 1010 thunks from the second implib to be used but without the 1011 head/tail objects, causing an improper import table. We detect 1012 those cases and rename the "other" import libraries to match 1013 the one the head/tail come from, so that the linker will sort 1014 things nicely and produce a valid import table. */ 1015 1016 LANG_FOR_EACH_INPUT_STATEMENT (is) 1017 { 1018 if (is->the_bfd->my_archive) 1019 { 1020 int idata2 = 0, reloc_count=0, is_imp = 0; 1021 asection *sec; 1022 1023 /* See if this is an import library thunk. */ 1024 for (sec = is->the_bfd->sections; sec; sec = sec->next) 1025 { 1026 if (strcmp (sec->name, ".idata\$2") == 0) 1027 idata2 = 1; 1028 if (CONST_STRNEQ (sec->name, ".idata\$")) 1029 is_imp = 1; 1030 reloc_count += sec->reloc_count; 1031 } 1032 1033 if (is_imp && !idata2 && reloc_count) 1034 { 1035 /* It is, look for the reference to head and see if it's 1036 from our own library. */ 1037 for (sec = is->the_bfd->sections; sec; sec = sec->next) 1038 { 1039 int i; 1040 long relsize; 1041 asymbol **symbols; 1042 arelent **relocs; 1043 int nrelocs; 1044 1045 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec); 1046 if (relsize < 1) 1047 break; 1048 1049 if (!bfd_generic_link_read_symbols (is->the_bfd)) 1050 { 1051 einfo (_("%B%F: could not read symbols: %E\n"), 1052 is->the_bfd); 1053 return; 1054 } 1055 symbols = bfd_get_outsymbols (is->the_bfd); 1056 1057 relocs = xmalloc ((size_t) relsize); 1058 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec, 1059 relocs, symbols); 1060 if (nrelocs < 0) 1061 { 1062 free (relocs); 1063 einfo ("%X%P: unable to process relocs: %E\n"); 1064 return; 1065 } 1066 1067 for (i = 0; i < nrelocs; i++) 1068 { 1069 struct bfd_symbol *s; 1070 struct bfd_link_hash_entry * blhe; 1071 char *other_bfd_filename; 1072 char *n; 1073 1074 s = (relocs[i]->sym_ptr_ptr)[0]; 1075 1076 if (s->flags & BSF_LOCAL) 1077 continue; 1078 1079 /* Thunk section with reloc to another bfd. */ 1080 blhe = bfd_link_hash_lookup (link_info.hash, 1081 s->name, 1082 FALSE, FALSE, TRUE); 1083 1084 if (blhe == NULL 1085 || blhe->type != bfd_link_hash_defined) 1086 continue; 1087 1088 other_bfd_filename 1089 = blhe->u.def.section->owner->my_archive 1090 ? bfd_get_filename (blhe->u.def.section->owner->my_archive) 1091 : bfd_get_filename (blhe->u.def.section->owner); 1092 1093 if (strcmp (bfd_get_filename (is->the_bfd->my_archive), 1094 other_bfd_filename) == 0) 1095 continue; 1096 1097 /* Rename this implib to match the other one. */ 1098 n = xmalloc (strlen (other_bfd_filename) + 1); 1099 strcpy (n, other_bfd_filename); 1100 is->the_bfd->my_archive->filename = n; 1101 } 1102 1103 free (relocs); 1104 /* Note - we do not free the symbols, 1105 they are now cached in the BFD. */ 1106 } 1107 } 1108 } 1109 } 1110 } 1111 1112 { 1113 int is_ms_arch = 0; 1114 bfd *cur_arch = 0; 1115 lang_input_statement_type *is2; 1116 lang_input_statement_type *is3; 1117 1118 /* Careful - this is a shell script. Watch those dollar signs! */ 1119 /* Microsoft import libraries have every member named the same, 1120 and not in the right order for us to link them correctly. We 1121 must detect these and rename the members so that they'll link 1122 correctly. There are three types of objects: the head, the 1123 thunks, and the sentinel(s). The head is easy; it's the one 1124 with idata2. We assume that the sentinels won't have relocs, 1125 and the thunks will. It's easier than checking the symbol 1126 table for external references. */ 1127 LANG_FOR_EACH_INPUT_STATEMENT (is) 1128 { 1129 if (is->the_bfd->my_archive) 1130 { 1131 char *pnt; 1132 bfd *arch = is->the_bfd->my_archive; 1133 1134 if (cur_arch != arch) 1135 { 1136 cur_arch = arch; 1137 is_ms_arch = 1; 1138 1139 for (is3 = is; 1140 is3 && is3->the_bfd->my_archive == arch; 1141 is3 = (lang_input_statement_type *) is3->next) 1142 { 1143 /* A MS dynamic import library can also contain static 1144 members, so look for the first element with a .dll 1145 extension, and use that for the remainder of the 1146 comparisons. */ 1147 pnt = strrchr (is3->the_bfd->filename, '.'); 1148 if (pnt != NULL && strcmp (pnt, ".dll") == 0) 1149 break; 1150 } 1151 1152 if (is3 == NULL) 1153 is_ms_arch = 0; 1154 else 1155 { 1156 /* OK, found one. Now look to see if the remaining 1157 (dynamic import) members use the same name. */ 1158 for (is2 = is; 1159 is2 && is2->the_bfd->my_archive == arch; 1160 is2 = (lang_input_statement_type *) is2->next) 1161 { 1162 /* Skip static members, ie anything with a .obj 1163 extension. */ 1164 pnt = strrchr (is2->the_bfd->filename, '.'); 1165 if (pnt != NULL && strcmp (pnt, ".obj") == 0) 1166 continue; 1167 1168 if (strcmp (is3->the_bfd->filename, 1169 is2->the_bfd->filename)) 1170 { 1171 is_ms_arch = 0; 1172 break; 1173 } 1174 } 1175 } 1176 } 1177 1178 /* This fragment might have come from an .obj file in a Microsoft 1179 import, and not an actual import record. If this is the case, 1180 then leave the filename alone. */ 1181 pnt = strrchr (is->the_bfd->filename, '.'); 1182 1183 if (is_ms_arch && (strcmp (pnt, ".dll") == 0)) 1184 { 1185 int idata2 = 0, reloc_count=0; 1186 asection *sec; 1187 char *new_name, seq; 1188 1189 for (sec = is->the_bfd->sections; sec; sec = sec->next) 1190 { 1191 if (strcmp (sec->name, ".idata\$2") == 0) 1192 idata2 = 1; 1193 reloc_count += sec->reloc_count; 1194 } 1195 1196 if (idata2) /* .idata2 is the TOC */ 1197 seq = 'a'; 1198 else if (reloc_count > 0) /* thunks */ 1199 seq = 'b'; 1200 else /* sentinel */ 1201 seq = 'c'; 1202 1203 new_name = xmalloc (strlen (is->the_bfd->filename) + 3); 1204 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq); 1205 is->the_bfd->filename = new_name; 1206 1207 new_name = xmalloc (strlen (is->filename) + 3); 1208 sprintf (new_name, "%s.%c", is->filename, seq); 1209 is->filename = new_name; 1210 } 1211 } 1212 } 1213 } 1214} 1215 1216static void 1217gld_${EMULATION_NAME}_before_allocation (void) 1218{ 1219 before_allocation_default (); 1220} 1221 1222#ifdef DLL_SUPPORT 1223/* This is called when an input file isn't recognized as a BFD. We 1224 check here for .DEF files and pull them in automatically. */ 1225 1226static int 1227saw_option (char *option) 1228{ 1229 int i; 1230 1231 for (i = 0; init[i].ptr; i++) 1232 if (strcmp (init[i].symbol, option) == 0) 1233 return init[i].inited; 1234 return 0; 1235} 1236#endif /* DLL_SUPPORT */ 1237 1238static bfd_boolean 1239gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED) 1240{ 1241#ifdef DLL_SUPPORT 1242 const char *ext = entry->filename + strlen (entry->filename) - 4; 1243 1244 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0) 1245 { 1246 pep_def_file = def_file_parse (entry->filename, pep_def_file); 1247 1248 if (pep_def_file) 1249 { 1250 int i, buflen=0, len; 1251 char *buf; 1252 1253 for (i = 0; i < pep_def_file->num_exports; i++) 1254 { 1255 len = strlen (pep_def_file->exports[i].internal_name); 1256 if (buflen < len + 2) 1257 buflen = len + 2; 1258 } 1259 1260 buf = xmalloc (buflen); 1261 1262 for (i = 0; i < pep_def_file->num_exports; i++) 1263 { 1264 struct bfd_link_hash_entry *h; 1265 1266 sprintf (buf, "_%s", pep_def_file->exports[i].internal_name); 1267 1268 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE); 1269 if (h == (struct bfd_link_hash_entry *) NULL) 1270 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 1271 if (h->type == bfd_link_hash_new) 1272 { 1273 h->type = bfd_link_hash_undefined; 1274 h->u.undef.abfd = NULL; 1275 bfd_link_add_undef (link_info.hash, h); 1276 } 1277 } 1278 free (buf); 1279 1280 /* def_file_print (stdout, pep_def_file); */ 1281 if (pep_def_file->is_dll == 1) 1282 link_info.shared = 1; 1283 1284 if (pep_def_file->base_address != (bfd_vma)(-1)) 1285 { 1286 pep.ImageBase 1287 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase 1288 = init[IMAGEBASEOFF].value 1289 = pep_def_file->base_address; 1290 init[IMAGEBASEOFF].inited = 1; 1291 if (image_base_statement) 1292 image_base_statement->exp = exp_assop ('=', "__image_base__", 1293 exp_intop (pep.ImageBase)); 1294 } 1295 1296 if (pep_def_file->stack_reserve != -1 1297 && ! saw_option ("__size_of_stack_reserve__")) 1298 { 1299 pep.SizeOfStackReserve = pep_def_file->stack_reserve; 1300 if (pep_def_file->stack_commit != -1) 1301 pep.SizeOfStackCommit = pep_def_file->stack_commit; 1302 } 1303 if (pep_def_file->heap_reserve != -1 1304 && ! saw_option ("__size_of_heap_reserve__")) 1305 { 1306 pep.SizeOfHeapReserve = pep_def_file->heap_reserve; 1307 if (pep_def_file->heap_commit != -1) 1308 pep.SizeOfHeapCommit = pep_def_file->heap_commit; 1309 } 1310 return TRUE; 1311 } 1312 } 1313#endif 1314 return FALSE; 1315} 1316 1317static bfd_boolean 1318gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED) 1319{ 1320#ifdef DLL_SUPPORT 1321#ifdef TARGET_IS_i386pep 1322 pep_dll_id_target ("pei-x86-64"); 1323#endif 1324 if (pep_bfd_is_dll (entry->the_bfd)) 1325 return pep_implied_import_dll (entry->filename); 1326#endif 1327 return FALSE; 1328} 1329 1330static void 1331gld_${EMULATION_NAME}_finish (void) 1332{ 1333 finish_default (); 1334 1335#ifdef DLL_SUPPORT 1336 if (link_info.shared 1337 || (!link_info.relocatable && pep_def_file->num_exports != 0)) 1338 { 1339 pep_dll_fill_sections (link_info.output_bfd, &link_info); 1340 if (pep_implib_filename) 1341 pep_dll_generate_implib (pep_def_file, pep_implib_filename); 1342 } 1343 1344 if (pep_out_def_filename) 1345 pep_dll_generate_def_file (pep_out_def_filename); 1346#endif /* DLL_SUPPORT */ 1347 1348 /* I don't know where .idata gets set as code, but it shouldn't be. */ 1349 { 1350 asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata"); 1351 1352 if (asec) 1353 { 1354 asec->flags &= ~SEC_CODE; 1355 asec->flags |= SEC_DATA; 1356 } 1357 } 1358} 1359 1360 1361/* Place an orphan section. 1362 1363 We use this to put sections in a reasonable place in the file, and 1364 to ensure that they are aligned as required. 1365 1366 We handle grouped sections here as well. A section named .foo$nn 1367 goes into the output section .foo. All grouped sections are sorted 1368 by name. 1369 1370 Grouped sections for the default sections are handled by the 1371 default linker script using wildcards, and are sorted by 1372 sort_sections. */ 1373 1374static bfd_boolean 1375gld_${EMULATION_NAME}_place_orphan (asection *s) 1376{ 1377 const char *secname; 1378 const char *orig_secname; 1379 char *dollar = NULL; 1380 lang_output_section_statement_type *os; 1381 lang_statement_list_type add_child; 1382 1383 secname = bfd_get_section_name (s->owner, s); 1384 1385 /* Look through the script to see where to place this section. */ 1386 orig_secname = secname; 1387 if (!link_info.relocatable 1388 && (dollar = strchr (secname, '$')) != NULL) 1389 { 1390 size_t len = dollar - orig_secname; 1391 char *newname = xmalloc (len + 1); 1392 memcpy (newname, orig_secname, len); 1393 newname[len] = '\0'; 1394 secname = newname; 1395 } 1396 1397 os = lang_output_section_find (secname); 1398 1399 lang_list_init (&add_child); 1400 1401 if (os != NULL 1402 && (os->bfd_section == NULL 1403 || os->bfd_section->flags == 0 1404 || ((s->flags ^ os->bfd_section->flags) 1405 & (SEC_LOAD | SEC_ALLOC)) == 0)) 1406 { 1407 /* We already have an output section statement with this 1408 name, and its bfd section, if any, has compatible flags. 1409 If the section already exists but does not have any flags set, 1410 then it has been created by the linker, probably as a result of 1411 a --section-start command line switch. */ 1412 lang_add_section (&add_child, s, os); 1413 } 1414 else 1415 { 1416 static struct orphan_save hold[] = 1417 { 1418 { ".text", 1419 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE, 1420 0, 0, 0, 0 }, 1421 { ".rdata", 1422 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 1423 0, 0, 0, 0 }, 1424 { ".data", 1425 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA, 1426 0, 0, 0, 0 }, 1427 { ".bss", 1428 SEC_ALLOC, 1429 0, 0, 0, 0 } 1430 }; 1431 enum orphan_save_index 1432 { 1433 orphan_text = 0, 1434 orphan_rodata, 1435 orphan_data, 1436 orphan_bss 1437 }; 1438 static int orphan_init_done = 0; 1439 struct orphan_save *place; 1440 lang_output_section_statement_type *after; 1441 etree_type *address; 1442 1443 if (!orphan_init_done) 1444 { 1445 struct orphan_save *ho; 1446 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho) 1447 if (ho->name != NULL) 1448 { 1449 ho->os = lang_output_section_find (ho->name); 1450 if (ho->os != NULL && ho->os->flags == 0) 1451 ho->os->flags = ho->flags; 1452 } 1453 orphan_init_done = 1; 1454 } 1455 1456 /* Try to put the new output section in a reasonable place based 1457 on the section name and section flags. */ 1458 1459 place = NULL; 1460 if ((s->flags & SEC_ALLOC) == 0) 1461 ; 1462 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 1463 place = &hold[orphan_bss]; 1464 else if ((s->flags & SEC_READONLY) == 0) 1465 place = &hold[orphan_data]; 1466 else if ((s->flags & SEC_CODE) == 0) 1467 place = &hold[orphan_rodata]; 1468 else 1469 place = &hold[orphan_text]; 1470 1471 after = NULL; 1472 if (place != NULL) 1473 { 1474 if (place->os == NULL) 1475 place->os = lang_output_section_find (place->name); 1476 after = place->os; 1477 if (after == NULL) 1478 after = lang_output_section_find_by_flags (s, &place->os, NULL); 1479 if (after == NULL) 1480 /* *ABS* is always the first output section statement. */ 1481 after = (&lang_output_section_statement.head 1482 ->output_section_statement); 1483 } 1484 1485 /* Choose a unique name for the section. This will be needed if the 1486 same section name appears in the input file with different 1487 loadable or allocatable characteristics. */ 1488 if (bfd_get_section_by_name (link_info.output_bfd, secname) != NULL) 1489 { 1490 static int count = 1; 1491 secname = bfd_get_unique_section_name (link_info.output_bfd, 1492 secname, &count); 1493 if (secname == NULL) 1494 einfo ("%F%P: place_orphan failed: %E\n"); 1495 } 1496 1497 /* All sections in an executable must be aligned to a page boundary. */ 1498 address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__")); 1499 os = lang_insert_orphan (s, secname, after, place, address, &add_child); 1500 } 1501 1502 { 1503 lang_statement_union_type **pl = &os->children.head; 1504 1505 if (dollar != NULL) 1506 { 1507 bfd_boolean found_dollar; 1508 1509 /* The section name has a '$'. Sort it with the other '$' 1510 sections. */ 1511 found_dollar = FALSE; 1512 for ( ; *pl != NULL; pl = &(*pl)->header.next) 1513 { 1514 lang_input_section_type *ls; 1515 const char *lname; 1516 1517 if ((*pl)->header.type != lang_input_section_enum) 1518 continue; 1519 1520 ls = &(*pl)->input_section; 1521 1522 lname = bfd_get_section_name (ls->section->owner, ls->section); 1523 if (strchr (lname, '$') == NULL) 1524 { 1525 if (found_dollar) 1526 break; 1527 } 1528 else 1529 { 1530 found_dollar = TRUE; 1531 if (strcmp (orig_secname, lname) < 0) 1532 break; 1533 } 1534 } 1535 } 1536 1537 if (add_child.head != NULL) 1538 { 1539 add_child.head->header.next = *pl; 1540 *pl = add_child.head; 1541 } 1542 } 1543 1544 return TRUE; 1545} 1546 1547static bfd_boolean 1548gld_${EMULATION_NAME}_open_dynamic_archive 1549 (const char *arch ATTRIBUTE_UNUSED, 1550 search_dirs_type *search, 1551 lang_input_statement_type *entry) 1552{ 1553 static const struct 1554 { 1555 const char * format; 1556 bfd_boolean use_prefix; 1557 } 1558 libname_fmt [] = 1559 { 1560 /* Preferred explicit import library for dll's. */ 1561 { "lib%s.dll.a", FALSE }, 1562 /* Alternate explicit import library for dll's. */ 1563 { "%s.dll.a", FALSE }, 1564 /* "libfoo.a" could be either an import lib or a static lib. 1565 For backwards compatibility, libfoo.a needs to precede 1566 libfoo.dll and foo.dll in the search. */ 1567 { "lib%s.a", FALSE }, 1568 /* The 'native' spelling of an import lib name is "foo.lib". */ 1569 { "%s.lib", FALSE }, 1570#ifdef DLL_SUPPORT 1571 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */ 1572 { "%s%s.dll", TRUE }, 1573#endif 1574 /* Try "libfoo.dll" (default preferred dll name). */ 1575 { "lib%s.dll", FALSE }, 1576 /* Finally try 'native' dll name "foo.dll". */ 1577 { "%s.dll", FALSE }, 1578 /* Note: If adding more formats to this table, make sure to check to 1579 see if their length is longer than libname_fmt[0].format, and if 1580 so, update the call to xmalloc() below. */ 1581 { NULL, FALSE } 1582 }; 1583 static unsigned int format_max_len = 0; 1584 const char * filename; 1585 char * full_string; 1586 char * base_string; 1587 unsigned int i; 1588 1589 1590 if (! entry->is_archive) 1591 return FALSE; 1592 1593 filename = entry->filename; 1594 1595 if (format_max_len == 0) 1596 /* We need to allow space in the memory that we are going to allocate 1597 for the characters in the format string. Since the format array is 1598 static we only need to calculate this information once. In theory 1599 this value could also be computed statically, but this introduces 1600 the possibility for a discrepancy and hence a possible memory 1601 corruption. The lengths we compute here will be too long because 1602 they will include any formating characters (%s) in the strings, but 1603 this will not matter. */ 1604 for (i = 0; libname_fmt[i].format; i++) 1605 if (format_max_len < strlen (libname_fmt[i].format)) 1606 format_max_len = strlen (libname_fmt[i].format); 1607 1608 full_string = xmalloc (strlen (search->name) 1609 + strlen (filename) 1610 + format_max_len 1611#ifdef DLL_SUPPORT 1612 + (pep_dll_search_prefix 1613 ? strlen (pep_dll_search_prefix) : 0) 1614#endif 1615 /* Allow for the terminating NUL and for the path 1616 separator character that is inserted between 1617 search->name and the start of the format string. */ 1618 + 2); 1619 1620 sprintf (full_string, "%s/", search->name); 1621 base_string = full_string + strlen (full_string); 1622 1623 for (i = 0; libname_fmt[i].format; i++) 1624 { 1625#ifdef DLL_SUPPORT 1626 if (libname_fmt[i].use_prefix) 1627 { 1628 if (!pep_dll_search_prefix) 1629 continue; 1630 sprintf (base_string, libname_fmt[i].format, pep_dll_search_prefix, filename); 1631 } 1632 else 1633#endif 1634 sprintf (base_string, libname_fmt[i].format, filename); 1635 1636 if (ldfile_try_open_bfd (full_string, entry)) 1637 break; 1638 } 1639 1640 if (!libname_fmt[i].format) 1641 { 1642 free (full_string); 1643 return FALSE; 1644 } 1645 1646 entry->filename = full_string; 1647 1648 return TRUE; 1649} 1650 1651static int 1652gld_${EMULATION_NAME}_find_potential_libraries 1653 (char *name, lang_input_statement_type *entry) 1654{ 1655 return ldfile_open_file_search (name, entry, "", ".lib"); 1656} 1657 1658static char * 1659gld_${EMULATION_NAME}_get_script (int *isfile) 1660EOF 1661# Scripts compiled in. 1662# sed commands to quote an ld script as a C string. 1663sc="-f stringify.sed" 1664 1665fragment <<EOF 1666{ 1667 *isfile = 0; 1668 1669 if (link_info.relocatable && config.build_constructors) 1670 return 1671EOF 1672sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c 1673echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c 1674sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c 1675echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c 1676sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c 1677echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c 1678sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c 1679if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then 1680echo ' ; else if (link_info.pei386_auto_import == 1) return' >> e${EMULATION_NAME}.c 1681sed $sc ldscripts/${EMULATION_NAME}.xa >> e${EMULATION_NAME}.c 1682fi 1683echo ' ; else return' >> e${EMULATION_NAME}.c 1684sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c 1685echo '; }' >> e${EMULATION_NAME}.c 1686 1687fragment <<EOF 1688 1689 1690struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = 1691{ 1692 gld_${EMULATION_NAME}_before_parse, 1693 syslib_default, 1694 hll_default, 1695 gld_${EMULATION_NAME}_after_parse, 1696 gld_${EMULATION_NAME}_after_open, 1697 after_allocation_default, 1698 set_output_arch_default, 1699 ldemul_default_target, 1700 gld_${EMULATION_NAME}_before_allocation, 1701 gld_${EMULATION_NAME}_get_script, 1702 "${EMULATION_NAME}", 1703 "${OUTPUT_FORMAT}", 1704 gld_${EMULATION_NAME}_finish, 1705 NULL, /* Create output section statements. */ 1706 gld_${EMULATION_NAME}_open_dynamic_archive, 1707 gld_${EMULATION_NAME}_place_orphan, 1708 gld_${EMULATION_NAME}_set_symbols, 1709 NULL, /* parse_args */ 1710 gld${EMULATION_NAME}_add_options, 1711 gld${EMULATION_NAME}_handle_option, 1712 gld_${EMULATION_NAME}_unrecognized_file, 1713 gld_${EMULATION_NAME}_list_options, 1714 gld_${EMULATION_NAME}_recognized_file, 1715 gld_${EMULATION_NAME}_find_potential_libraries, 1716 NULL /* new_vers_pattern. */ 1717}; 1718EOF 1719