1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 if [ -z "$MACHINE" ]; then
6 OUTPUT_ARCH=${ARCH}:${MACHINE}
8 rm -f e${EMULATION_NAME}.c
9 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
11 /* Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
12 Written by Kai Tietz, OneVision Software GmbH&CoKg.
14 This file is part of the GNU Binutils.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
29 MA 02110-1301, USA. */
32 /* For WINDOWS_XP64 and higher */
33 /* Based on pe.em, but modified for 64 bit support. */
35 #define TARGET_IS_${EMULATION_NAME}
37 #define COFF_IMAGE_WITH_PE
39 #define COFF_WITH_pex64
45 #include "libiberty.h"
56 #include "coff/internal.h"
58 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
59 header in generic PE code. */
60 #include "coff/x86_64.h"
63 /* FIXME: This is a BFD internal header file, and we should not be
65 #include "../bfd/libcoff.h"
68 #define AOUTSZ PEPAOUTSZ
69 #define PEAOUTHDR PEPAOUTHDR
73 #include "safe-ctype.h"
75 /* Permit the emulation parameters to override the default section
76 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
77 it seem that include/coff/internal.h should not define
78 PE_DEF_SECTION_ALIGNMENT. */
79 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
80 #undef PE_DEF_SECTION_ALIGNMENT
81 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
84 #ifdef TARGET_IS_i386pep
88 #if defined(TARGET_IS_i386pep) || ! defined(DLL_SUPPORT)
89 #define PE_DEF_SUBSYSTEM 3
91 #undef NT_EXE_IMAGE_BASE
92 #define NT_EXE_IMAGE_BASE 0x00010000
93 #undef PE_DEF_SECTION_ALIGNMENT
94 #define PE_DEF_SUBSYSTEM 2
95 #undef PE_DEF_FILE_ALIGNMENT
96 #define PE_DEF_FILE_ALIGNMENT 0x00000200
97 #define PE_DEF_SECTION_ALIGNMENT 0x00000400
100 #define U(S) ${INITIAL_SYMBOL_CHAR} S
102 static struct internal_extra_pe_aouthdr pep;
104 static int pep_subsystem = ${SUBSYSTEM};
105 static flagword real_flags = IMAGE_FILE_LARGE_ADDRESS_AWARE;
106 static int support_old_code = 0;
107 static lang_assignment_statement_type *image_base_statement = 0;
108 static unsigned short pe_dll_characteristics = 0;
111 static int pep_enable_stdcall_fixup = 1; /* 0=disable 1=enable (default). */
112 static char * pep_out_def_filename = NULL;
113 static char * pep_implib_filename = NULL;
114 static int pep_enable_auto_image_base = 0;
115 static char * pep_dll_search_prefix = NULL;
118 extern const char *output_filename;
121 gld_${EMULATION_NAME}_before_parse (void)
123 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
124 output_filename = "${EXECUTABLE_NAME:-a.exe}";
126 config.dynamic_link = TRUE;
127 config.has_shared = 1;
128 link_info.pei386_auto_import = -1;
129 link_info.pei386_runtime_pseudo_reloc = 2; /* Use by default version 2. */
133 /* PE format extra command line options. */
135 /* Used for setting flags in the PE header. */
138 OPTION_BASE_FILE = 300 + 1,
140 OPTION_FILE_ALIGNMENT,
142 OPTION_MAJOR_IMAGE_VERSION,
143 OPTION_MAJOR_OS_VERSION,
144 OPTION_MAJOR_SUBSYSTEM_VERSION,
145 OPTION_MINOR_IMAGE_VERSION,
146 OPTION_MINOR_OS_VERSION,
147 OPTION_MINOR_SUBSYSTEM_VERSION,
148 OPTION_SECTION_ALIGNMENT,
152 OPTION_SUPPORT_OLD_CODE,
155 OPTION_EXCLUDE_SYMBOLS,
156 OPTION_EXCLUDE_ALL_SYMBOLS,
158 OPTION_STDCALL_ALIASES,
159 OPTION_ENABLE_STDCALL_FIXUP,
160 OPTION_DISABLE_STDCALL_FIXUP,
161 OPTION_IMPLIB_FILENAME,
162 OPTION_WARN_DUPLICATE_EXPORTS,
164 OPTION_ENABLE_AUTO_IMAGE_BASE,
165 OPTION_DISABLE_AUTO_IMAGE_BASE,
166 OPTION_DLL_SEARCH_PREFIX,
167 OPTION_NO_DEFAULT_EXCLUDES,
168 OPTION_DLL_ENABLE_AUTO_IMPORT,
169 OPTION_DLL_DISABLE_AUTO_IMPORT,
170 OPTION_ENABLE_EXTRA_PE_DEBUG,
172 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC,
173 OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC,
174 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1,
175 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2,
176 OPTION_EXCLUDE_MODULES_FOR_IMPLIB,
177 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES,
178 OPTION_ENABLE_LONG_SECTION_NAMES,
179 OPTION_DISABLE_LONG_SECTION_NAMES,
181 OPTION_FORCE_INTEGRITY,
187 OPTION_TERMINAL_SERVER_AWARE
191 gld${EMULATION_NAME}_add_options
192 (int ns ATTRIBUTE_UNUSED,
193 char **shortopts ATTRIBUTE_UNUSED,
195 struct option **longopts,
196 int nrl ATTRIBUTE_UNUSED,
197 struct option **really_longopts ATTRIBUTE_UNUSED)
199 static const struct option xtra_long[] =
202 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
203 {"dll", no_argument, NULL, OPTION_DLL},
204 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
205 {"heap", required_argument, NULL, OPTION_HEAP},
206 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
207 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
208 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
209 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
210 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
211 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
212 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
213 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
214 {"stack", required_argument, NULL, OPTION_STACK},
215 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
216 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
217 {"use-nul-prefixed-import-tables", no_argument, NULL,
218 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
220 /* getopt allows abbreviations, so we do this to stop it
221 from treating -o as an abbreviation for this option. */
222 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
223 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
224 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
225 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
226 {"exclude-all-symbols", no_argument, NULL, OPTION_EXCLUDE_ALL_SYMBOLS},
227 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
228 {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB},
229 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
230 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
231 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
232 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
233 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
234 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
235 /* getopt() allows abbreviations, so we do this to stop it from
236 treating -c as an abbreviation for these --compat-implib. */
237 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
238 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
239 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
240 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
241 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
242 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
243 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
244 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
245 {"enable-extra-pep-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
246 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
247 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
248 {"enable-runtime-pseudo-reloc-v1", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1},
249 {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2},
251 {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},
252 {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},
253 {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},
254 {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},
255 {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},
256 {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},
257 {"no-seh", no_argument, NULL, OPTION_NO_SEH},
258 {"no-bind", no_argument, NULL, OPTION_NO_BIND},
259 {"wdmdriver", no_argument, NULL, OPTION_WDM_DRIVER},
260 {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE},
261 {NULL, no_argument, NULL, 0}
265 = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
266 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
269 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
270 parameters which may be input from the command line. */
281 #define D(field,symbol,def) {&pep.field,sizeof(pep.field), def, symbol,0}
283 static definfo init[] =
285 /* imagebase must be first */
286 #define IMAGEBASEOFF 0
287 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
289 {&dll, sizeof(dll), 0, "__dll__", 0},
290 #define MSIMAGEBASEOFF 2
291 D(ImageBase, U("__ImageBase"), NT_EXE_IMAGE_BASE),
292 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
293 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
294 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
295 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
296 D(MajorImageVersion,"__major_image_version__", 0),
297 D(MinorImageVersion,"__minor_image_version__", 0),
298 D(MajorSubsystemVersion,"__major_subsystem_version__", 5),
299 D(MinorSubsystemVersion,"__minor_subsystem_version__", 2),
300 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
301 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
302 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
303 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
304 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
305 D(LoaderFlags,"__loader_flags__", 0x0),
306 D(DllCharacteristics, "__dll_characteristics__", 0x0),
307 { NULL, 0, 0, NULL, 0 }
312 gld_${EMULATION_NAME}_list_options (FILE *file)
314 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
315 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
316 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
317 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
318 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
319 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
320 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
321 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
322 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
323 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
324 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
325 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
326 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
327 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
328 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
330 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
331 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
332 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
333 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
334 fprintf (file, _(" --exclude-all-symbols Exclude all symbols from automatic export\n"));
335 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n"));
336 fprintf (file, _(" --exclude-modules-for-implib mod,mod,...\n"));
337 fprintf (file, _(" Exclude objects, archive members from auto\n"));
338 fprintf (file, _(" export, place into import library instead.\n"));
339 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
340 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
341 fprintf (file, _(" --out-implib <file> Generate import library\n"));
342 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
343 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
344 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\
345 create __imp_<SYMBOL> as well.\n"));
346 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\
347 unless user specifies one\n"));
348 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
349 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\
350 an importlib, use <string><basename>.dll\n\
351 in preference to lib<basename>.dll \n"));
352 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to\n\
353 __imp_sym for DATA references\n"));
354 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
355 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\
356 adding pseudo-relocations resolved at\n\
358 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\
359 auto-imported DATA.\n"));
360 fprintf (file, _(" --enable-extra-pep-debug Enable verbose debug output when building\n\
361 or linking to DLLs (esp. auto-import)\n"));
362 fprintf (file, _(" --enable-long-section-names Use long COFF section names even in\n\
363 executable image files\n"));
364 fprintf (file, _(" --disable-long-section-names Never use long COFF section names, even\n\
365 in object files\n"));
366 fprintf (file, _(" --dynamicbase Image base address may be relocated using\n\
367 address space layout randomization (ASLR)\n"));
368 fprintf (file, _(" --forceinteg Code integrity checks are enforced\n"));
369 fprintf (file, _(" --nxcompat Image is compatible with data execution prevention\n"));
370 fprintf (file, _(" --no-isolation Image understands isolation but do not isolate the image\n"));
371 fprintf (file, _(" --no-seh Image does not use SEH. No SE handler may\n\
372 be called in this image\n"));
373 fprintf (file, _(" --no-bind Do not bind this image\n"));
374 fprintf (file, _(" --wdmdriver Driver uses the WDM model\n"));
375 fprintf (file, _(" --tsaware Image is Terminal Server aware\n"));
381 set_pep_name (char *name, bfd_vma val)
385 /* Find the name and set it. */
386 for (i = 0; init[i].ptr; i++)
388 if (strcmp (name, init[i].symbol) == 0)
392 if (strcmp (name,"__image_base__") == 0)
393 set_pep_name ("___ImageBase", val);
401 set_entry_point (void)
404 const char *initial_symbol_char;
414 { 1, "NtProcessStartup" },
415 { 2, "WinMainCRTStartup" },
416 { 3, "mainCRTStartup" },
417 { 7, "__PosixProcessStartup" },
418 { 9, "WinMainCRTStartup" },
419 {14, "mainCRTStartup" },
423 /* Entry point name for arbitrary subsystem numbers. */
424 static const char default_entry[] = "mainCRTStartup";
426 if (link_info.shared || dll)
428 entry = "DllMainCRTStartup";
432 for (i = 0; v[i].entry; i++)
433 if (v[i].value == pep_subsystem)
436 /* If no match, use the default. */
437 if (v[i].entry != NULL)
440 entry = default_entry;
443 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
444 if (*initial_symbol_char != '\0')
448 /* lang_default_entry expects its argument to be permanently
449 allocated, so we don't free this string. */
450 alc_entry = xmalloc (strlen (initial_symbol_char)
453 strcpy (alc_entry, initial_symbol_char);
454 strcat (alc_entry, entry);
458 lang_default_entry (entry);
462 set_pep_subsystem (void)
468 unsigned long temp_subsystem;
485 /* Check for the presence of a version number. */
486 sver = strchr (optarg, ':');
488 len = strlen (optarg);
492 set_pep_name ("__major_subsystem_version__",
493 strtoul (sver + 1, &end, 0));
495 set_pep_name ("__minor_subsystem_version__",
496 strtoul (end + 1, &end, 0));
498 einfo (_("%P: warning: bad version number in -subsystem option\n"));
501 /* Check for numeric subsystem. */
502 temp_subsystem = strtoul (optarg, & end, 0);
503 if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
505 /* Search list for a numeric match to use its entry point. */
506 for (i = 0; v[i].name; i++)
507 if (v[i].value == (int) temp_subsystem)
510 /* Use this subsystem. */
511 pep_subsystem = (int) temp_subsystem;
515 /* Search for subsystem by name. */
516 for (i = 0; v[i].name; i++)
517 if (strncmp (optarg, v[i].name, len) == 0
518 && v[i].name[len] == '\0')
521 if (v[i].name == NULL)
523 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
527 pep_subsystem = v[i].value;
530 set_pep_name ("__subsystem__", pep_subsystem);
537 set_pep_value (char *name)
541 set_pep_name (name, (bfd_vma) strtoull (optarg, &end, 0));
544 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
551 set_pep_stack_heap (char *resname, char *comname)
553 set_pep_value (resname);
558 set_pep_value (comname);
561 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
566 gld${EMULATION_NAME}_handle_option (int optc)
573 case OPTION_BASE_FILE:
574 link_info.base_file = fopen (optarg, FOPEN_WB);
575 if (link_info.base_file == NULL)
577 /* xgettext:c-format */
578 fprintf (stderr, _("%s: Can't open base file %s\n"),
579 program_name, optarg);
586 set_pep_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
589 set_pep_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
591 case OPTION_SUBSYSTEM:
592 set_pep_subsystem ();
594 case OPTION_MAJOR_OS_VERSION:
595 set_pep_value ("__major_os_version__");
597 case OPTION_MINOR_OS_VERSION:
598 set_pep_value ("__minor_os_version__");
600 case OPTION_MAJOR_SUBSYSTEM_VERSION:
601 set_pep_value ("__major_subsystem_version__");
603 case OPTION_MINOR_SUBSYSTEM_VERSION:
604 set_pep_value ("__minor_subsystem_version__");
606 case OPTION_MAJOR_IMAGE_VERSION:
607 set_pep_value ("__major_image_version__");
609 case OPTION_MINOR_IMAGE_VERSION:
610 set_pep_value ("__minor_image_version__");
612 case OPTION_FILE_ALIGNMENT:
613 set_pep_value ("__file_alignment__");
615 case OPTION_SECTION_ALIGNMENT:
616 set_pep_value ("__section_alignment__");
619 set_pep_name ("__dll__", 1);
621 case OPTION_IMAGE_BASE:
622 set_pep_value ("__image_base__");
624 case OPTION_SUPPORT_OLD_CODE:
625 support_old_code = 1;
627 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
628 pep_use_nul_prefixed_import_tables = TRUE;
632 pep_out_def_filename = xstrdup (optarg);
634 case OPTION_EXPORT_ALL:
635 pep_dll_export_everything = 1;
637 case OPTION_EXCLUDE_SYMBOLS:
638 pep_dll_add_excludes (optarg, EXCLUDESYMS);
640 case OPTION_EXCLUDE_ALL_SYMBOLS:
641 pep_dll_exclude_all_symbols = 1;
643 case OPTION_EXCLUDE_LIBS:
644 pep_dll_add_excludes (optarg, EXCLUDELIBS);
646 case OPTION_EXCLUDE_MODULES_FOR_IMPLIB:
647 pep_dll_add_excludes (optarg, EXCLUDEFORIMPLIB);
649 case OPTION_KILL_ATS:
650 pep_dll_kill_ats = 1;
652 case OPTION_STDCALL_ALIASES:
653 pep_dll_stdcall_aliases = 1;
655 case OPTION_ENABLE_STDCALL_FIXUP:
656 pep_enable_stdcall_fixup = 1;
658 case OPTION_DISABLE_STDCALL_FIXUP:
659 pep_enable_stdcall_fixup = 0;
661 case OPTION_IMPLIB_FILENAME:
662 pep_implib_filename = xstrdup (optarg);
664 case OPTION_WARN_DUPLICATE_EXPORTS:
665 pep_dll_warn_dup_exports = 1;
667 case OPTION_IMP_COMPAT:
668 pep_dll_compat_implib = 1;
670 case OPTION_ENABLE_AUTO_IMAGE_BASE:
671 pep_enable_auto_image_base = 1;
673 case OPTION_DISABLE_AUTO_IMAGE_BASE:
674 pep_enable_auto_image_base = 0;
676 case OPTION_DLL_SEARCH_PREFIX:
677 pep_dll_search_prefix = xstrdup (optarg);
679 case OPTION_NO_DEFAULT_EXCLUDES:
680 pep_dll_do_default_excludes = 0;
682 case OPTION_DLL_ENABLE_AUTO_IMPORT:
683 link_info.pei386_auto_import = 1;
685 case OPTION_DLL_DISABLE_AUTO_IMPORT:
686 link_info.pei386_auto_import = 0;
688 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
689 link_info.pei386_runtime_pseudo_reloc = 2;
691 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
692 link_info.pei386_runtime_pseudo_reloc = 0;
694 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1:
695 link_info.pei386_runtime_pseudo_reloc = 1;
697 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2:
698 link_info.pei386_runtime_pseudo_reloc = 2;
700 case OPTION_ENABLE_EXTRA_PE_DEBUG:
701 pep_dll_extra_pe_debug = 1;
704 case OPTION_ENABLE_LONG_SECTION_NAMES:
705 pep_use_coff_long_section_names = 1;
707 case OPTION_DISABLE_LONG_SECTION_NAMES:
708 pep_use_coff_long_section_names = 0;
710 /* Get DLLCharacteristics bits */
711 case OPTION_DYNAMIC_BASE:
712 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
714 case OPTION_FORCE_INTEGRITY:
715 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
717 case OPTION_NX_COMPAT:
718 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
720 case OPTION_NO_ISOLATION:
721 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
724 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_SEH;
727 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_BIND;
729 case OPTION_WDM_DRIVER:
730 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_WDM_DRIVER;
732 case OPTION_TERMINAL_SERVER_AWARE:
733 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE;
737 /* Set DLLCharacteristics bits */
738 set_pep_name ("__dll_characteristics__", pe_dll_characteristics);
746 strhash (const char *str)
748 const unsigned char *s;
755 s = (const unsigned char *) str;
756 while ((c = *s++) != '\0')
758 hash += c + (c << 17);
762 hash += len + (len << 17);
768 /* Use the output file to create a image base for relocatable DLLs. */
771 compute_dll_image_base (const char *ofile)
773 bfd_vma hash = (bfd_vma) strhash (ofile);
774 return 0x61300000 + ((hash << 16) & 0x0FFC0000);
778 /* Assign values to the special symbols before the linker script is
782 gld_${EMULATION_NAME}_set_symbols (void)
784 /* Run through and invent symbols for all the
785 names and insert the defaults. */
788 if (!init[IMAGEBASEOFF].inited)
790 if (link_info.relocatable)
791 init[IMAGEBASEOFF].value = 0;
792 else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
795 init[IMAGEBASEOFF].value = (pep_enable_auto_image_base
796 ? compute_dll_image_base (output_filename)
797 : NT_DLL_IMAGE_BASE);
799 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
803 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
804 init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;
807 /* Don't do any symbol assignments if this is a relocatable link. */
808 if (link_info.relocatable)
811 /* Glue the assignments into the abs section. */
812 push_stat_ptr (&abs_output_section->children);
814 for (j = 0; init[j].ptr; j++)
816 bfd_vma val = init[j].value;
817 lang_assignment_statement_type *rv;
818 rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
820 if (init[j].size == sizeof (short))
821 *(short *) init[j].ptr = (short) val;
822 else if (init[j].size == sizeof (int))
823 *(int *) init[j].ptr = (int) val;
824 else if (init[j].size == sizeof (long))
825 *(long *) init[j].ptr = (long) val;
826 /* This might be a long long or other special type. */
827 else if (init[j].size == sizeof (bfd_vma))
828 *(bfd_vma *) init[j].ptr = val;
830 if (j == IMAGEBASEOFF)
831 image_base_statement = rv;
833 /* Restore the pointer. */
836 if (pep.FileAlignment > pep.SectionAlignment)
838 einfo (_("%P: warning, file alignment > section alignment.\n"));
842 /* This is called after the linker script and the command line options
846 gld_${EMULATION_NAME}_after_parse (void)
848 /* PR ld/6744: Warn the user if they have used an ELF-only
849 option hoping it will work on PE+. */
850 if (link_info.export_dynamic)
851 einfo (_("%P: warning: --export-dynamic is not supported for PE+ "
852 "targets, did you mean --export-all-symbols?\n"));
856 after_parse_default ();
859 /* pep-dll.c directly accesses pep_data_import_dll,
860 so it must be defined outside of #ifdef DLL_SUPPORT.
861 Note - this variable is deliberately not initialised.
862 This allows it to be treated as a common varaible, and only
863 exist in one incarnation in a multiple target enabled linker. */
864 char * pep_data_import_dll;
867 static struct bfd_link_hash_entry *pep_undef_found_sym;
870 pep_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
874 const char *hs = h->root.string;
876 sl = strlen (string);
877 if (h->type == bfd_link_hash_defined
878 && ((*hs == '@' && *string == '_'
879 && strncmp (hs + 1, string + 1, sl - 1) == 0)
880 || strncmp (hs, string, sl) == 0)
881 && h->root.string[sl] == '@')
883 pep_undef_found_sym = h;
890 pep_fixup_stdcalls (void)
892 static int gave_warning_message = 0;
893 struct bfd_link_hash_entry *undef, *sym;
895 if (pep_dll_extra_pe_debug)
896 printf ("%s\n", __FUNCTION__);
898 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
899 if (undef->type == bfd_link_hash_undefined)
901 char* at = strchr (undef->root.string, '@');
902 int lead_at = (*undef->root.string == '@');
904 at = strchr (undef->root.string + 1, '@');
907 /* The symbol is a stdcall symbol, so let's look for a
908 cdecl symbol with the same name and resolve to that. */
909 char *cname = xstrdup (undef->root.string);
913 at = strchr (cname, '@');
916 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
918 if (sym && sym->type == bfd_link_hash_defined)
920 undef->type = bfd_link_hash_defined;
921 undef->u.def.value = sym->u.def.value;
922 undef->u.def.section = sym->u.def.section;
924 if (pep_enable_stdcall_fixup == -1)
926 einfo (_("Warning: resolving %s by linking to %s\n"),
927 undef->root.string, cname);
928 if (! gave_warning_message)
930 gave_warning_message = 1;
931 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
932 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
939 /* The symbol is a cdecl symbol, so we look for stdcall
940 symbols - which means scanning the whole symbol table. */
941 pep_undef_found_sym = 0;
942 bfd_link_hash_traverse (link_info.hash, pep_undef_cdecl_match,
943 (char *) undef->root.string);
944 sym = pep_undef_found_sym;
947 undef->type = bfd_link_hash_defined;
948 undef->u.def.value = sym->u.def.value;
949 undef->u.def.section = sym->u.def.section;
951 if (pep_enable_stdcall_fixup == -1)
953 einfo (_("Warning: resolving %s by linking to %s\n"),
954 undef->root.string, sym->root.string);
955 if (! gave_warning_message)
957 gave_warning_message = 1;
958 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
959 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
968 make_import_fixup (arelent *rel, asection *s)
970 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
975 if (pep_dll_extra_pe_debug)
976 printf ("arelent: %s@%#lx: add=%li\n", sym->name,
977 (unsigned long) rel->address, (long) rel->addend);
979 memset (addend, 0, sizeof (addend));
980 switch ((rel->howto->bitsize))
983 suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 1);
984 if (suc && rel->howto->pc_relative)
985 _addend = (bfd_vma) ((bfd_signed_vma) ((char) bfd_get_8 (s->owner, addend)));
987 _addend = ((bfd_vma) bfd_get_8 (s->owner, addend)) & 0xff;
990 suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 2);
991 if (suc && rel->howto->pc_relative)
992 _addend = (bfd_vma) ((bfd_signed_vma) ((short) bfd_get_16 (s->owner, addend)));
994 _addend = ((bfd_vma) bfd_get_16 (s->owner, addend)) & 0xffff;
997 suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 4);
998 if (suc && rel->howto->pc_relative)
999 _addend = (bfd_vma) ((bfd_signed_vma) ((int) bfd_get_32 (s->owner, addend)));
1001 _addend = ((bfd_vma) bfd_get_32 (s->owner, addend)) & 0xffffffff;
1004 suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 8);
1006 _addend = ((bfd_vma) bfd_get_64 (s->owner, addend));
1010 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
1011 s->owner, s, rel->address);
1013 if (pep_dll_extra_pe_debug)
1015 printf ("import of 0x%lx(0x%lx) sec_addr=0x%lx", (long) _addend, (long) rel->addend, (long) rel->address);
1016 if (rel->howto->pc_relative) printf (" pcrel");
1017 printf (" %d bit rel.\n",(int) rel->howto->bitsize);
1019 pep_create_import_fixup (rel, s, _addend);
1025 pep_find_data_imports (void)
1027 struct bfd_link_hash_entry *undef, *sym;
1029 if (link_info.pei386_auto_import == 0)
1032 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
1034 if (undef->type == bfd_link_hash_undefined)
1036 /* C++ symbols are *long*. */
1039 if (pep_dll_extra_pe_debug)
1040 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
1042 sprintf (buf, "__imp_%s", undef->root.string);
1044 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
1046 if (sym && sym->type == bfd_link_hash_defined)
1048 bfd *b = sym->u.def.section->owner;
1052 if (link_info.pei386_auto_import == -1)
1054 static bfd_boolean warned = FALSE;
1056 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
1057 undef->root.string, buf);
1059 /* PR linker/4844. */
1063 einfo (_("%P: warning: auto-importing has been activated without --enable-auto-import specified on the command line.\n\
1064 This should work unless it involves constant data structures referencing symbols from auto-imported DLLs.\n"));
1068 if (!bfd_generic_link_read_symbols (b))
1070 einfo (_("%B%F: could not read symbols: %E\n"), b);
1074 symbols = bfd_get_outsymbols (b);
1075 nsyms = bfd_get_symcount (b);
1077 for (i = 0; i < nsyms; i++)
1079 if (! CONST_STRNEQ (symbols[i]->name, "__head_"))
1082 if (pep_dll_extra_pe_debug)
1083 printf ("->%s\n", symbols[i]->name);
1085 pep_data_import_dll = (char*) (symbols[i]->name +
1086 sizeof ("__head_") - 1);
1090 pep_walk_relocs_of_symbol (&link_info, undef->root.string,
1093 /* Let's differentiate it somehow from defined. */
1094 undef->type = bfd_link_hash_defweak;
1095 /* We replace original name with __imp_ prefixed, this
1096 1) may trash memory 2) leads to duplicate symbol generation.
1097 Still, IMHO it's better than having name poluted. */
1098 undef->root.string = sym->root.string;
1099 undef->u.def.value = sym->u.def.value;
1100 undef->u.def.section = sym->u.def.section;
1107 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
1109 if (pep_dll_extra_pe_debug)
1110 printf ("+%s\n", h->string);
1114 #endif /* DLL_SUPPORT */
1117 debug_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
1119 int *found = (int *) obj;
1120 if (strncmp (".debug_", sect->name, sizeof (".debug_") - 1) == 0)
1125 gld_${EMULATION_NAME}_after_open (void)
1128 if (pep_dll_extra_pe_debug)
1131 struct bfd_link_hash_entry *sym;
1133 printf ("%s()\n", __FUNCTION__);
1135 for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
1136 printf ("-%s\n", sym->root.string);
1137 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
1139 for (a = link_info.input_bfds; a; a = a->link_next)
1140 printf ("*%s\n",a->filename);
1144 /* Pass the wacky PE command line options into the output bfd.
1145 FIXME: This should be done via a function, rather than by
1146 including an internal BFD header. */
1148 if (coff_data (link_info.output_bfd) == NULL
1149 || coff_data (link_info.output_bfd)->pe == 0)
1150 einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"),
1151 link_info.output_bfd);
1153 pe_data (link_info.output_bfd)->pe_opthdr = pep;
1154 pe_data (link_info.output_bfd)->dll = init[DLLOFF].value;
1155 pe_data (link_info.output_bfd)->real_flags |= real_flags;
1157 /* At this point we must decide whether to use long section names
1158 in the output or not. If the user hasn't explicitly specified
1159 on the command line, we leave it to the default for the format
1160 (object files yes, image files no), except if there is debug
1161 information present; GDB relies on the long section names to
1162 find it, so enable it in that case. */
1163 if (pep_use_coff_long_section_names < 0 && link_info.strip == strip_none)
1165 /* Iterate over all sections of all input BFDs, checking
1166 for any that begin 'debug_' and are long names. */
1167 LANG_FOR_EACH_INPUT_STATEMENT (is)
1169 int found_debug = 0;
1170 bfd_map_over_sections (is->the_bfd, debug_section_p, &found_debug);
1173 pep_use_coff_long_section_names = 1;
1179 pep_output_file_set_long_section_names (link_info.output_bfd);
1182 if (pep_enable_stdcall_fixup) /* -1=warn or 1=disable */
1183 pep_fixup_stdcalls ();
1185 pep_process_import_defs (link_info.output_bfd, &link_info);
1187 pep_find_data_imports ();
1189 /* As possibly new symbols are added by imports, we rerun
1190 stdcall/fastcall fixup here. */
1191 if (pep_enable_stdcall_fixup) /* -1=warn or 1=disable */
1192 pep_fixup_stdcalls ();
1194 #ifndef TARGET_IS_i386pep
1195 if (link_info.shared)
1197 if (!link_info.relocatable)
1199 pep_dll_build_sections (link_info.output_bfd, &link_info);
1201 #ifndef TARGET_IS_i386pep
1203 pep_exe_build_sections (link_info.output_bfd, &link_info);
1205 #endif /* DLL_SUPPORT */
1208 /* This next chunk of code tries to detect the case where you have
1209 two import libraries for the same DLL (specifically,
1210 symbolically linking libm.a and libc.a in cygwin to
1211 libcygwin.a). In those cases, it's possible for function
1212 thunks from the second implib to be used but without the
1213 head/tail objects, causing an improper import table. We detect
1214 those cases and rename the "other" import libraries to match
1215 the one the head/tail come from, so that the linker will sort
1216 things nicely and produce a valid import table. */
1218 LANG_FOR_EACH_INPUT_STATEMENT (is)
1220 if (is->the_bfd->my_archive)
1222 int idata2 = 0, reloc_count=0, is_imp = 0;
1225 /* See if this is an import library thunk. */
1226 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1228 if (strcmp (sec->name, ".idata\$2") == 0)
1230 if (CONST_STRNEQ (sec->name, ".idata\$"))
1232 reloc_count += sec->reloc_count;
1235 if (is_imp && !idata2 && reloc_count)
1237 /* It is, look for the reference to head and see if it's
1238 from our own library. */
1239 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1247 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1251 if (!bfd_generic_link_read_symbols (is->the_bfd))
1253 einfo (_("%B%F: could not read symbols: %E\n"),
1257 symbols = bfd_get_outsymbols (is->the_bfd);
1259 relocs = xmalloc ((size_t) relsize);
1260 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1265 einfo ("%X%P: unable to process relocs: %E\n");
1269 for (i = 0; i < nrelocs; i++)
1271 struct bfd_symbol *s;
1272 struct bfd_link_hash_entry * blhe;
1273 char *other_bfd_filename;
1276 s = (relocs[i]->sym_ptr_ptr)[0];
1278 if (s->flags & BSF_LOCAL)
1281 /* Thunk section with reloc to another bfd. */
1282 blhe = bfd_link_hash_lookup (link_info.hash,
1284 FALSE, FALSE, TRUE);
1287 || blhe->type != bfd_link_hash_defined)
1291 = blhe->u.def.section->owner->my_archive
1292 ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1293 : bfd_get_filename (blhe->u.def.section->owner);
1295 if (strcmp (bfd_get_filename (is->the_bfd->my_archive),
1296 other_bfd_filename) == 0)
1299 /* Rename this implib to match the other one. */
1300 n = xmalloc (strlen (other_bfd_filename) + 1);
1301 strcpy (n, other_bfd_filename);
1302 is->the_bfd->my_archive->filename = n;
1306 /* Note - we do not free the symbols,
1307 they are now cached in the BFD. */
1317 lang_input_statement_type *is2;
1318 lang_input_statement_type *is3;
1320 /* Careful - this is a shell script. Watch those dollar signs! */
1321 /* Microsoft import libraries have every member named the same,
1322 and not in the right order for us to link them correctly. We
1323 must detect these and rename the members so that they'll link
1324 correctly. There are three types of objects: the head, the
1325 thunks, and the sentinel(s). The head is easy; it's the one
1326 with idata2. We assume that the sentinels won't have relocs,
1327 and the thunks will. It's easier than checking the symbol
1328 table for external references. */
1329 LANG_FOR_EACH_INPUT_STATEMENT (is)
1331 if (is->the_bfd->my_archive)
1334 bfd *arch = is->the_bfd->my_archive;
1336 if (cur_arch != arch)
1342 is3 && is3->the_bfd->my_archive == arch;
1343 is3 = (lang_input_statement_type *) is3->next)
1345 /* A MS dynamic import library can also contain static
1346 members, so look for the first element with a .dll
1347 extension, and use that for the remainder of the
1349 pnt = strrchr (is3->the_bfd->filename, '.');
1350 if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1358 /* OK, found one. Now look to see if the remaining
1359 (dynamic import) members use the same name. */
1361 is2 && is2->the_bfd->my_archive == arch;
1362 is2 = (lang_input_statement_type *) is2->next)
1364 /* Skip static members, ie anything with a .obj
1366 pnt = strrchr (is2->the_bfd->filename, '.');
1367 if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1370 if (strcmp (is3->the_bfd->filename,
1371 is2->the_bfd->filename))
1380 /* This fragment might have come from an .obj file in a Microsoft
1381 import, and not an actual import record. If this is the case,
1382 then leave the filename alone. */
1383 pnt = strrchr (is->the_bfd->filename, '.');
1385 if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1387 int idata2 = 0, reloc_count=0;
1389 char *new_name, seq;
1391 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1393 if (strcmp (sec->name, ".idata\$2") == 0)
1395 reloc_count += sec->reloc_count;
1398 if (idata2) /* .idata2 is the TOC */
1400 else if (reloc_count > 0) /* thunks */
1405 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1406 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1407 is->the_bfd->filename = new_name;
1409 new_name = xmalloc (strlen (is->filename) + 3);
1410 sprintf (new_name, "%s.%c", is->filename, seq);
1411 is->filename = new_name;
1419 gld_${EMULATION_NAME}_before_allocation (void)
1421 before_allocation_default ();
1425 /* This is called when an input file isn't recognized as a BFD. We
1426 check here for .DEF files and pull them in automatically. */
1429 saw_option (char *option)
1433 for (i = 0; init[i].ptr; i++)
1434 if (strcmp (init[i].symbol, option) == 0)
1435 return init[i].inited;
1438 #endif /* DLL_SUPPORT */
1441 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1444 const char *ext = entry->filename + strlen (entry->filename) - 4;
1446 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1448 pep_def_file = def_file_parse (entry->filename, pep_def_file);
1452 int i, buflen=0, len;
1455 for (i = 0; i < pep_def_file->num_exports; i++)
1457 len = strlen (pep_def_file->exports[i].internal_name);
1458 if (buflen < len + 2)
1462 buf = xmalloc (buflen);
1464 for (i = 0; i < pep_def_file->num_exports; i++)
1466 struct bfd_link_hash_entry *h;
1468 sprintf (buf, "_%s", pep_def_file->exports[i].internal_name);
1470 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1471 if (h == (struct bfd_link_hash_entry *) NULL)
1472 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1473 if (h->type == bfd_link_hash_new)
1475 h->type = bfd_link_hash_undefined;
1476 h->u.undef.abfd = NULL;
1477 bfd_link_add_undef (link_info.hash, h);
1482 /* def_file_print (stdout, pep_def_file); */
1483 if (pep_def_file->is_dll == 1)
1484 link_info.shared = 1;
1486 if (pep_def_file->base_address != (bfd_vma)(-1))
1489 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase
1490 = init[IMAGEBASEOFF].value
1491 = pep_def_file->base_address;
1492 init[IMAGEBASEOFF].inited = 1;
1493 if (image_base_statement)
1494 image_base_statement->exp = exp_assop ('=', "__image_base__",
1495 exp_intop (pep.ImageBase));
1498 if (pep_def_file->stack_reserve != -1
1499 && ! saw_option ("__size_of_stack_reserve__"))
1501 pep.SizeOfStackReserve = pep_def_file->stack_reserve;
1502 if (pep_def_file->stack_commit != -1)
1503 pep.SizeOfStackCommit = pep_def_file->stack_commit;
1505 if (pep_def_file->heap_reserve != -1
1506 && ! saw_option ("__size_of_heap_reserve__"))
1508 pep.SizeOfHeapReserve = pep_def_file->heap_reserve;
1509 if (pep_def_file->heap_commit != -1)
1510 pep.SizeOfHeapCommit = pep_def_file->heap_commit;
1520 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1523 #ifdef TARGET_IS_i386pep
1524 pep_dll_id_target ("pei-x86-64");
1526 if (pep_bfd_is_dll (entry->the_bfd))
1527 return pep_implied_import_dll (entry->filename);
1533 gld_${EMULATION_NAME}_finish (void)
1538 if (link_info.shared
1539 || (!link_info.relocatable && pep_def_file->num_exports != 0))
1541 pep_dll_fill_sections (link_info.output_bfd, &link_info);
1542 if (pep_implib_filename)
1543 pep_dll_generate_implib (pep_def_file, pep_implib_filename, &link_info);
1546 if (pep_out_def_filename)
1547 pep_dll_generate_def_file (pep_out_def_filename);
1548 #endif /* DLL_SUPPORT */
1550 /* I don't know where .idata gets set as code, but it shouldn't be. */
1552 asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata");
1556 asec->flags &= ~SEC_CODE;
1557 asec->flags |= SEC_DATA;
1563 /* Place an orphan section.
1565 We use this to put sections in a reasonable place in the file, and
1566 to ensure that they are aligned as required.
1568 We handle grouped sections here as well. A section named .foo\$nn
1569 goes into the output section .foo. All grouped sections are sorted
1572 Grouped sections for the default sections are handled by the
1573 default linker script using wildcards, and are sorted by
1576 static lang_output_section_statement_type *
1577 gld_${EMULATION_NAME}_place_orphan (asection *s,
1578 const char *secname,
1581 const char *orig_secname = secname;
1582 char *dollar = NULL;
1583 lang_output_section_statement_type *os;
1584 lang_statement_list_type add_child;
1585 lang_output_section_statement_type *match_by_name = NULL;
1586 lang_statement_union_type **pl;
1588 /* Look through the script to see where to place this section. */
1589 if (!link_info.relocatable
1590 && (dollar = strchr (secname, '\$')) != NULL)
1592 size_t len = dollar - secname;
1593 char *newname = xmalloc (len + 1);
1594 memcpy (newname, secname, len);
1595 newname[len] = '\0';
1599 lang_list_init (&add_child);
1602 if (constraint == 0)
1603 for (os = lang_output_section_find (secname);
1605 os = next_matching_output_section_statement (os, 0))
1607 /* If we don't match an existing output section, tell
1608 lang_insert_orphan to create a new output section. */
1609 constraint = SPECIAL;
1611 if (os->bfd_section != NULL
1612 && (os->bfd_section->flags == 0
1613 || ((s->flags ^ os->bfd_section->flags)
1614 & (SEC_LOAD | SEC_ALLOC)) == 0))
1616 /* We already have an output section statement with this
1617 name, and its bfd section has compatible flags.
1618 If the section already exists but does not have any flags set,
1619 then it has been created by the linker, probably as a result of
1620 a --section-start command line switch. */
1621 lang_add_section (&add_child, s, os);
1625 /* Save unused output sections in case we can match them
1626 against orphans later. */
1627 if (os->bfd_section == NULL)
1631 /* If we didn't match an active output section, see if we matched an
1632 unused one and use that. */
1633 if (os == NULL && match_by_name)
1635 lang_add_section (&match_by_name->children, s, match_by_name);
1636 return match_by_name;
1641 static struct orphan_save hold[] =
1644 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1647 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1650 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1656 enum orphan_save_index
1663 static int orphan_init_done = 0;
1664 struct orphan_save *place;
1665 lang_output_section_statement_type *after;
1666 etree_type *address;
1668 if (!orphan_init_done)
1670 struct orphan_save *ho;
1671 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1672 if (ho->name != NULL)
1674 ho->os = lang_output_section_find (ho->name);
1675 if (ho->os != NULL && ho->os->flags == 0)
1676 ho->os->flags = ho->flags;
1678 orphan_init_done = 1;
1681 /* Try to put the new output section in a reasonable place based
1682 on the section name and section flags. */
1685 if ((s->flags & SEC_ALLOC) == 0)
1687 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1688 place = &hold[orphan_bss];
1689 else if ((s->flags & SEC_READONLY) == 0)
1690 place = &hold[orphan_data];
1691 else if ((s->flags & SEC_CODE) == 0)
1692 place = &hold[orphan_rodata];
1694 place = &hold[orphan_text];
1699 if (place->os == NULL)
1700 place->os = lang_output_section_find (place->name);
1703 after = lang_output_section_find_by_flags (s, &place->os, NULL);
1705 /* *ABS* is always the first output section statement. */
1706 after = (&lang_output_section_statement.head
1707 ->output_section_statement);
1710 /* All sections in an executable must be aligned to a page boundary. */
1711 address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
1712 os = lang_insert_orphan (s, secname, constraint, after, place, address,
1716 /* If the section name has a '\$', sort it with the other '\$'
1718 for (pl = &os->children.head; *pl != NULL; pl = &(*pl)->header.next)
1720 lang_input_section_type *ls;
1723 if ((*pl)->header.type != lang_input_section_enum)
1726 ls = &(*pl)->input_section;
1728 lname = bfd_get_section_name (ls->section->owner, ls->section);
1729 if (strchr (lname, '\$') != NULL
1730 && (dollar == NULL || strcmp (orig_secname, lname) < 0))
1734 if (add_child.head != NULL)
1736 *add_child.tail = *pl;
1737 *pl = add_child.head;
1744 gld_${EMULATION_NAME}_open_dynamic_archive
1745 (const char *arch ATTRIBUTE_UNUSED,
1746 search_dirs_type *search,
1747 lang_input_statement_type *entry)
1751 const char * format;
1752 bfd_boolean use_prefix;
1756 /* Preferred explicit import library for dll's. */
1757 { "lib%s.dll.a", FALSE },
1758 /* Alternate explicit import library for dll's. */
1759 { "%s.dll.a", FALSE },
1760 /* "libfoo.a" could be either an import lib or a static lib.
1761 For backwards compatibility, libfoo.a needs to precede
1762 libfoo.dll and foo.dll in the search. */
1763 { "lib%s.a", FALSE },
1764 /* The 'native' spelling of an import lib name is "foo.lib". */
1765 { "%s.lib", FALSE },
1767 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */
1768 { "%s%s.dll", TRUE },
1770 /* Try "libfoo.dll" (default preferred dll name). */
1771 { "lib%s.dll", FALSE },
1772 /* Finally try 'native' dll name "foo.dll". */
1773 { "%s.dll", FALSE },
1774 /* Note: If adding more formats to this table, make sure to check to
1775 see if their length is longer than libname_fmt[0].format, and if
1776 so, update the call to xmalloc() below. */
1779 static unsigned int format_max_len = 0;
1780 const char * filename;
1786 if (! entry->is_archive)
1789 filename = entry->filename;
1791 if (format_max_len == 0)
1792 /* We need to allow space in the memory that we are going to allocate
1793 for the characters in the format string. Since the format array is
1794 static we only need to calculate this information once. In theory
1795 this value could also be computed statically, but this introduces
1796 the possibility for a discrepancy and hence a possible memory
1797 corruption. The lengths we compute here will be too long because
1798 they will include any formating characters (%s) in the strings, but
1799 this will not matter. */
1800 for (i = 0; libname_fmt[i].format; i++)
1801 if (format_max_len < strlen (libname_fmt[i].format))
1802 format_max_len = strlen (libname_fmt[i].format);
1804 full_string = xmalloc (strlen (search->name)
1808 + (pep_dll_search_prefix
1809 ? strlen (pep_dll_search_prefix) : 0)
1811 /* Allow for the terminating NUL and for the path
1812 separator character that is inserted between
1813 search->name and the start of the format string. */
1816 sprintf (full_string, "%s/", search->name);
1817 base_string = full_string + strlen (full_string);
1819 for (i = 0; libname_fmt[i].format; i++)
1822 if (libname_fmt[i].use_prefix)
1824 if (!pep_dll_search_prefix)
1826 sprintf (base_string, libname_fmt[i].format, pep_dll_search_prefix, filename);
1830 sprintf (base_string, libname_fmt[i].format, filename);
1832 if (ldfile_try_open_bfd (full_string, entry))
1836 if (!libname_fmt[i].format)
1842 entry->filename = full_string;
1848 gld_${EMULATION_NAME}_find_potential_libraries
1849 (char *name, lang_input_statement_type *entry)
1851 return ldfile_open_file_search (name, entry, "", ".lib");
1855 gld_${EMULATION_NAME}_get_script (int *isfile)
1857 # Scripts compiled in.
1858 # sed commands to quote an ld script as a C string.
1859 sc="-f stringify.sed"
1865 if (link_info.relocatable && config.build_constructors)
1868 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1869 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1870 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1871 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1872 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1873 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1874 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1875 if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then
1876 echo ' ; else if (link_info.pei386_auto_import == 1) return' >> e${EMULATION_NAME}.c
1877 sed $sc ldscripts/${EMULATION_NAME}.xa >> e${EMULATION_NAME}.c
1879 echo ' ; else return' >> e${EMULATION_NAME}.c
1880 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1881 echo '; }' >> e${EMULATION_NAME}.c
1886 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1888 gld_${EMULATION_NAME}_before_parse,
1891 gld_${EMULATION_NAME}_after_parse,
1892 gld_${EMULATION_NAME}_after_open,
1893 after_allocation_default,
1894 set_output_arch_default,
1895 ldemul_default_target,
1896 gld_${EMULATION_NAME}_before_allocation,
1897 gld_${EMULATION_NAME}_get_script,
1898 "${EMULATION_NAME}",
1900 gld_${EMULATION_NAME}_finish,
1901 NULL, /* Create output section statements. */
1902 gld_${EMULATION_NAME}_open_dynamic_archive,
1903 gld_${EMULATION_NAME}_place_orphan,
1904 gld_${EMULATION_NAME}_set_symbols,
1905 NULL, /* parse_args */
1906 gld${EMULATION_NAME}_add_options,
1907 gld${EMULATION_NAME}_handle_option,
1908 gld_${EMULATION_NAME}_unrecognized_file,
1909 gld_${EMULATION_NAME}_list_options,
1910 gld_${EMULATION_NAME}_recognized_file,
1911 gld_${EMULATION_NAME}_find_potential_libraries,
1912 NULL /* new_vers_pattern. */