1# This shell script emits a C file. -*- C -*- 2# It does some substitutions. 3if [ -z "$MACHINE" ]; then 4 OUTPUT_ARCH=${ARCH} 5else 6 OUTPUT_ARCH=${ARCH}:${MACHINE} 7fi 8 9case ${target} in 10 *-*-cygwin*) 11 cygwin_behavior=1 12 ;; 13 *) 14 cygwin_behavior=0; 15 ;; 16esac 17 18rm -f e${EMULATION_NAME}.c 19(echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-) 20fragment <<EOF 21/* Copyright (C) 1995-2024 Free Software Foundation, Inc. 22 23 This file is part of the GNU Binutils. 24 25 This program is free software; you can redistribute it and/or modify 26 it under the terms of the GNU General Public License as published by 27 the Free Software Foundation; either version 3 of the License, or 28 (at your option) any later version. 29 30 This program is distributed in the hope that it will be useful, 31 but WITHOUT ANY WARRANTY; without even the implied warranty of 32 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 33 GNU General Public License for more details. 34 35 You should have received a copy of the GNU General Public License 36 along with this program; if not, write to the Free Software 37 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 38 MA 02110-1301, USA. */ 39 40 41/* For WINDOWS_NT */ 42/* The original file generated returned different default scripts depending 43 on whether certain switches were set, but these switches pertain to the 44 Linux system and that particular version of coff. In the NT case, we 45 only determine if the subsystem is console or windows in order to select 46 the correct entry point by default. */ 47 48#define TARGET_IS_${EMULATION_NAME} 49 50#include "sysdep.h" 51#include "bfd.h" 52#include "bfdlink.h" 53#include "ctf-api.h" 54#include "getopt.h" 55#include "libiberty.h" 56#include "filenames.h" 57#include "ld.h" 58#include "ldmain.h" 59#include "ldexp.h" 60#include "ldlang.h" 61#include "ldfile.h" 62#include "ldemul.h" 63#include <ldgram.h> 64#include "ldlex.h" 65#include "ldmisc.h" 66#include "ldctor.h" 67#include "ldbuildid.h" 68#include "coff/internal.h" 69EOF 70 71case ${target} in 72 x86_64-*-mingw* | x86_64-*-pe | x86_64-*-pep | x86_64-*-cygwin | \ 73 i[3-7]86-*-mingw32* | i[3-7]86-*-cygwin* | i[3-7]86-*-winnt | i[3-7]86-*-pe) 74fragment <<EOF 75#include "pdb.h" 76EOF 77 ;; 78esac 79 80fragment <<EOF 81 82/* FIXME: See bfd/peXXigen.c for why we include an architecture specific 83 header in generic PE code. */ 84#include "coff/i386.h" 85#include "coff/pe.h" 86 87/* FIXME: These are BFD internal header files, and we should not be 88 using it here. */ 89#include "../bfd/libcoff.h" 90#include "../bfd/libpei.h" 91 92#if defined(TARGET_IS_armpe) \ 93 || defined(TARGET_IS_arm_wince_pe) 94#define bfd_arm_allocate_interworking_sections \ 95 bfd_${EMULATION_NAME}_allocate_interworking_sections 96#define bfd_arm_get_bfd_for_interworking \ 97 bfd_${EMULATION_NAME}_get_bfd_for_interworking 98#define bfd_arm_process_before_allocation \ 99 bfd_${EMULATION_NAME}_process_before_allocation 100#include "coff-arm.h" 101#endif 102 103#include "deffile.h" 104#include "pe-dll.h" 105#include "safe-ctype.h" 106 107/* Permit the emulation parameters to override the default section 108 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes 109 it seem that include/coff/internal.h should not define 110 PE_DEF_SECTION_ALIGNMENT. */ 111#if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT} 112#undef PE_DEF_SECTION_ALIGNMENT 113#define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT} 114#endif 115 116#if defined(TARGET_IS_i386pe) \ 117 || defined(TARGET_IS_shpe) \ 118 || defined(TARGET_IS_armpe) \ 119 || defined(TARGET_IS_arm_wince_pe) 120#define DLL_SUPPORT 121#endif 122 123#if defined(TARGET_IS_i386pe) 124#define DEFAULT_PSEUDO_RELOC_VERSION 2 125#else 126#define DEFAULT_PSEUDO_RELOC_VERSION 1 127#endif 128 129#define DEFAULT_DLL_CHARACTERISTICS (${cygwin_behavior} ? 0 : \ 130 IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE \ 131 | IMAGE_DLL_CHARACTERISTICS_NX_COMPAT) 132 133#if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT) 134#define PE_DEF_SUBSYSTEM IMAGE_SUBSYSTEM_WINDOWS_CUI 135#else 136#undef NT_EXE_IMAGE_BASE 137#undef PE_DEF_SECTION_ALIGNMENT 138#undef PE_DEF_FILE_ALIGNMENT 139#define NT_EXE_IMAGE_BASE 0x00010000 140 141#if defined(TARGET_IS_armpe) 142#define PE_DEF_SECTION_ALIGNMENT 0x00001000 143#define PE_DEF_SUBSYSTEM IMAGE_SUBSYSTEM_WINDOWS_GUI 144#elif defined(TARGET_IS_arm_wince_pe) 145#define PE_DEF_SECTION_ALIGNMENT 0x00001000 146#define PE_DEF_SUBSYSTEM IMAGE_SUBSYSTEM_WINDOWS_CE_GUI 147#else 148#define PE_DEF_SECTION_ALIGNMENT 0x00000400 149#define PE_DEF_SUBSYSTEM IMAGE_SUBSYSTEM_WINDOWS_GUI 150#endif 151#define PE_DEF_FILE_ALIGNMENT 0x00000200 152#endif 153 154static struct internal_extra_pe_aouthdr pe; 155static int dll; 156static int pe_subsystem = ${SUBSYSTEM}; 157static flagword real_flags = 0; 158static int support_old_code = 0; 159static char * thumb_entry_symbol = NULL; 160static lang_assignment_statement_type *image_base_statement = 0; 161static unsigned short pe_dll_characteristics = DEFAULT_DLL_CHARACTERISTICS; 162static bool insert_timestamp = true; 163static const char *emit_build_id; 164#ifdef PDB_H 165static int pdb; 166static char *pdb_name; 167#endif 168 169#ifdef DLL_SUPPORT 170static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable. */ 171static char *pe_out_def_filename = NULL; 172static int pe_enable_auto_image_base = 0; 173static unsigned long pe_auto_image_base = 0x61500000; 174static char *pe_dll_search_prefix = NULL; 175#endif 176 177extern const char *output_filename; 178 179static int 180is_underscoring (void) 181{ 182 int u = 0; 183 if (pe_leading_underscore != -1) 184 return pe_leading_underscore; 185 if (!bfd_get_target_info ("${OUTPUT_FORMAT}", NULL, NULL, &u, NULL)) 186 bfd_get_target_info ("${RELOCATEABLE_OUTPUT_FORMAT}", NULL, NULL, &u, NULL); 187 188 if (u == -1) 189 abort (); 190 pe_leading_underscore = (u != 0 ? 1 : 0); 191 return pe_leading_underscore; 192} 193 194static void 195gld${EMULATION_NAME}_before_parse (void) 196{ 197 is_underscoring (); 198 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`); 199 output_filename = "${EXECUTABLE_NAME:-a.exe}"; 200#ifdef DLL_SUPPORT 201 input_flags.dynamic = true; 202 config.has_shared = 1; 203EOF 204 205# Cygwin no longer wants these noisy warnings. Other PE 206# targets might like to consider adding themselves here. 207# See also the mail thread starting here for the reason why 208# merge_rdata defaults to 0 for cygwin: 209# http://cygwin.com/ml/cygwin-apps/2013-04/msg00187.html 210case ${target} in 211 *-*-cygwin*) 212 default_auto_import=1 213 default_merge_rdata=0 214 ;; 215 i[3-7]86-*-mingw* | x86_64-*-mingw*) 216 default_auto_import=1 217 default_merge_rdata=0 218 ;; 219 *) 220 default_auto_import=-1 221 default_merge_rdata=1 222 ;; 223esac 224 225fragment <<EOF 226 link_info.pei386_auto_import = ${default_auto_import}; 227 /* Use by default version. */ 228 link_info.pei386_runtime_pseudo_reloc = DEFAULT_PSEUDO_RELOC_VERSION; 229#endif 230} 231 232/* Indicates if RDATA shall be merged into DATA when pseudo-relocation 233 version 2 is used and auto-import is enabled. */ 234#define MERGE_RDATA_V2 ${default_merge_rdata} 235 236/* PE format extra command line options. */ 237 238/* Used for setting flags in the PE header. */ 239enum options 240{ 241 OPTION_BASE_FILE = 300 + 1, 242 OPTION_DLL, 243 OPTION_FILE_ALIGNMENT, 244 OPTION_IMAGE_BASE, 245 OPTION_MAJOR_IMAGE_VERSION, 246 OPTION_MAJOR_OS_VERSION, 247 OPTION_MAJOR_SUBSYSTEM_VERSION, 248 OPTION_MINOR_IMAGE_VERSION, 249 OPTION_MINOR_OS_VERSION, 250 OPTION_MINOR_SUBSYSTEM_VERSION, 251 OPTION_SECTION_ALIGNMENT, 252 OPTION_STACK, 253 OPTION_SUBSYSTEM, 254 OPTION_HEAP, 255 OPTION_SUPPORT_OLD_CODE, 256 OPTION_OUT_DEF, 257 OPTION_EXPORT_ALL, 258 OPTION_EXCLUDE_SYMBOLS, 259 OPTION_EXCLUDE_ALL_SYMBOLS, 260 OPTION_KILL_ATS, 261 OPTION_STDCALL_ALIASES, 262 OPTION_ENABLE_STDCALL_FIXUP, 263 OPTION_DISABLE_STDCALL_FIXUP, 264 OPTION_THUMB_ENTRY, 265 OPTION_WARN_DUPLICATE_EXPORTS, 266 OPTION_IMP_COMPAT, 267 OPTION_ENABLE_AUTO_IMAGE_BASE, 268 OPTION_DISABLE_AUTO_IMAGE_BASE, 269 OPTION_DLL_SEARCH_PREFIX, 270 OPTION_NO_DEFAULT_EXCLUDES, 271 OPTION_DLL_ENABLE_AUTO_IMPORT, 272 OPTION_DLL_DISABLE_AUTO_IMPORT, 273 OPTION_ENABLE_EXTRA_PE_DEBUG, 274 OPTION_EXCLUDE_LIBS, 275 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC, 276 OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC, 277 OPTION_LARGE_ADDRESS_AWARE, 278 OPTION_DISABLE_LARGE_ADDRESS_AWARE, 279 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1, 280 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2, 281 OPTION_EXCLUDE_MODULES_FOR_IMPLIB, 282 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES, 283 OPTION_NO_LEADING_UNDERSCORE, 284 OPTION_LEADING_UNDERSCORE, 285 OPTION_ENABLE_LONG_SECTION_NAMES, 286 OPTION_DISABLE_LONG_SECTION_NAMES, 287/* DLLCharacteristics flags. */ 288 OPTION_DYNAMIC_BASE, 289 OPTION_FORCE_INTEGRITY, 290 OPTION_NX_COMPAT, 291 OPTION_NO_ISOLATION, 292 OPTION_NO_SEH, 293 OPTION_NO_BIND, 294 OPTION_WDM_DRIVER, 295 OPTION_TERMINAL_SERVER_AWARE, 296/* Determinism. */ 297 OPTION_INSERT_TIMESTAMP, 298 OPTION_NO_INSERT_TIMESTAMP, 299 OPTION_BUILD_ID, 300#ifdef PDB_H 301 OPTION_PDB, 302#endif 303 OPTION_ENABLE_RELOC_SECTION, 304 OPTION_DISABLE_RELOC_SECTION, 305/* DLL Characteristics flags. */ 306 OPTION_DISABLE_DYNAMIC_BASE, 307 OPTION_DISABLE_FORCE_INTEGRITY, 308 OPTION_DISABLE_NX_COMPAT, 309 OPTION_DISABLE_NO_ISOLATION, 310 OPTION_DISABLE_NO_SEH, 311 OPTION_DISABLE_NO_BIND, 312 OPTION_DISABLE_WDM_DRIVER, 313 OPTION_DISABLE_TERMINAL_SERVER_AWARE 314}; 315 316static void 317gld${EMULATION_NAME}_add_options 318 (int ns ATTRIBUTE_UNUSED, 319 char **shortopts ATTRIBUTE_UNUSED, 320 int nl, 321 struct option **longopts, 322 int nrl ATTRIBUTE_UNUSED, 323 struct option **really_longopts ATTRIBUTE_UNUSED) 324{ 325 static const struct option xtra_long[] = 326 { 327 /* PE options. */ 328 {"base-file", required_argument, NULL, OPTION_BASE_FILE}, 329 {"dll", no_argument, NULL, OPTION_DLL}, 330 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT}, 331 {"heap", required_argument, NULL, OPTION_HEAP}, 332 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE}, 333 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION}, 334 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION}, 335 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION}, 336 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION}, 337 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION}, 338 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION}, 339 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT}, 340 {"stack", required_argument, NULL, OPTION_STACK}, 341 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM}, 342 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE}, 343 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY}, 344 {"use-nul-prefixed-import-tables", no_argument, NULL, 345 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES}, 346 {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE}, 347 {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE}, 348 {"insert-timestamp", no_argument, NULL, OPTION_INSERT_TIMESTAMP}, 349 {"no-insert-timestamp", no_argument, NULL, OPTION_NO_INSERT_TIMESTAMP}, 350#ifdef DLL_SUPPORT 351 /* getopt allows abbreviations, so we do this to stop it 352 from treating -o as an abbreviation for this option. */ 353 {"output-def", required_argument, NULL, OPTION_OUT_DEF}, 354 {"output-def", required_argument, NULL, OPTION_OUT_DEF}, 355 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL}, 356 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS}, 357 {"exclude-all-symbols", no_argument, NULL, OPTION_EXCLUDE_ALL_SYMBOLS}, 358 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS}, 359 {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB}, 360 {"kill-at", no_argument, NULL, OPTION_KILL_ATS}, 361 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES}, 362 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP}, 363 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP}, 364 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS}, 365 /* getopt() allows abbreviations, so we do this to stop it from 366 treating -c as an abbreviation for these --compat-implib. */ 367 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT}, 368 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT}, 369 {"enable-auto-image-base", optional_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE}, 370 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE}, 371 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX}, 372 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES}, 373 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT}, 374 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT}, 375 {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG}, 376 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC}, 377 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC}, 378 {"enable-runtime-pseudo-reloc-v1", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1}, 379 {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2}, 380#endif 381 {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE}, 382 {"disable-large-address-aware", no_argument, NULL, OPTION_DISABLE_LARGE_ADDRESS_AWARE}, 383 {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES}, 384 {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES}, 385 {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE}, 386 {"disable-dynamicbase",no_argument, NULL, OPTION_DISABLE_DYNAMIC_BASE}, 387 {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY}, 388 {"disable-forceinteg", no_argument, NULL, OPTION_DISABLE_FORCE_INTEGRITY}, 389 {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT}, 390 {"disable-nxcompat", no_argument, NULL, OPTION_DISABLE_NX_COMPAT}, 391 {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION}, 392 {"disable-no-isolation", no_argument, NULL, OPTION_DISABLE_NO_ISOLATION}, 393 {"no-seh", no_argument, NULL, OPTION_NO_SEH}, 394 {"disable-no-seh", no_argument, NULL, OPTION_DISABLE_NO_SEH}, 395 {"no-bind", no_argument, NULL, OPTION_NO_BIND}, 396 {"disable-no-bind", no_argument, NULL, OPTION_DISABLE_NO_BIND}, 397 {"wdmdriver", no_argument, NULL, OPTION_WDM_DRIVER}, 398 {"disable-wdmdriver", no_argument, NULL, OPTION_DISABLE_WDM_DRIVER}, 399 {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE}, 400 {"disable-tsaware", no_argument, NULL, OPTION_DISABLE_TERMINAL_SERVER_AWARE}, 401 {"build-id", optional_argument, NULL, OPTION_BUILD_ID}, 402#ifdef PDB_H 403 {"pdb", required_argument, NULL, OPTION_PDB}, 404#endif 405 {"enable-reloc-section", no_argument, NULL, OPTION_ENABLE_RELOC_SECTION}, 406 {"disable-reloc-section", no_argument, NULL, OPTION_DISABLE_RELOC_SECTION}, 407 {NULL, no_argument, NULL, 0} 408 }; 409 410 *longopts 411 = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long)); 412 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); 413} 414 415/* PE/WIN32; added routines to get the subsystem type, heap and/or stack 416 parameters which may be input from the command line. */ 417 418typedef struct 419{ 420 void *ptr; 421 int size; 422 int value; 423 char *symbol; 424 int inited; 425 /* FALSE for an assembly level symbol and TRUE for a C visible symbol. 426 C visible symbols can be prefixed by underscore dependent to target's 427 settings. */ 428 bool is_c_symbol; 429} definfo; 430 431/* Get symbol name dependent to kind and C visible state of 432 underscore. */ 433#define GET_INIT_SYMBOL_NAME(IDX) \ 434 (init[(IDX)].symbol \ 435 + ((!init[(IDX)].is_c_symbol || is_underscoring () != 0) ? 0 : 1)) 436 437/* Decorates the C visible symbol by underscore, if target requires. */ 438#define U(CSTR) \ 439 ((is_underscoring () == 0) ? CSTR : "_" CSTR) 440 441#define D(field,symbol,def,usc) {&pe.field, sizeof (pe.field), def, symbol, 0, usc} 442 443static definfo init[] = 444{ 445 /* imagebase must be first */ 446#define IMAGEBASEOFF 0 447 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE, false), 448#define DLLOFF 1 449 {&dll, sizeof(dll), 0, "__dll__", 0, false}, 450#define MSIMAGEBASEOFF 2 451 D(ImageBase, "___ImageBase", NT_EXE_IMAGE_BASE, true), 452 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT, false), 453 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT, false), 454 D(MajorOperatingSystemVersion,"__major_os_version__", 4, false), 455 D(MinorOperatingSystemVersion,"__minor_os_version__", 0, false), 456 D(MajorImageVersion,"__major_image_version__", 1, false), 457 D(MinorImageVersion,"__minor_image_version__", 0, false), 458#if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe) 459 D(MajorSubsystemVersion,"__major_subsystem_version__", 3, false), 460#else 461 D(MajorSubsystemVersion,"__major_subsystem_version__", 4, false), 462#endif 463 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0, false), 464 D(Subsystem,"__subsystem__", ${SUBSYSTEM}, false), 465 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000, false), 466 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000, false), 467 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000, false), 468 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000, false), 469 D(LoaderFlags,"__loader_flags__", 0x0, false), 470 D(DllCharacteristics, "__dll_characteristics__", DEFAULT_DLL_CHARACTERISTICS, false), 471 { NULL, 0, 0, NULL, 0 , false} 472}; 473 474 475static void 476gld${EMULATION_NAME}_list_options (FILE *file) 477{ 478 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n")); 479 fprintf (file, _(" --dll Set image base to the default for DLLs\n")); 480 fprintf (file, _(" --file-alignment <size> Set file alignment\n")); 481 fprintf (file, _(" --heap <size> Set initial size of the heap\n")); 482 fprintf (file, _(" --image-base <address> Set start address of the executable\n")); 483 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n")); 484 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n")); 485 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n")); 486 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n")); 487 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n")); 488 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n")); 489 fprintf (file, _(" --section-alignment <size> Set section alignment\n")); 490 fprintf (file, _(" --stack <size> Set size of the initial stack\n")); 491 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n")); 492 fprintf (file, _(" --support-old-code Support interworking with old code\n")); 493 fprintf (file, _(" --[no-]leading-underscore Set explicit symbol underscore prefix mode\n")); 494 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n")); 495 fprintf (file, _(" --[no-]insert-timestamp Use a real timestamp rather than zero (default).\n")); 496 fprintf (file, _(" This makes binaries non-deterministic\n")); 497#ifdef DLL_SUPPORT 498 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n")); 499 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n")); 500 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n")); 501 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n")); 502 fprintf (file, _(" --exclude-all-symbols Exclude all symbols from automatic export\n")); 503 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n")); 504 fprintf (file, _(" --exclude-modules-for-implib mod,mod,...\n")); 505 fprintf (file, _(" Exclude objects, archive members from auto\n")); 506 fprintf (file, _(" export, place into import library instead.\n")); 507 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n")); 508 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n")); 509 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n")); 510 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports\n")); 511 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\ 512 create __imp_<SYMBOL> as well.\n")); 513 fprintf (file, _(" --enable-auto-image-base[=<address>] Automatically choose image base for DLLs\n\ 514 (optionally starting with address) unless\n\ 515 specifically set with --image-base\n")); 516 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n")); 517 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\ 518 an importlib, use <string><basename>.dll\n\ 519 in preference to lib<basename>.dll \n")); 520 fprintf (file, _(" --enable-auto-import Do sophisticated linking of _sym to\n\ 521 __imp_sym for DATA references\n")); 522 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n")); 523 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\ 524 adding pseudo-relocations resolved at\n\ 525 runtime.\n")); 526 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\ 527 auto-imported DATA.\n")); 528 fprintf (file, _(" --enable-extra-pe-debug Enable verbose debug output when building\n\ 529 or linking to DLLs (esp. auto-import)\n")); 530#endif 531 fprintf (file, _(" --large-address-aware Executable supports virtual addresses\n\ 532 greater than 2 gigabytes\n")); 533 fprintf (file, _(" --disable-large-address-aware Executable does not support virtual\n\ 534 addresses greater than 2 gigabytes\n")); 535 fprintf (file, _(" --enable-long-section-names Use long COFF section names even in\n\ 536 executable image files\n")); 537 fprintf (file, _(" --disable-long-section-names Never use long COFF section names, even\n\ 538 in object files\n")); 539 fprintf (file, _(" --[disable-]dynamicbase Image base address may be relocated using\n\ 540 address space layout randomization (ASLR)\n")); 541 fprintf (file, _(" --enable-reloc-section Create the base relocation table\n")); 542 fprintf (file, _(" --disable-reloc-section Do not create the base relocation table\n")); 543 fprintf (file, _(" --[disable-]forceinteg Code integrity checks are enforced\n")); 544 fprintf (file, _(" --[disable-]nxcompat Image is compatible with data execution\n\ 545 prevention\n")); 546 fprintf (file, _(" --[disable-]no-isolation Image understands isolation but do not\n\ 547 isolate the image\n")); 548 fprintf (file, _(" --[disable-]no-seh Image does not use SEH. No SE handler may\n\ 549 be called in this image\n")); 550 fprintf (file, _(" --[disable-]no-bind Do not bind this image\n")); 551 fprintf (file, _(" --[disable-]wdmdriver Driver uses the WDM model\n")); 552 fprintf (file, _(" --[disable-]tsaware Image is Terminal Server aware\n")); 553 fprintf (file, _(" --build-id[=STYLE] Generate build ID\n")); 554#ifdef PDB_H 555 fprintf (file, _(" --pdb=[FILENAME] Generate PDB file\n")); 556#endif 557} 558 559/* A case insensitive comparison, regardless of the host platform, used for 560 comparing file extensions. */ 561static int 562fileext_cmp (const char *s1, const char *s2) 563{ 564 for (;;) 565 { 566 int c1 = TOLOWER (*s1++); 567 int c2 = *s2++; /* Assumed to be lower case from the caller. */ 568 569 if (c1 != c2) 570 return (c1 - c2); 571 572 if (c1 == '\0') 573 return 0; 574 } 575} 576 577static void 578set_pe_name (char *name, long val) 579{ 580 int i; 581 is_underscoring (); 582 583 /* Find the name and set it. */ 584 for (i = 0; init[i].ptr; i++) 585 { 586 if (strcmp (name, GET_INIT_SYMBOL_NAME (i)) == 0) 587 { 588 init[i].value = val; 589 init[i].inited = 1; 590 if (strcmp (name,"__image_base__") == 0) 591 set_pe_name (U ("__ImageBase"), val); 592 return; 593 } 594 } 595 abort (); 596} 597 598static void 599set_entry_point (void) 600{ 601 const char *entry; 602 const char *initial_symbol_char; 603 int i; 604 605 static const struct 606 { 607 const int value; 608 const char *entry; 609 } 610 v[] = 611 { 612 { 1, "NtProcessStartup" }, 613 { 2, "WinMainCRTStartup" }, 614 { 3, "mainCRTStartup" }, 615 { 7, "__PosixProcessStartup"}, 616 { 9, "WinMainCRTStartup" }, 617 {14, "mainCRTStartup" }, 618 { 0, NULL } 619 }; 620 621 /* Entry point name for arbitrary subsystem numbers. */ 622 static const char default_entry[] = "mainCRTStartup"; 623 624 if (bfd_link_dll (&link_info) || dll) 625 { 626#if defined (TARGET_IS_i386pe) 627 entry = "DllMainCRTStartup@12"; 628#else 629 entry = "DllMainCRTStartup"; 630#endif 631 } 632 else 633 { 634 for (i = 0; v[i].entry; i++) 635 if (v[i].value == pe_subsystem) 636 break; 637 638 /* If no match, use the default. */ 639 if (v[i].entry != NULL) 640 entry = v[i].entry; 641 else 642 entry = default_entry; 643 } 644 645 initial_symbol_char = (is_underscoring () != 0 ? "_" : ""); 646 647 if (*initial_symbol_char != '\0') 648 { 649 char *alc_entry; 650 651 /* lang_default_entry expects its argument to be permanently 652 allocated, so we don't free this string. */ 653 alc_entry = xmalloc (strlen (initial_symbol_char) 654 + strlen (entry) 655 + 1); 656 strcpy (alc_entry, initial_symbol_char); 657 strcat (alc_entry, entry); 658 entry = alc_entry; 659 } 660 661 lang_default_entry (entry); 662 663 if (bfd_link_executable (&link_info) && ! entry_from_cmdline) 664 ldlang_add_undef (entry, false); 665} 666 667static void 668set_pe_subsystem (void) 669{ 670 const char *sver; 671 char *end; 672 int len; 673 int i; 674 unsigned long temp_subsystem; 675 static const struct 676 { 677 const char *name; 678 const int value; 679 } 680 v[] = 681 { 682 { "native", 1}, 683 { "windows", 2}, 684 { "console", 3}, 685 { "posix", 7}, 686 { "wince", 9}, 687 { "xbox", 14}, 688 { NULL, 0 } 689 }; 690 691 /* Check for the presence of a version number. */ 692 sver = strchr (optarg, ':'); 693 if (sver == NULL) 694 len = strlen (optarg); 695 else 696 { 697 len = sver - optarg; 698 set_pe_name ("__major_subsystem_version__", 699 strtoul (sver + 1, &end, 0)); 700 if (*end == '.') 701 set_pe_name ("__minor_subsystem_version__", 702 strtoul (end + 1, &end, 0)); 703 if (*end != '\0') 704 einfo (_("%P: warning: bad version number in -subsystem option\n")); 705 } 706 707 /* Check for numeric subsystem. */ 708 temp_subsystem = strtoul (optarg, & end, 0); 709 if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536)) 710 { 711 /* Search list for a numeric match to use its entry point. */ 712 for (i = 0; v[i].name; i++) 713 if (v[i].value == (int) temp_subsystem) 714 break; 715 716 /* Use this subsystem. */ 717 pe_subsystem = (int) temp_subsystem; 718 } 719 else 720 { 721 /* Search for subsystem by name. */ 722 for (i = 0; v[i].name; i++) 723 if (strncmp (optarg, v[i].name, len) == 0 724 && v[i].name[len] == '\0') 725 break; 726 727 if (v[i].name == NULL) 728 { 729 einfo (_("%F%P: invalid subsystem type %s\n"), optarg); 730 return; 731 } 732 733 pe_subsystem = v[i].value; 734 } 735 736 set_pe_name ("__subsystem__", pe_subsystem); 737 738 return; 739} 740 741 742static void 743set_pe_value (char *name) 744{ 745 char *end; 746 747 set_pe_name (name, strtoul (optarg, &end, 0)); 748 749 if (end == optarg) 750 einfo (_("%F%P: invalid hex number for PE parameter '%s'\n"), optarg); 751 752 optarg = end; 753} 754 755 756static void 757set_pe_stack_heap (char *resname, char *comname) 758{ 759 set_pe_value (resname); 760 761 if (*optarg == ',') 762 { 763 optarg++; 764 set_pe_value (comname); 765 } 766 else if (*optarg) 767 einfo (_("%F%P: strange hex info for PE parameter '%s'\n"), optarg); 768} 769 770#define DEFAULT_BUILD_ID_STYLE "md5" 771 772static bool 773gld${EMULATION_NAME}_handle_option (int optc) 774{ 775 switch (optc) 776 { 777 default: 778 return false; 779 780 case OPTION_BASE_FILE: 781 link_info.base_file = fopen (optarg, FOPEN_WB); 782 if (link_info.base_file == NULL) 783 einfo (_("%F%P: cannot open base file %s\n"), optarg); 784 break; 785 786 /* PE options. */ 787 case OPTION_HEAP: 788 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__"); 789 break; 790 case OPTION_STACK: 791 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__"); 792 break; 793 case OPTION_SUBSYSTEM: 794 set_pe_subsystem (); 795 break; 796 case OPTION_MAJOR_OS_VERSION: 797 set_pe_value ("__major_os_version__"); 798 break; 799 case OPTION_MINOR_OS_VERSION: 800 set_pe_value ("__minor_os_version__"); 801 break; 802 case OPTION_MAJOR_SUBSYSTEM_VERSION: 803 set_pe_value ("__major_subsystem_version__"); 804 break; 805 case OPTION_MINOR_SUBSYSTEM_VERSION: 806 set_pe_value ("__minor_subsystem_version__"); 807 break; 808 case OPTION_MAJOR_IMAGE_VERSION: 809 set_pe_value ("__major_image_version__"); 810 break; 811 case OPTION_MINOR_IMAGE_VERSION: 812 set_pe_value ("__minor_image_version__"); 813 break; 814 case OPTION_FILE_ALIGNMENT: 815 set_pe_value ("__file_alignment__"); 816 break; 817 case OPTION_SECTION_ALIGNMENT: 818 set_pe_value ("__section_alignment__"); 819 break; 820 case OPTION_DLL: 821 set_pe_name ("__dll__", 1); 822 break; 823 case OPTION_IMAGE_BASE: 824 set_pe_value ("__image_base__"); 825 break; 826 case OPTION_SUPPORT_OLD_CODE: 827 support_old_code = 1; 828 break; 829 case OPTION_THUMB_ENTRY: 830 thumb_entry_symbol = optarg; 831 break; 832 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES: 833 pe_use_nul_prefixed_import_tables = true; 834 break; 835 case OPTION_NO_LEADING_UNDERSCORE: 836 pe_leading_underscore = 0; 837 break; 838 case OPTION_LEADING_UNDERSCORE: 839 pe_leading_underscore = 1; 840 break; 841 case OPTION_INSERT_TIMESTAMP: 842 insert_timestamp = true; 843 break; 844 case OPTION_NO_INSERT_TIMESTAMP: 845 insert_timestamp = false; 846 break; 847#ifdef DLL_SUPPORT 848 case OPTION_OUT_DEF: 849 pe_out_def_filename = xstrdup (optarg); 850 break; 851 case OPTION_EXPORT_ALL: 852 pe_dll_export_everything = 1; 853 break; 854 case OPTION_EXCLUDE_SYMBOLS: 855 pe_dll_add_excludes (optarg, EXCLUDESYMS); 856 break; 857 case OPTION_EXCLUDE_ALL_SYMBOLS: 858 pe_dll_exclude_all_symbols = 1; 859 break; 860 case OPTION_EXCLUDE_LIBS: 861 pe_dll_add_excludes (optarg, EXCLUDELIBS); 862 break; 863 case OPTION_EXCLUDE_MODULES_FOR_IMPLIB: 864 pe_dll_add_excludes (optarg, EXCLUDEFORIMPLIB); 865 break; 866 case OPTION_KILL_ATS: 867 pe_dll_kill_ats = 1; 868 break; 869 case OPTION_STDCALL_ALIASES: 870 pe_dll_stdcall_aliases = 1; 871 break; 872 case OPTION_ENABLE_STDCALL_FIXUP: 873 pe_enable_stdcall_fixup = 1; 874 break; 875 case OPTION_DISABLE_STDCALL_FIXUP: 876 pe_enable_stdcall_fixup = 0; 877 break; 878 case OPTION_WARN_DUPLICATE_EXPORTS: 879 pe_dll_warn_dup_exports = 1; 880 break; 881 case OPTION_IMP_COMPAT: 882 pe_dll_compat_implib = 1; 883 break; 884 case OPTION_ENABLE_AUTO_IMAGE_BASE: 885 pe_enable_auto_image_base = 1; 886 if (optarg && *optarg) 887 { 888 char *end; 889 pe_auto_image_base = strtoul (optarg, &end, 0); 890 /* XXX should check that we actually parsed something */ 891 } 892 break; 893 case OPTION_DISABLE_AUTO_IMAGE_BASE: 894 pe_enable_auto_image_base = 0; 895 break; 896 case OPTION_DLL_SEARCH_PREFIX: 897 pe_dll_search_prefix = xstrdup (optarg); 898 break; 899 case OPTION_NO_DEFAULT_EXCLUDES: 900 pe_dll_do_default_excludes = 0; 901 break; 902 case OPTION_DLL_ENABLE_AUTO_IMPORT: 903 link_info.pei386_auto_import = 1; 904 break; 905 case OPTION_DLL_DISABLE_AUTO_IMPORT: 906 link_info.pei386_auto_import = 0; 907 break; 908 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC: 909 link_info.pei386_runtime_pseudo_reloc = 910 DEFAULT_PSEUDO_RELOC_VERSION; 911 break; 912 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1: 913 link_info.pei386_runtime_pseudo_reloc = 1; 914 break; 915 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2: 916 link_info.pei386_runtime_pseudo_reloc = 2; 917 break; 918 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC: 919 link_info.pei386_runtime_pseudo_reloc = 0; 920 break; 921 case OPTION_ENABLE_EXTRA_PE_DEBUG: 922 pe_dll_extra_pe_debug = 1; 923 break; 924#endif 925 case OPTION_LARGE_ADDRESS_AWARE: 926 real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE; 927 break; 928 case OPTION_DISABLE_LARGE_ADDRESS_AWARE: 929 real_flags &= ~ IMAGE_FILE_LARGE_ADDRESS_AWARE; 930 break; 931 case OPTION_ENABLE_LONG_SECTION_NAMES: 932 pe_use_coff_long_section_names = 1; 933 break; 934 case OPTION_DISABLE_LONG_SECTION_NAMES: 935 pe_use_coff_long_section_names = 0; 936 break; 937/* Get DLLCharacteristics bits */ 938 case OPTION_DYNAMIC_BASE: 939 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE; 940 /* fall through */ 941 case OPTION_ENABLE_RELOC_SECTION: 942 pe_dll_enable_reloc_section = 1; 943 break; 944 case OPTION_DISABLE_RELOC_SECTION: 945 pe_dll_enable_reloc_section = 0; 946 /* fall through */ 947 case OPTION_DISABLE_DYNAMIC_BASE: 948 pe_dll_characteristics &= ~ IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE; 949 break; 950 case OPTION_FORCE_INTEGRITY: 951 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY; 952 break; 953 case OPTION_DISABLE_FORCE_INTEGRITY: 954 pe_dll_characteristics &= ~ IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY; 955 break; 956 case OPTION_NX_COMPAT: 957 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT; 958 break; 959 case OPTION_DISABLE_NX_COMPAT: 960 pe_dll_characteristics &= ~ IMAGE_DLL_CHARACTERISTICS_NX_COMPAT; 961 break; 962 case OPTION_NO_ISOLATION: 963 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION; 964 break; 965 case OPTION_DISABLE_NO_ISOLATION: 966 pe_dll_characteristics &= ~ IMAGE_DLLCHARACTERISTICS_NO_ISOLATION; 967 break; 968 case OPTION_NO_SEH: 969 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_SEH; 970 break; 971 case OPTION_DISABLE_NO_SEH: 972 pe_dll_characteristics &= ~ IMAGE_DLLCHARACTERISTICS_NO_SEH; 973 break; 974 case OPTION_NO_BIND: 975 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_BIND; 976 break; 977 case OPTION_DISABLE_NO_BIND: 978 pe_dll_characteristics &= ~ IMAGE_DLLCHARACTERISTICS_NO_BIND; 979 break; 980 case OPTION_WDM_DRIVER: 981 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_WDM_DRIVER; 982 break; 983 case OPTION_DISABLE_WDM_DRIVER: 984 pe_dll_characteristics &= ~ IMAGE_DLLCHARACTERISTICS_WDM_DRIVER; 985 break; 986 case OPTION_TERMINAL_SERVER_AWARE: 987 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE; 988 break; 989 case OPTION_DISABLE_TERMINAL_SERVER_AWARE: 990 pe_dll_characteristics &= ~ IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE; 991 break; 992 case OPTION_BUILD_ID: 993 free ((char *) emit_build_id); 994 emit_build_id = NULL; 995 if (optarg == NULL) 996 optarg = DEFAULT_BUILD_ID_STYLE; 997 if (strcmp (optarg, "none")) 998 emit_build_id = xstrdup (optarg); 999 break; 1000#ifdef PDB_H 1001 case OPTION_PDB: 1002 pdb = 1; 1003 if (optarg && optarg[0]) 1004 pdb_name = xstrdup (optarg); 1005 break; 1006#endif 1007 } 1008 1009 /* Set DLLCharacteristics bits */ 1010 set_pe_name ("__dll_characteristics__", pe_dll_characteristics); 1011 1012 return true; 1013} 1014 1015 1016#ifdef DLL_SUPPORT 1017static unsigned long 1018strhash (const char *str) 1019{ 1020 const unsigned char *s; 1021 unsigned long hash; 1022 unsigned int c; 1023 unsigned int len; 1024 1025 hash = 0; 1026 len = 0; 1027 s = (const unsigned char *) str; 1028 while ((c = *s++) != '\0') 1029 { 1030 hash += c + (c << 17); 1031 hash ^= hash >> 2; 1032 ++len; 1033 } 1034 hash += len + (len << 17); 1035 hash ^= hash >> 2; 1036 1037 return hash; 1038} 1039 1040/* Use the output file to create a image base for relocatable DLLs. */ 1041 1042static unsigned long 1043compute_dll_image_base (const char *ofile) 1044{ 1045 unsigned long hash = strhash (ofile); 1046 return pe_auto_image_base + ((hash << 16) & 0x0FFC0000); 1047} 1048#endif 1049 1050/* Assign values to the special symbols before the linker script is 1051 read. */ 1052 1053static void 1054gld${EMULATION_NAME}_set_symbols (void) 1055{ 1056 /* Run through and invent symbols for all the 1057 names and insert the defaults. */ 1058 int j; 1059 1060 is_underscoring (); 1061 1062 if (!init[IMAGEBASEOFF].inited) 1063 { 1064 if (bfd_link_relocatable (&link_info)) 1065 init[IMAGEBASEOFF].value = 0; 1066 else if (init[DLLOFF].value || bfd_link_dll (&link_info)) 1067 { 1068#ifdef DLL_SUPPORT 1069 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base 1070 ? compute_dll_image_base (output_filename) 1071 : NT_DLL_IMAGE_BASE); 1072#else 1073 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE; 1074#endif 1075 } 1076 else 1077 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE; 1078 init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value; 1079 } 1080 1081 /* Don't do any symbol assignments if this is a relocatable link. */ 1082 if (bfd_link_relocatable (&link_info)) 1083 return; 1084 1085 /* Glue the assignments into the abs section. */ 1086 push_stat_ptr (&abs_output_section->children); 1087 1088 for (j = 0; init[j].ptr; j++) 1089 { 1090 long val = init[j].value; 1091 lang_assignment_statement_type *rv; 1092 1093 rv = lang_add_assignment (exp_assign (GET_INIT_SYMBOL_NAME (j), 1094 exp_intop (val), false)); 1095 if (init[j].size == sizeof (short)) 1096 *(short *) init[j].ptr = val; 1097 else if (init[j].size == sizeof (int)) 1098 *(int *) init[j].ptr = val; 1099 else if (init[j].size == sizeof (long)) 1100 *(long *) init[j].ptr = val; 1101 /* This might be a long long or other special type. */ 1102 else if (init[j].size == sizeof (bfd_vma)) 1103 *(bfd_vma *) init[j].ptr = val; 1104 else abort (); 1105 if (j == IMAGEBASEOFF) 1106 image_base_statement = rv; 1107 } 1108 /* Restore the pointer. */ 1109 pop_stat_ptr (); 1110 1111 if (pe.FileAlignment > pe.SectionAlignment) 1112 { 1113 einfo (_("%P: warning, file alignment > section alignment\n")); 1114 } 1115} 1116 1117/* This is called after the linker script and the command line options 1118 have been read. */ 1119 1120static void 1121gld${EMULATION_NAME}_after_parse (void) 1122{ 1123 /* PR ld/6744: Warn the user if they have used an ELF-only 1124 option hoping it will work on PE. */ 1125 if (link_info.export_dynamic) 1126 einfo (_("%P: warning: --export-dynamic is not supported for PE " 1127 "targets, did you mean --export-all-symbols?\n")); 1128 1129#ifdef PDB_H 1130 if (pdb && emit_build_id == NULL) 1131 emit_build_id = xstrdup (DEFAULT_BUILD_ID_STYLE); 1132#endif 1133 1134 set_entry_point (); 1135 1136 after_parse_default (); 1137} 1138 1139#ifdef DLL_SUPPORT 1140static struct bfd_link_hash_entry *pe_undef_found_sym; 1141 1142static bool 1143pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf) 1144{ 1145 int sl; 1146 char *string = inf; 1147 const char *hs = h->root.string; 1148 1149 sl = strlen (string); 1150 if (h->type == bfd_link_hash_defined 1151 && ((*hs == '@' && *string == '_' 1152 && strncmp (hs + 1, string + 1, sl - 1) == 0) 1153 || strncmp (hs, string, sl) == 0) 1154 && h->root.string[sl] == '@') 1155 { 1156 pe_undef_found_sym = h; 1157 return false; 1158 } 1159 return true; 1160} 1161 1162/* Change UNDEF to a defined symbol, taking data from SYM. */ 1163 1164static void 1165change_undef (struct bfd_link_hash_entry * undef, 1166 struct bfd_link_hash_entry * sym) 1167{ 1168 static bool gave_warning_message = false; 1169 1170 undef->type = bfd_link_hash_defined; 1171 undef->u.def.value = sym->u.def.value; 1172 undef->u.def.section = sym->u.def.section; 1173 1174 if (pe_enable_stdcall_fixup == -1) 1175 { 1176 einfo (_("%P: warning: resolving %s by linking to %s\n"), 1177 undef->root.string, sym->root.string); 1178 1179 if (! gave_warning_message) 1180 { 1181 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n")); 1182 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n")); 1183 gave_warning_message = true; 1184 } 1185 } 1186 1187 /* PR 19803: Make sure that the linked symbol is not garbage collected. */ 1188 lang_add_gc_name (sym->root.string); 1189} 1190 1191static void 1192set_decoration (const char *undecorated_name, 1193 struct bfd_link_hash_entry * decoration) 1194{ 1195 static bool gave_warning_message = false; 1196 struct decoration_hash_entry *entry; 1197 1198 if (is_underscoring () && undecorated_name[0] == '_') 1199 undecorated_name++; 1200 1201 entry = (struct decoration_hash_entry *) 1202 bfd_hash_lookup (&(coff_hash_table (&link_info)->decoration_hash), 1203 undecorated_name, true /* create */, false /* copy */); 1204 1205 if (entry->decorated_link != NULL && !gave_warning_message) 1206 { 1207 einfo (_("%P: warning: overwriting decorated name %s with %s\n"), 1208 entry->decorated_link->root.string, undecorated_name); 1209 gave_warning_message = true; 1210 } 1211 1212 entry->decorated_link = decoration; 1213} 1214 1215static void 1216pe_fixup_stdcalls (void) 1217{ 1218 struct bfd_link_hash_entry *undef, *sym; 1219 1220 if (pe_dll_extra_pe_debug) 1221 printf ("%s\n", __func__); 1222 1223 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next) 1224 if (undef->type == bfd_link_hash_undefined) 1225 { 1226 const char * name = undef->root.string; 1227 char * at; 1228 int lead_at = (*name == '@'); 1229 1230 if (lead_at) 1231 at = strchr (name + 1, '@'); 1232 else 1233 at = strchr (name, '@'); 1234 1235 if (at || lead_at) 1236 { 1237 /* The symbol is a stdcall symbol, so let's look for a 1238 cdecl symbol with the same name and resolve to that. */ 1239 char *cname = xstrdup (name); 1240 1241 if (lead_at) 1242 *cname = '_'; 1243 if (at) 1244 * strchr (cname, '@') = 0; 1245 sym = bfd_link_hash_lookup (link_info.hash, cname, false, false, true); 1246 1247 if (sym && sym->type == bfd_link_hash_defined) 1248 change_undef (undef, sym); 1249 } 1250 else 1251 { 1252 /* The symbol is a cdecl symbol, so we look for stdcall 1253 symbols - which means scanning the whole symbol table. */ 1254 pe_undef_found_sym = NULL; 1255 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match, 1256 (char *) name); 1257 if (pe_undef_found_sym) 1258 { 1259 change_undef (undef, pe_undef_found_sym); 1260 set_decoration (undef->root.string, pe_undef_found_sym); 1261 } 1262 } 1263 } 1264} 1265 1266static bfd_vma 1267read_addend (arelent *rel, asection *s) 1268{ 1269 char buf[4]; 1270 bfd_vma addend = 0; 1271 1272 if (!bfd_get_section_contents (s->owner, s, buf, rel->address, sizeof (buf))) 1273 einfo (_("%P: %H: cannot get section contents - auto-import exception\n"), 1274 s->owner, s, rel->address); 1275 else 1276 addend = bfd_get_32 (s->owner, buf); 1277 return addend; 1278} 1279 1280static void 1281make_import_fixup (arelent *rel, asection *s, char *name, const char *symname) 1282{ 1283 struct bfd_symbol *sym = *rel->sym_ptr_ptr; 1284 bfd_vma addend; 1285 1286 if (pe_dll_extra_pe_debug) 1287 printf ("arelent: %s@%#lx: add=%li\n", sym->name, 1288 (unsigned long) rel->address, (long) rel->addend); 1289 1290 addend = read_addend (rel, s); 1291 1292 if (pe_dll_extra_pe_debug) 1293 { 1294 printf ("import of 0x%lx(0x%lx) sec_addr=0x%lx", 1295 (long) addend, (long) rel->addend, (long) rel->address); 1296 if (rel->howto->pc_relative) 1297 printf (" pcrel"); 1298 printf (" %d bit rel.\n", (int) rel->howto->bitsize); 1299 } 1300 1301 pe_create_import_fixup (rel, s, addend, name, symname); 1302} 1303 1304static void 1305make_runtime_ref (void) 1306{ 1307 const char *rr = U ("_pei386_runtime_relocator"); 1308 struct bfd_link_hash_entry *h 1309 = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info, 1310 rr, true, false, true); 1311 if (!h) 1312 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n")); 1313 else 1314 { 1315 if (h->type == bfd_link_hash_new) 1316 { 1317 h->type = bfd_link_hash_undefined; 1318 h->u.undef.abfd = NULL; 1319 if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail) 1320 bfd_link_add_undef (link_info.hash, h); 1321 } 1322 h->non_ir_ref_regular = true; 1323 } 1324} 1325 1326static bool 1327pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED) 1328{ 1329 printf ("+%s\n", h->string); 1330 1331 return true; 1332} 1333#endif /* DLL_SUPPORT */ 1334 1335static void 1336debug_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj) 1337{ 1338 int *found = (int *) obj; 1339 if (strncmp (".debug_", sect->name, sizeof (".debug_") - 1) == 0) 1340 *found = 1; 1341} 1342 1343static bool 1344pecoff_checksum_contents (bfd *abfd, 1345 void (*process) (const void *, size_t, void *), 1346 void *arg) 1347{ 1348 file_ptr filepos = (file_ptr) 0; 1349 1350 while (1) 1351 { 1352 unsigned char b; 1353 int status; 1354 1355 if (bfd_seek (abfd, filepos, SEEK_SET) != 0) 1356 return 0; 1357 1358 status = bfd_read (&b, 1, abfd); 1359 if (status < 1) 1360 { 1361 break; 1362 } 1363 1364 (*process) (&b, 1, arg); 1365 filepos += 1; 1366 } 1367 1368 return true; 1369} 1370 1371static bool 1372write_build_id (bfd *abfd) 1373{ 1374 struct pe_tdata *td = pe_data (abfd); 1375 asection *asec; 1376 struct bfd_link_order *link_order = NULL; 1377 unsigned char *contents; 1378 bfd_size_type build_id_size; 1379 unsigned char *build_id; 1380 const char *pdb_base_name = NULL; 1381 1382 /* Find the section the .buildid output section has been merged info. */ 1383 for (asec = abfd->sections; asec != NULL; asec = asec->next) 1384 { 1385 struct bfd_link_order *l = NULL; 1386 for (l = asec->map_head.link_order; l != NULL; l = l->next) 1387 { 1388 if (l->type == bfd_indirect_link_order) 1389 { 1390 if (l->u.indirect.section == td->build_id.sec) 1391 { 1392 link_order = l; 1393 break; 1394 } 1395 } 1396 } 1397 1398 if (link_order) 1399 break; 1400 } 1401 1402 if (!link_order) 1403 { 1404 einfo (_("%P: warning: .buildid section discarded," 1405 " --build-id ignored\n")); 1406 return true; 1407 } 1408 1409 if (td->build_id.sec->contents == NULL) 1410 td->build_id.sec->contents = xmalloc (td->build_id.sec->size); 1411 contents = td->build_id.sec->contents; 1412 1413 build_id_size = compute_build_id_size (td->build_id.style); 1414 build_id = xmalloc (build_id_size); 1415 generate_build_id (abfd, td->build_id.style, pecoff_checksum_contents, 1416 build_id, build_id_size); 1417 1418 bfd_vma ib = td->pe_opthdr.ImageBase; 1419 1420#ifdef PDB_H 1421 if (pdb_name) 1422 pdb_base_name = lbasename (pdb_name); 1423#endif 1424 1425 /* Construct a debug directory entry which points to an immediately following CodeView record. */ 1426 struct internal_IMAGE_DEBUG_DIRECTORY idd; 1427 idd.Characteristics = 0; 1428 idd.TimeDateStamp = 0; 1429 idd.MajorVersion = 0; 1430 idd.MinorVersion = 0; 1431 idd.Type = PE_IMAGE_DEBUG_TYPE_CODEVIEW; 1432 idd.SizeOfData = (sizeof (CV_INFO_PDB70) 1433#ifdef PDB_H 1434 + (pdb_base_name ? strlen (pdb_base_name) : 0) 1435#endif 1436 + 1); 1437 idd.AddressOfRawData = asec->vma - ib + link_order->offset 1438 + sizeof (struct external_IMAGE_DEBUG_DIRECTORY); 1439 idd.PointerToRawData = asec->filepos + link_order->offset 1440 + sizeof (struct external_IMAGE_DEBUG_DIRECTORY); 1441 1442 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *)contents; 1443 _bfd_XXi_swap_debugdir_out (abfd, &idd, ext); 1444 1445 /* Write the debug directory entry. */ 1446 if (bfd_seek (abfd, asec->filepos + link_order->offset, SEEK_SET) != 0) 1447 return 0; 1448 1449 if (bfd_write (contents, sizeof (*ext), abfd) != sizeof (*ext)) 1450 return 0; 1451 1452#ifdef PDB_H 1453 if (pdb) 1454 { 1455 if (!create_pdb_file (abfd, pdb_name, build_id)) 1456 return 0; 1457 } 1458#endif 1459 1460 /* Construct the CodeView record. */ 1461 CODEVIEW_INFO cvinfo; 1462 cvinfo.CVSignature = CVINFO_PDB70_CVSIGNATURE; 1463 cvinfo.Age = 1; 1464 1465 /* Zero pad or truncate the generated build_id to fit in the 1466 CodeView record. */ 1467 memset (&(cvinfo.Signature), 0, CV_INFO_SIGNATURE_LENGTH); 1468 memcpy (&(cvinfo.Signature), build_id, 1469 (build_id_size > CV_INFO_SIGNATURE_LENGTH 1470 ? CV_INFO_SIGNATURE_LENGTH : build_id_size)); 1471 1472 free (build_id); 1473 1474 /* Write the codeview record. */ 1475 if (_bfd_XXi_write_codeview_record (abfd, idd.PointerToRawData, &cvinfo, 1476 pdb_base_name) == 0) 1477 return 0; 1478 1479 /* Record the location of the debug directory in the data directory. */ 1480 td->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress 1481 = asec->vma - ib + link_order->offset; 1482 td->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size 1483 = sizeof (struct external_IMAGE_DEBUG_DIRECTORY); 1484 1485 return true; 1486} 1487 1488/* Make .buildid section, and set up coff_tdata->build_id. */ 1489static bool 1490setup_build_id (bfd *ibfd) 1491{ 1492 asection *s; 1493 flagword flags; 1494 1495 if (!validate_build_id_style (emit_build_id)) 1496 { 1497 einfo (_("%P: warning: unrecognized --build-id style ignored\n")); 1498 return false; 1499 } 1500 1501 flags = (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_IN_MEMORY 1502 | SEC_LINKER_CREATED | SEC_READONLY | SEC_DATA); 1503 s = bfd_make_section_anyway_with_flags (ibfd, ".buildid", flags); 1504 if (s != NULL) 1505 { 1506 struct pe_tdata *td = pe_data (link_info.output_bfd); 1507 td->build_id.after_write_object_contents = &write_build_id; 1508 td->build_id.style = emit_build_id; 1509 td->build_id.sec = s; 1510 1511 /* Section is a fixed size: 1512 One IMAGE_DEBUG_DIRECTORY entry, of type IMAGE_DEBUG_TYPE_CODEVIEW, 1513 pointing at a CV_INFO_PDB70 record containing the build-id, followed by 1514 PdbFileName if relevant. */ 1515 s->size = (sizeof (struct external_IMAGE_DEBUG_DIRECTORY) 1516 + sizeof (CV_INFO_PDB70) + 1); 1517 1518#ifdef PDB_H 1519 if (pdb_name) 1520 s->size += strlen (lbasename (pdb_name)); 1521#endif 1522 return true; 1523 } 1524 1525 einfo (_("%P: warning: cannot create .buildid section," 1526 " --build-id ignored\n")); 1527 return false; 1528} 1529 1530static void 1531gld${EMULATION_NAME}_before_plugin_all_symbols_read (void) 1532{ 1533#ifdef DLL_SUPPORT 1534 if (link_info.lto_plugin_active 1535 && link_info.pei386_auto_import) 1536 make_runtime_ref (); 1537#endif 1538} 1539 1540static void 1541gld${EMULATION_NAME}_after_open (void) 1542{ 1543 after_open_default (); 1544 1545#ifdef DLL_SUPPORT 1546 if (pe_dll_extra_pe_debug) 1547 { 1548 bfd *a; 1549 struct bfd_link_hash_entry *sym; 1550 1551 printf ("%s()\n", __func__); 1552 1553 for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next) 1554 printf ("-%s\n", sym->root.string); 1555 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL); 1556 1557 for (a = link_info.input_bfds; a; a = a->link.next) 1558 printf ("*%s\n", bfd_get_filename (a)); 1559 } 1560#endif 1561 1562#ifdef PDB_H 1563 if (pdb && !pdb_name) 1564 { 1565 const char *base = lbasename (bfd_get_filename (link_info.output_bfd)); 1566 size_t len = strlen (base); 1567 static const char suffix[] = ".pdb"; 1568 1569 while (len > 0 && base[len] != '.') 1570 { 1571 len--; 1572 } 1573 1574 if (len == 0) 1575 len = strlen (base); 1576 1577 pdb_name = xmalloc (len + sizeof (suffix)); 1578 memcpy (pdb_name, base, len); 1579 memcpy (pdb_name + len, suffix, sizeof (suffix)); 1580 } 1581#endif 1582 1583 if (emit_build_id != NULL) 1584 { 1585 bfd *abfd; 1586 1587 /* Find a COFF input. */ 1588 for (abfd = link_info.input_bfds; 1589 abfd != (bfd *) NULL; abfd = abfd->link.next) 1590 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour) 1591 break; 1592 1593 /* If there are no COFF input files do not try to 1594 add a build-id section. */ 1595 if (abfd == NULL 1596 || !setup_build_id (abfd)) 1597 { 1598 free ((char *) emit_build_id); 1599 emit_build_id = NULL; 1600 } 1601 } 1602 1603 /* Pass the wacky PE command line options into the output bfd. 1604 FIXME: This should be done via a function, rather than by 1605 including an internal BFD header. */ 1606 1607 if (bfd_get_flavour (link_info.output_bfd) != bfd_target_coff_flavour 1608 || coff_data (link_info.output_bfd) == NULL 1609 || !obj_pe (link_info.output_bfd)) 1610 einfo (_("%F%P: cannot perform PE operations on non PE output file '%pB'\n"), 1611 link_info.output_bfd); 1612 1613 pe_data (link_info.output_bfd)->pe_opthdr = pe; 1614 pe_data (link_info.output_bfd)->dll = init[DLLOFF].value; 1615 pe_data (link_info.output_bfd)->real_flags |= real_flags; 1616 if (insert_timestamp) 1617 pe_data (link_info.output_bfd)->timestamp = -1; 1618 else 1619 pe_data (link_info.output_bfd)->timestamp = 0; 1620 1621 /* At this point we must decide whether to use long section names 1622 in the output or not. If the user hasn't explicitly specified 1623 on the command line, we leave it to the default for the format 1624 (object files yes, image files no), except if there is debug 1625 information present; GDB relies on the long section names to 1626 find it, so enable it in that case. */ 1627 if (pe_use_coff_long_section_names < 0 && link_info.strip == strip_none) 1628 { 1629 if (bfd_link_relocatable (&link_info)) 1630 pe_use_coff_long_section_names = 1; 1631 else 1632 { 1633 /* Iterate over all sections of all input BFDs, checking 1634 for any that begin 'debug_' and are long names. */ 1635 LANG_FOR_EACH_INPUT_STATEMENT (is) 1636 { 1637 int found_debug = 0; 1638 1639 bfd_map_over_sections (is->the_bfd, debug_section_p, &found_debug); 1640 if (found_debug) 1641 { 1642 pe_use_coff_long_section_names = 1; 1643 break; 1644 } 1645 } 1646 } 1647 } 1648 1649 pe_output_file_set_long_section_names (link_info.output_bfd); 1650 1651#ifdef DLL_SUPPORT 1652 pe_process_import_defs (link_info.output_bfd, &link_info); 1653 1654 if (link_info.pei386_auto_import) /* -1=warn or 1=enable */ 1655 pe_find_data_imports (U ("_head_"), make_import_fixup); 1656 1657 /* The implementation of the feature is rather dumb and would cause the 1658 compilation time to go through the roof if there are many undefined 1659 symbols in the link, so it needs to be run after auto-import. */ 1660 if (pe_enable_stdcall_fixup) /* -1=warn or 1=enable */ 1661 pe_fixup_stdcalls (); 1662 1663#if defined (TARGET_IS_i386pe) \ 1664 || defined (TARGET_IS_armpe) \ 1665 || defined (TARGET_IS_arm_wince_pe) 1666 if (!bfd_link_relocatable (&link_info)) 1667 pe_dll_build_sections (link_info.output_bfd, &link_info); 1668#else 1669 if (bfd_link_pic (&link_info)) 1670 pe_dll_build_sections (link_info.output_bfd, &link_info); 1671 else 1672 pe_exe_build_sections (link_info.output_bfd, &link_info); 1673#endif 1674#endif /* DLL_SUPPORT */ 1675 1676#if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe) 1677 if (strstr (bfd_get_target (link_info.output_bfd), "arm") == NULL) 1678 { 1679 /* The arm backend needs special fields in the output hash structure. 1680 These will only be created if the output format is an arm format, 1681 hence we do not support linking and changing output formats at the 1682 same time. Use a link followed by objcopy to change output formats. */ 1683 einfo (_("%F%P: error: cannot change output format " 1684 "whilst linking %s binaries\n"), "ARM"); 1685 return; 1686 } 1687 { 1688 /* Find a BFD that can hold the interworking stubs. */ 1689 LANG_FOR_EACH_INPUT_STATEMENT (is) 1690 { 1691 if (bfd_arm_get_bfd_for_interworking (is->the_bfd, & link_info)) 1692 break; 1693 } 1694 } 1695#endif 1696 1697 { 1698 /* This next chunk of code tries to detect the case where you have 1699 two import libraries for the same DLL (specifically, 1700 symbolically linking libm.a and libc.a in cygwin to 1701 libcygwin.a). In those cases, it's possible for function 1702 thunks from the second implib to be used but without the 1703 head/tail objects, causing an improper import table. We detect 1704 those cases and rename the "other" import libraries to match 1705 the one the head/tail come from, so that the linker will sort 1706 things nicely and produce a valid import table. */ 1707 1708 LANG_FOR_EACH_INPUT_STATEMENT (is) 1709 { 1710 if (is->the_bfd->my_archive) 1711 { 1712 int idata2 = 0, reloc_count=0, is_imp = 0; 1713 asection *sec; 1714 1715 /* See if this is an import library thunk. */ 1716 for (sec = is->the_bfd->sections; sec; sec = sec->next) 1717 { 1718 if (strcmp (sec->name, ".idata\$2") == 0) 1719 idata2 = 1; 1720 if (startswith (sec->name, ".idata\$")) 1721 is_imp = 1; 1722 reloc_count += sec->reloc_count; 1723 } 1724 1725 if (is_imp && !idata2 && reloc_count) 1726 { 1727 /* It is, look for the reference to head and see if it's 1728 from our own library. */ 1729 for (sec = is->the_bfd->sections; sec; sec = sec->next) 1730 { 1731 int i; 1732 long relsize; 1733 asymbol **symbols; 1734 arelent **relocs; 1735 int nrelocs; 1736 1737 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec); 1738 if (relsize < 1) 1739 break; 1740 1741 if (!bfd_generic_link_read_symbols (is->the_bfd)) 1742 { 1743 einfo (_("%F%P: %pB: could not read symbols: %E\n"), 1744 is->the_bfd); 1745 return; 1746 } 1747 symbols = bfd_get_outsymbols (is->the_bfd); 1748 1749 relocs = xmalloc ((size_t) relsize); 1750 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec, 1751 relocs, symbols); 1752 if (nrelocs < 0) 1753 { 1754 free (relocs); 1755 einfo (_("%X%P: unable to process relocs: %E\n")); 1756 return; 1757 } 1758 1759 for (i = 0; i < nrelocs; i++) 1760 { 1761 struct bfd_symbol *s; 1762 struct bfd_link_hash_entry * blhe; 1763 bfd *other_bfd; 1764 const char *other_bfd_filename; 1765 1766 s = (relocs[i]->sym_ptr_ptr)[0]; 1767 1768 if (s->flags & BSF_LOCAL) 1769 continue; 1770 1771 /* Thunk section with reloc to another bfd. */ 1772 blhe = bfd_link_hash_lookup (link_info.hash, 1773 s->name, 1774 false, false, true); 1775 1776 if (blhe == NULL 1777 || blhe->type != bfd_link_hash_defined) 1778 continue; 1779 1780 other_bfd = blhe->u.def.section->owner; 1781 if (other_bfd->my_archive == is->the_bfd->my_archive) 1782 continue; 1783 1784 other_bfd_filename 1785 = (other_bfd->my_archive 1786 ? bfd_get_filename (other_bfd->my_archive) 1787 : bfd_get_filename (other_bfd)); 1788 1789 if (filename_cmp (bfd_get_filename 1790 (is->the_bfd->my_archive), 1791 other_bfd_filename) == 0) 1792 continue; 1793 1794 /* Sort this implib to match the other one. */ 1795 lang_input_statement_type *arch_is 1796 = bfd_usrdata (is->the_bfd->my_archive); 1797 arch_is->sort_key = other_bfd_filename; 1798 break; 1799 } 1800 1801 free (relocs); 1802 /* Note - we do not free the symbols, 1803 they are now cached in the BFD. */ 1804 } 1805 } 1806 } 1807 } 1808 } 1809 1810 { 1811 1812 /* Careful - this is a shell script. Watch those dollar signs! */ 1813 /* Microsoft import libraries have every member named the same, 1814 and not in the right order for us to link them correctly. We 1815 must detect these and rename the members so that they'll link 1816 correctly. There are three types of objects: the head, the 1817 thunks, and the sentinel(s). The head is easy; it's the one 1818 with idata2. We assume that the sentinels won't have relocs, 1819 and the thunks will. It's easier than checking the symbol 1820 table for external references. */ 1821 LANG_FOR_EACH_INPUT_STATEMENT (is) 1822 { 1823 if (is->the_bfd->my_archive) 1824 { 1825 char *pnt; 1826 1827 /* Microsoft import libraries may contain archive members for 1828 one or more DLLs, together with static object files. 1829 Inspect all members that are named *.dll - check whether 1830 they contain .idata sections. Do the renaming of all 1831 archive members that seem to be Microsoft style import 1832 objects. */ 1833 pnt = strrchr (bfd_get_filename (is->the_bfd), '.'); 1834 1835 if (pnt != NULL && (fileext_cmp (pnt + 1, "dll") == 0)) 1836 { 1837 int idata2 = 0, reloc_count = 0, idata = 0; 1838 asection *sec; 1839 char *new_name, seq; 1840 1841 for (sec = is->the_bfd->sections; sec; sec = sec->next) 1842 { 1843 if (strcmp (sec->name, ".idata\$2") == 0) 1844 idata2 = 1; 1845 if (strncmp (sec->name, ".idata\$", 6) == 0) 1846 idata = 1; 1847 reloc_count += sec->reloc_count; 1848 } 1849 1850 /* An archive member named .dll, but not having any .idata 1851 sections - apparently not a Microsoft import object 1852 after all: Skip renaming it. */ 1853 if (!idata) 1854 continue; 1855 1856 if (idata2) /* .idata2 is the TOC */ 1857 seq = 'a'; 1858 else if (reloc_count > 0) /* thunks */ 1859 seq = 'b'; 1860 else /* sentinel */ 1861 seq = 'c'; 1862 1863 new_name 1864 = xmalloc (strlen (bfd_get_filename (is->the_bfd)) + 3); 1865 sprintf (new_name, "%s.%c", 1866 bfd_get_filename (is->the_bfd), seq); 1867 is->sort_key = new_name; 1868 } 1869 } 1870 } 1871 } 1872 1873 { 1874 /* The following chunk of code tries to identify jump stubs in 1875 import libraries which are dead code and eliminates them 1876 from the final link. For each exported symbol <sym>, there 1877 is a object file in the import library with a .text section 1878 and several .idata\$* sections. The .text section contains the 1879 symbol definition for <sym> which is a jump stub of the form 1880 jmp *__imp_<sym>. The .idata\$5 contains the symbol definition 1881 for __imp_<sym> which is the address of the slot for <sym> in 1882 the import address table. When a symbol is imported explicitly 1883 using __declspec(dllimport) declaration, the compiler generates 1884 a reference to __imp_<sym> which directly resolves to the 1885 symbol in .idata\$5, in which case the jump stub code is not 1886 needed. The following code tries to identify jump stub sections 1887 in import libraries which are not referred to by anyone and 1888 marks them for exclusion from the final link. */ 1889 LANG_FOR_EACH_INPUT_STATEMENT (is) 1890 { 1891 if (is->the_bfd->my_archive) 1892 { 1893 int is_imp = 0; 1894 asection *sec, *stub_sec = NULL; 1895 1896 /* See if this is an import library thunk. */ 1897 for (sec = is->the_bfd->sections; sec; sec = sec->next) 1898 { 1899 if (strncmp (sec->name, ".idata\$", 7) == 0) 1900 is_imp = 1; 1901 /* The section containing the jmp stub has code 1902 and has a reloc. */ 1903 if ((sec->flags & SEC_CODE) && sec->reloc_count) 1904 stub_sec = sec; 1905 } 1906 1907 if (is_imp && stub_sec) 1908 { 1909 asymbol **symbols; 1910 long nsyms, src_count; 1911 struct bfd_link_hash_entry * blhe; 1912 1913 if (!bfd_generic_link_read_symbols (is->the_bfd)) 1914 { 1915 einfo (_("%F%P: %pB: could not read symbols: %E\n"), 1916 is->the_bfd); 1917 return; 1918 } 1919 symbols = bfd_get_outsymbols (is->the_bfd); 1920 nsyms = bfd_get_symcount (is->the_bfd); 1921 1922 for (src_count = 0; src_count < nsyms; src_count++) 1923 { 1924 if (symbols[src_count]->section->id == stub_sec->id) 1925 { 1926 /* This symbol belongs to the section containing 1927 the stub. */ 1928 blhe = bfd_link_hash_lookup (link_info.hash, 1929 symbols[src_count]->name, 1930 false, false, true); 1931 /* If the symbol in the stub section has no other 1932 undefined references, exclude the stub section 1933 from the final link. */ 1934 if (blhe != NULL 1935 && blhe->type == bfd_link_hash_defined 1936 && blhe->u.undef.next == NULL 1937 && blhe != link_info.hash->undefs_tail) 1938 stub_sec->flags |= SEC_EXCLUDE; 1939 } 1940 } 1941 } 1942 } 1943 } 1944 } 1945} 1946 1947static void 1948gld${EMULATION_NAME}_before_allocation (void) 1949{ 1950#if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe) 1951 /* FIXME: we should be able to set the size of the interworking stub 1952 section. 1953 1954 Here we rummage through the found bfds to collect glue 1955 information. FIXME: should this be based on a command line 1956 option? krk@cygnus.com. */ 1957 { 1958 LANG_FOR_EACH_INPUT_STATEMENT (is) 1959 { 1960 if (! bfd_arm_process_before_allocation 1961 (is->the_bfd, & link_info, support_old_code)) 1962 { 1963 /* xgettext:c-format */ 1964 einfo (_("%P: errors encountered processing file %s for interworking\n"), 1965 is->filename); 1966 } 1967 } 1968 } 1969 1970 /* We have seen it all. Allocate it, and carry on. */ 1971 bfd_arm_allocate_interworking_sections (& link_info); 1972#endif /* TARGET_IS_armpe || TARGET_IS_arm_wince_pe */ 1973 1974 before_allocation_default (); 1975} 1976 1977#ifdef DLL_SUPPORT 1978/* This is called when an input file isn't recognized as a BFD. We 1979 check here for .DEF files and pull them in automatically. */ 1980 1981static int 1982saw_option (char *option) 1983{ 1984 int i; 1985 1986 for (i = 0; init[i].ptr; i++) 1987 if (strcmp (GET_INIT_SYMBOL_NAME (i), option) == 0) 1988 return init[i].inited; 1989 return 0; 1990} 1991#endif /* DLL_SUPPORT */ 1992 1993static bool 1994gld${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED) 1995{ 1996#ifdef DLL_SUPPORT 1997 const char *ext = strrchr (entry->filename, '.'); 1998 1999 if (ext != NULL && fileext_cmp (ext + 1, "def") == 0) 2000 { 2001 pe_def_file = def_file_parse (entry->filename, pe_def_file); 2002 2003 if (pe_def_file) 2004 { 2005 int i, buflen=0, len; 2006 char *buf; 2007 2008 for (i = 0; i < pe_def_file->num_exports; i++) 2009 { 2010 len = strlen (pe_def_file->exports[i].internal_name); 2011 if (buflen < len + 2) 2012 buflen = len + 2; 2013 } 2014 2015 buf = xmalloc (buflen); 2016 2017 for (i = 0; i < pe_def_file->num_exports; i++) 2018 { 2019 struct bfd_link_hash_entry *h; 2020 2021 sprintf (buf, "%s%s", U (""), 2022 pe_def_file->exports[i].internal_name); 2023 2024 h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true); 2025 if (h == (struct bfd_link_hash_entry *) NULL) 2026 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n")); 2027 if (h->type == bfd_link_hash_new) 2028 { 2029 h->type = bfd_link_hash_undefined; 2030 h->u.undef.abfd = NULL; 2031 bfd_link_add_undef (link_info.hash, h); 2032 } 2033 } 2034 free (buf); 2035 2036 /* def_file_print (stdout, pe_def_file); */ 2037 if (pe_def_file->is_dll == 1) 2038 link_info.type = type_dll; 2039 2040 if (pe_def_file->base_address != (bfd_vma)(-1)) 2041 { 2042 pe.ImageBase 2043 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase 2044 = init[IMAGEBASEOFF].value 2045 = pe_def_file->base_address; 2046 init[IMAGEBASEOFF].inited = 1; 2047 if (image_base_statement) 2048 image_base_statement->exp 2049 = exp_assign ("__image_base__", exp_intop (pe.ImageBase), 2050 false); 2051 } 2052 2053 if (pe_def_file->stack_reserve != -1 2054 && ! saw_option ("__size_of_stack_reserve__")) 2055 { 2056 pe.SizeOfStackReserve = pe_def_file->stack_reserve; 2057 if (pe_def_file->stack_commit != -1) 2058 pe.SizeOfStackCommit = pe_def_file->stack_commit; 2059 } 2060 if (pe_def_file->heap_reserve != -1 2061 && ! saw_option ("__size_of_heap_reserve__")) 2062 { 2063 pe.SizeOfHeapReserve = pe_def_file->heap_reserve; 2064 if (pe_def_file->heap_commit != -1) 2065 pe.SizeOfHeapCommit = pe_def_file->heap_commit; 2066 } 2067 return true; 2068 } 2069 } 2070#endif 2071 return false; 2072} 2073 2074static bool 2075gld${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED) 2076{ 2077#ifdef DLL_SUPPORT 2078#ifdef TARGET_IS_i386pe 2079 pe_dll_id_target ("pei-i386"); 2080#endif 2081#ifdef TARGET_IS_shpe 2082 pe_dll_id_target ("pei-shl"); 2083#endif 2084#ifdef TARGET_IS_armpe 2085 pe_dll_id_target ("pei-arm-little"); 2086#endif 2087#ifdef TARGET_IS_arm_wince_pe 2088 pe_dll_id_target ("pei-arm-wince-little"); 2089#endif 2090 if (pe_bfd_is_dll (entry->the_bfd)) 2091 return pe_implied_import_dll (entry->filename); 2092#endif 2093 return false; 2094} 2095 2096static void 2097gld${EMULATION_NAME}_finish (void) 2098{ 2099#if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe) 2100 struct bfd_link_hash_entry * h; 2101 2102 if (thumb_entry_symbol != NULL) 2103 { 2104 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol, 2105 false, false, true); 2106 2107 if (h != (struct bfd_link_hash_entry *) NULL 2108 && (h->type == bfd_link_hash_defined 2109 || h->type == bfd_link_hash_defweak) 2110 && h->u.def.section->output_section != NULL) 2111 { 2112 static char buffer[32]; 2113 bfd_vma val; 2114 2115 /* Special procesing is required for a Thumb entry symbol. The 2116 bottom bit of its address must be set. */ 2117 val = (h->u.def.value 2118 + bfd_section_vma (h->u.def.section->output_section) 2119 + h->u.def.section->output_offset); 2120 2121 val |= 1; 2122 2123 /* Now convert this value into a string and store it in entry_symbol 2124 where the lang_finish() function will pick it up. */ 2125 sprintf (buffer, "0x%" PRIx64, (uint64_t) val); 2126 2127 if (entry_symbol.name != NULL && entry_from_cmdline) 2128 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"), 2129 thumb_entry_symbol, entry_symbol.name); 2130 entry_symbol.name = buffer; 2131 } 2132 else 2133 einfo (_("%P: warning: cannot find thumb start symbol %s\n"), thumb_entry_symbol); 2134 } 2135#endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe) */ 2136 2137 finish_default (); 2138 2139#ifdef DLL_SUPPORT 2140 if (bfd_link_pic (&link_info) 2141#if !defined(TARGET_IS_shpe) 2142 || pe_dll_enable_reloc_section 2143 || (!bfd_link_relocatable (&link_info) 2144 && pe_def_file->num_exports != 0) 2145#endif 2146 ) 2147 { 2148 pe_dll_fill_sections (link_info.output_bfd, &link_info); 2149 if (command_line.out_implib_filename 2150 && (pe_def_file->num_exports != 0 2151 || bfd_link_pic (&link_info))) 2152 pe_dll_generate_implib (pe_def_file, command_line.out_implib_filename, 2153 &link_info); 2154 } 2155#if defined(TARGET_IS_shpe) 2156 /* ARM doesn't need relocs. */ 2157 else 2158 { 2159 pe_exe_fill_sections (link_info.output_bfd, &link_info); 2160 } 2161#endif 2162 2163 if (pe_out_def_filename) 2164 pe_dll_generate_def_file (pe_out_def_filename); 2165#endif /* DLL_SUPPORT */ 2166 2167 /* I don't know where .idata gets set as code, but it shouldn't be. */ 2168 { 2169 asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata"); 2170 2171 if (asec) 2172 { 2173 asec->flags &= ~SEC_CODE; 2174 asec->flags |= SEC_DATA; 2175 } 2176 } 2177} 2178 2179 2180/* Place an orphan section. 2181 2182 We use this to put sections in a reasonable place in the file, and 2183 to ensure that they are aligned as required. 2184 2185 We handle grouped sections here as well. A section named .foo\$nn 2186 goes into the output section .foo. All grouped sections are sorted 2187 by name. 2188 2189 Grouped sections for the default sections are handled by the 2190 default linker script using wildcards, and are sorted by 2191 sort_sections. */ 2192 2193static lang_output_section_statement_type * 2194gld${EMULATION_NAME}_place_orphan (asection *s, 2195 const char *secname, 2196 int constraint) 2197{ 2198 const char *orig_secname = secname; 2199 char *dollar = NULL; 2200 lang_output_section_statement_type *os; 2201 lang_statement_list_type add_child; 2202 lang_output_section_statement_type *match_by_name = NULL; 2203 lang_statement_union_type **pl; 2204 2205 /* Look through the script to see where to place this section. */ 2206 if (!bfd_link_relocatable (&link_info) 2207 && (dollar = strchr (secname, '\$')) != NULL) 2208 { 2209 size_t len = dollar - secname; 2210 char *newname = xmalloc (len + 1); 2211 memcpy (newname, secname, len); 2212 newname[len] = '\0'; 2213 secname = newname; 2214 } 2215 2216 lang_list_init (&add_child); 2217 2218 os = NULL; 2219 if (constraint == 0) 2220 for (os = lang_output_section_find (secname); 2221 os != NULL; 2222 os = next_matching_output_section_statement (os, 0)) 2223 { 2224 /* If we don't match an existing output section, tell 2225 lang_insert_orphan to create a new output section. */ 2226 constraint = SPECIAL; 2227 2228 if (os->bfd_section != NULL 2229 && (os->bfd_section->flags == 0 2230 || ((s->flags ^ os->bfd_section->flags) 2231 & (SEC_LOAD | SEC_ALLOC)) == 0)) 2232 { 2233 /* We already have an output section statement with this 2234 name, and its bfd section has compatible flags. 2235 If the section already exists but does not have any flags set, 2236 then it has been created by the linker, probably as a result of 2237 a --section-start command line switch. */ 2238 lang_add_section (&add_child, s, NULL, NULL, os); 2239 break; 2240 } 2241 2242 /* Save unused output sections in case we can match them 2243 against orphans later. */ 2244 if (os->bfd_section == NULL) 2245 match_by_name = os; 2246 } 2247 2248 /* If we didn't match an active output section, see if we matched an 2249 unused one and use that. */ 2250 if (os == NULL && match_by_name) 2251 { 2252 lang_add_section (&match_by_name->children, s, NULL, NULL, match_by_name); 2253 return match_by_name; 2254 } 2255 2256 if (os == NULL) 2257 { 2258 static struct orphan_save hold[] = 2259 { 2260 { ".text", 2261 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE, 2262 0, 0, 0, 0 }, 2263 { ".idata", 2264 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 2265 0, 0, 0, 0 }, 2266 { ".rdata", 2267 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 2268 0, 0, 0, 0 }, 2269 { ".data", 2270 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA, 2271 0, 0, 0, 0 }, 2272 { ".bss", 2273 SEC_ALLOC, 2274 0, 0, 0, 0 } 2275 }; 2276 enum orphan_save_index 2277 { 2278 orphan_text = 0, 2279 orphan_idata, 2280 orphan_rodata, 2281 orphan_data, 2282 orphan_bss 2283 }; 2284 static int orphan_init_done = 0; 2285 struct orphan_save *place; 2286 lang_output_section_statement_type *after; 2287 etree_type *address; 2288 flagword flags; 2289 asection *nexts; 2290 2291 if (!orphan_init_done) 2292 { 2293 struct orphan_save *ho; 2294 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho) 2295 if (ho->name != NULL) 2296 { 2297 ho->os = lang_output_section_find (ho->name); 2298 if (ho->os != NULL && ho->os->flags == 0) 2299 ho->os->flags = ho->flags; 2300 } 2301 orphan_init_done = 1; 2302 } 2303 2304 flags = s->flags; 2305 if (!bfd_link_relocatable (&link_info)) 2306 { 2307 nexts = s; 2308 while ((nexts = bfd_get_next_section_by_name (nexts->owner, 2309 nexts))) 2310 if (nexts->output_section == NULL 2311 && (nexts->flags & SEC_EXCLUDE) == 0 2312 && ((nexts->flags ^ flags) & (SEC_LOAD | SEC_ALLOC)) == 0 2313 && (nexts->owner->flags & DYNAMIC) == 0 2314 && !bfd_input_just_syms (nexts->owner)) 2315 flags = (((flags ^ SEC_READONLY) 2316 | (nexts->flags ^ SEC_READONLY)) 2317 ^ SEC_READONLY); 2318 } 2319 2320 /* Try to put the new output section in a reasonable place based 2321 on the section name and section flags. */ 2322 2323 place = NULL; 2324 if ((flags & SEC_ALLOC) == 0) 2325 ; 2326 else if ((flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 2327 place = &hold[orphan_bss]; 2328 else if ((flags & SEC_READONLY) == 0) 2329 place = &hold[orphan_data]; 2330 else if ((flags & SEC_CODE) == 0) 2331 { 2332 place = (!strncmp (secname, ".idata\$", 7) ? &hold[orphan_idata] 2333 : &hold[orphan_rodata]); 2334 } 2335 else 2336 place = &hold[orphan_text]; 2337 2338 after = NULL; 2339 if (place != NULL) 2340 { 2341 if (place->os == NULL) 2342 place->os = lang_output_section_find (place->name); 2343 after = place->os; 2344 if (after == NULL) 2345 after = lang_output_section_find_by_flags (s, flags, &place->os, 2346 NULL); 2347 if (after == NULL) 2348 /* *ABS* is always the first output section statement. */ 2349 after = (void *) lang_os_list.head; 2350 } 2351 2352 /* All sections in an executable must be aligned to a page boundary. 2353 In a relocatable link, just preserve the incoming alignment; the 2354 address is discarded by lang_insert_orphan in that case, anyway. */ 2355 address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__")); 2356 os = lang_insert_orphan (s, secname, constraint, after, place, address, 2357 &add_child); 2358 if (bfd_link_relocatable (&link_info)) 2359 { 2360 os->section_alignment = exp_intop (1U << s->alignment_power); 2361 os->bfd_section->alignment_power = s->alignment_power; 2362 } 2363 } 2364 2365 /* If the section name has a '\$', sort it with the other '\$' 2366 sections. */ 2367 for (pl = &os->children.head; *pl != NULL; pl = &(*pl)->header.next) 2368 { 2369 lang_input_section_type *ls; 2370 const char *lname; 2371 2372 if ((*pl)->header.type != lang_input_section_enum) 2373 continue; 2374 2375 ls = &(*pl)->input_section; 2376 2377 lname = bfd_section_name (ls->section); 2378 if (strchr (lname, '\$') != NULL 2379 && (dollar == NULL || strcmp (orig_secname, lname) < 0)) 2380 break; 2381 } 2382 2383 if (add_child.head != NULL) 2384 { 2385 *add_child.tail = *pl; 2386 *pl = add_child.head; 2387 } 2388 2389 return os; 2390} 2391 2392static bool 2393gld${EMULATION_NAME}_open_dynamic_archive 2394 (const char *arch ATTRIBUTE_UNUSED, 2395 search_dirs_type *search, 2396 lang_input_statement_type *entry) 2397{ 2398 static const struct 2399 { 2400 const char * format; 2401 bool use_prefix; 2402 } 2403 libname_fmt [] = 2404 { 2405 /* Preferred explicit import library for dll's. */ 2406 { "lib%s.dll.a", false }, 2407 /* Alternate explicit import library for dll's. */ 2408 { "%s.dll.a", false }, 2409 /* "libfoo.a" could be either an import lib or a static lib. 2410 For backwards compatibility, libfoo.a needs to precede 2411 libfoo.dll and foo.dll in the search. */ 2412 { "lib%s.a", false }, 2413 /* The 'native' spelling of an import lib name is "foo.lib". */ 2414 { "%s.lib", false }, 2415 /* PR 22948 - Check for an import library. */ 2416 { "lib%s.lib", false }, 2417#ifdef DLL_SUPPORT 2418 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */ 2419 { "%s%s.dll", true }, 2420#endif 2421 /* Try "libfoo.dll" (default preferred dll name). */ 2422 { "lib%s.dll", false }, 2423 /* Finally try 'native' dll name "foo.dll". */ 2424 { "%s.dll", false }, 2425 /* Note: If adding more formats to this table, make sure to check to 2426 see if their length is longer than libname_fmt[0].format, and if 2427 so, update the call to xmalloc() below. */ 2428 { NULL, false } 2429 }; 2430 static unsigned int format_max_len = 0; 2431 const char * filename; 2432 char * full_string; 2433 char * base_string; 2434 unsigned int i; 2435 2436 2437 if (! entry->flags.maybe_archive || entry->flags.full_name_provided) 2438 return false; 2439 2440 filename = entry->filename; 2441 2442 if (format_max_len == 0) 2443 /* We need to allow space in the memory that we are going to allocate 2444 for the characters in the format string. Since the format array is 2445 static we only need to calculate this information once. In theory 2446 this value could also be computed statically, but this introduces 2447 the possibility for a discrepancy and hence a possible memory 2448 corruption. The lengths we compute here will be too long because 2449 they will include any formating characters (%s) in the strings, but 2450 this will not matter. */ 2451 for (i = 0; libname_fmt[i].format; i++) 2452 if (format_max_len < strlen (libname_fmt[i].format)) 2453 format_max_len = strlen (libname_fmt[i].format); 2454 2455 full_string = xmalloc (strlen (search->name) 2456 + strlen (filename) 2457 + format_max_len 2458#ifdef DLL_SUPPORT 2459 + (pe_dll_search_prefix 2460 ? strlen (pe_dll_search_prefix) : 0) 2461#endif 2462 /* Allow for the terminating NUL and for the path 2463 separator character that is inserted between 2464 search->name and the start of the format string. */ 2465 + 2); 2466 2467 base_string = stpcpy (full_string, search->name); 2468 *base_string++ = '/'; 2469 2470 for (i = 0; libname_fmt[i].format; i++) 2471 { 2472#ifdef DLL_SUPPORT 2473 if (libname_fmt[i].use_prefix) 2474 { 2475 if (!pe_dll_search_prefix) 2476 continue; 2477 sprintf (base_string, libname_fmt[i].format, pe_dll_search_prefix, filename); 2478 } 2479 else 2480#endif 2481 sprintf (base_string, libname_fmt[i].format, filename); 2482 2483 if (ldfile_try_open_bfd (full_string, entry)) 2484 break; 2485 } 2486 2487 if (!libname_fmt[i].format) 2488 { 2489 free (full_string); 2490 return false; 2491 } 2492 2493 entry->filename = full_string; 2494 2495 return true; 2496} 2497 2498static int 2499gld${EMULATION_NAME}_find_potential_libraries 2500 (char *name, lang_input_statement_type *entry) 2501{ 2502 return ldfile_open_file_search (name, entry, "", ".lib"); 2503} 2504 2505static char * 2506gld${EMULATION_NAME}_get_script (int *isfile) 2507EOF 2508 2509if test x"$COMPILE_IN" = xyes 2510then 2511# Scripts compiled in. 2512 2513# sed commands to quote an ld script as a C string. 2514sc="-f ${srcdir}/emultempl/stringify.sed" 2515 2516fragment <<EOF 2517{ 2518 *isfile = 0; 2519 2520 if (bfd_link_relocatable (&link_info) && config.build_constructors) 2521 return 2522EOF 2523sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c 2524echo ' ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c 2525sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c 2526echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c 2527sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c 2528echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c 2529sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c 2530if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then 2531echo ' ; else if (link_info.pei386_auto_import == 1 && (MERGE_RDATA_V2 || link_info.pei386_runtime_pseudo_reloc != 2)) return' >> e${EMULATION_NAME}.c 2532sed $sc ldscripts/${EMULATION_NAME}.xa >> e${EMULATION_NAME}.c 2533fi 2534echo ' ; else return' >> e${EMULATION_NAME}.c 2535sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c 2536echo '; }' >> e${EMULATION_NAME}.c 2537 2538else 2539# Scripts read from the filesystem. 2540 2541fragment <<EOF 2542{ 2543 *isfile = 1; 2544 2545 if (bfd_link_relocatable (&link_info) && config.build_constructors) 2546 return "ldscripts/${EMULATION_NAME}.xu"; 2547 else if (bfd_link_relocatable (&link_info)) 2548 return "ldscripts/${EMULATION_NAME}.xr"; 2549 else if (!config.text_read_only) 2550 return "ldscripts/${EMULATION_NAME}.xbn"; 2551 else if (!config.magic_demand_paged) 2552 return "ldscripts/${EMULATION_NAME}.xn"; 2553EOF 2554if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then 2555fragment <<EOF 2556 else if (link_info.pei386_auto_import == 1 2557 && (MERGE_RDATA_V2 || link_info.pei386_runtime_pseudo_reloc != 2)) 2558 return "ldscripts/${EMULATION_NAME}.xa"; 2559EOF 2560fi 2561fragment <<EOF 2562 else 2563 return "ldscripts/${EMULATION_NAME}.x"; 2564} 2565EOF 2566fi 2567 2568LDEMUL_AFTER_PARSE=gld${EMULATION_NAME}_after_parse 2569LDEMUL_BEFORE_PLUGIN_ALL_SYMBOLS_READ=gld${EMULATION_NAME}_before_plugin_all_symbols_read 2570LDEMUL_AFTER_OPEN=gld${EMULATION_NAME}_after_open 2571LDEMUL_BEFORE_ALLOCATION=gld${EMULATION_NAME}_before_allocation 2572LDEMUL_FINISH=gld${EMULATION_NAME}_finish 2573LDEMUL_OPEN_DYNAMIC_ARCHIVE=gld${EMULATION_NAME}_open_dynamic_archive 2574LDEMUL_PLACE_ORPHAN=gld${EMULATION_NAME}_place_orphan 2575LDEMUL_SET_SYMBOLS=gld${EMULATION_NAME}_set_symbols 2576LDEMUL_ADD_OPTIONS=gld${EMULATION_NAME}_add_options 2577LDEMUL_HANDLE_OPTION=gld${EMULATION_NAME}_handle_option 2578LDEMUL_UNRECOGNIZED_FILE=gld${EMULATION_NAME}_unrecognized_file 2579LDEMUL_LIST_OPTIONS=gld${EMULATION_NAME}_list_options 2580LDEMUL_RECOGNIZED_FILE=gld${EMULATION_NAME}_recognized_file 2581LDEMUL_FIND_POTENTIAL_LIBRARIES=gld${EMULATION_NAME}_find_potential_libraries 2582 2583source_em ${srcdir}/emultempl/emulation.em 2584