1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 test -z "${ENTRY}" && ENTRY="_mainCRTStartup"
4 if [ -z "$MACHINE" ]; then
7 OUTPUT_ARCH=${ARCH}:${MACHINE}
9 rm -f e${EMULATION_NAME}.c
10 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
11 cat >>e${EMULATION_NAME}.c <<EOF
12 /* This file is part of GLD, the Gnu Linker.
13 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
14 2005, 2006 Free Software Foundation, Inc.
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 2 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, MA 02110-1301, USA. */
31 /* The original file generated returned different default scripts depending
32 on whether certain switches were set, but these switches pertain to the
33 Linux system and that particular version of coff. In the NT case, we
34 only determine if the subsystem is console or windows in order to select
35 the correct entry point by default. */
37 #define TARGET_IS_${EMULATION_NAME}
39 /* Do this before including bfd.h, so we prototype the right functions. */
41 #if defined(TARGET_IS_armpe) \
42 || defined(TARGET_IS_arm_epoc_pe) \
43 || defined(TARGET_IS_arm_wince_pe)
44 #define bfd_arm_allocate_interworking_sections \
45 bfd_${EMULATION_NAME}_allocate_interworking_sections
46 #define bfd_arm_get_bfd_for_interworking \
47 bfd_${EMULATION_NAME}_get_bfd_for_interworking
48 #define bfd_arm_process_before_allocation \
49 bfd_${EMULATION_NAME}_process_before_allocation
56 #include "libiberty.h"
67 #include "coff/internal.h"
69 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
70 header in generic PE code. */
71 #include "coff/i386.h"
74 /* FIXME: This is a BFD internal header file, and we should not be
76 #include "../bfd/libcoff.h"
80 #include "safe-ctype.h"
82 /* Permit the emulation parameters to override the default section
83 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
84 it seem that include/coff/internal.h should not define
85 PE_DEF_SECTION_ALIGNMENT. */
86 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
87 #undef PE_DEF_SECTION_ALIGNMENT
88 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
91 #if defined(TARGET_IS_i386pe) \
92 || defined(TARGET_IS_shpe) \
93 || defined(TARGET_IS_mipspe) \
94 || defined(TARGET_IS_armpe) \
95 || defined(TARGET_IS_arm_epoc_pe) \
96 || defined(TARGET_IS_arm_wince_pe)
100 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
101 #define PE_DEF_SUBSYSTEM 3
103 #undef NT_EXE_IMAGE_BASE
104 #undef PE_DEF_SECTION_ALIGNMENT
105 #undef PE_DEF_FILE_ALIGNMENT
106 #define NT_EXE_IMAGE_BASE 0x00010000
108 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
109 #define PE_DEF_SECTION_ALIGNMENT 0x00001000
110 #define PE_DEF_SUBSYSTEM 9
112 #define PE_DEF_SECTION_ALIGNMENT 0x00000400
113 #define PE_DEF_SUBSYSTEM 2
115 #define PE_DEF_FILE_ALIGNMENT 0x00000200
119 static struct internal_extra_pe_aouthdr pe;
121 static flagword real_flags = 0;
122 static int support_old_code = 0;
123 static char * thumb_entry_symbol = NULL;
124 static lang_assignment_statement_type *image_base_statement = 0;
127 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable. */
128 static char *pe_out_def_filename = NULL;
129 static char *pe_implib_filename = NULL;
130 static int pe_enable_auto_image_base = 0;
131 static char *pe_dll_search_prefix = NULL;
134 extern const char *output_filename;
137 gld_${EMULATION_NAME}_before_parse (void)
139 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
140 output_filename = "${EXECUTABLE_NAME:-a.exe}";
142 config.dynamic_link = TRUE;
143 config.has_shared = 1;
144 link_info.pei386_auto_import = -1;
145 link_info.pei386_runtime_pseudo_reloc = -1;
147 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
148 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe || defined TARGET_IS_arm_wince_pe
149 lang_default_entry ("WinMainCRTStartup");
151 lang_default_entry ("_WinMainCRTStartup");
154 lang_default_entry ("${ENTRY}");
159 /* PE format extra command line options. */
161 /* Used for setting flags in the PE header. */
162 #define OPTION_BASE_FILE (300 + 1)
163 #define OPTION_DLL (OPTION_BASE_FILE + 1)
164 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
165 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
166 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
167 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
168 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
169 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
170 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
171 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
172 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
173 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
174 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
175 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
176 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
177 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
178 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
179 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
180 #define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
181 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
182 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
183 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
184 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
185 #define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
186 #define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
187 #define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
188 #define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
189 #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
190 #define OPTION_DLL_SEARCH_PREFIX (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
191 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_DLL_SEARCH_PREFIX + 1)
192 #define OPTION_DLL_ENABLE_AUTO_IMPORT (OPTION_NO_DEFAULT_EXCLUDES + 1)
193 #define OPTION_DLL_DISABLE_AUTO_IMPORT (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
194 #define OPTION_ENABLE_EXTRA_PE_DEBUG (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
195 #define OPTION_EXCLUDE_LIBS (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
196 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC \
197 (OPTION_EXCLUDE_LIBS + 1)
198 #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \
199 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
200 #define OPTION_LARGE_ADDRESS_AWARE \
201 (OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC + 1)
204 gld${EMULATION_NAME}_add_options
205 (int ns ATTRIBUTE_UNUSED, char **shortopts ATTRIBUTE_UNUSED, int nl,
206 struct option **longopts, int nrl ATTRIBUTE_UNUSED,
207 struct option **really_longopts ATTRIBUTE_UNUSED)
209 static const struct option xtra_long[] = {
211 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
212 {"dll", no_argument, NULL, OPTION_DLL},
213 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
214 {"heap", required_argument, NULL, OPTION_HEAP},
215 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
216 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
217 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
218 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
219 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
220 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
221 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
222 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
223 {"stack", required_argument, NULL, OPTION_STACK},
224 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
225 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
226 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
228 /* getopt allows abbreviations, so we do this to stop it from treating -o
229 as an abbreviation for this option */
230 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
231 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
232 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
233 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
234 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
235 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
236 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
237 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
238 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
239 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
240 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
241 /* getopt() allows abbreviations, so we do this to stop it from
242 treating -c as an abbreviation for these --compat-implib. */
243 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
244 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
245 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
246 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
247 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
248 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
249 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
250 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
251 {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
252 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
253 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
255 {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE},
256 {NULL, no_argument, NULL, 0}
259 *longopts = (struct option *)
260 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
261 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
264 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
265 parameters which may be input from the command line. */
276 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
278 static definfo init[] =
280 /* imagebase must be first */
281 #define IMAGEBASEOFF 0
282 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
284 {&dll, sizeof(dll), 0, "__dll__", 0},
285 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
286 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
287 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
288 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
289 D(MajorImageVersion,"__major_image_version__", 1),
290 D(MinorImageVersion,"__minor_image_version__", 0),
291 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
292 D(MajorSubsystemVersion,"__major_subsystem_version__", 3),
294 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
296 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
297 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
298 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
299 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
300 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
301 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
302 D(LoaderFlags,"__loader_flags__", 0x0),
303 { NULL, 0, 0, NULL, 0 }
308 gld_${EMULATION_NAME}_list_options (FILE *file)
310 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
311 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
312 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
313 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
314 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
315 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
316 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
317 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
318 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
319 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
320 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
321 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
322 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
323 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
324 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
325 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
327 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
328 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
329 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
330 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
331 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n"));
332 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
333 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
334 fprintf (file, _(" --out-implib <file> Generate import library\n"));
335 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
336 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
337 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\
338 create __imp_<SYMBOL> as well.\n"));
339 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\
340 unless user specifies one\n"));
341 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
342 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\
343 an importlib, use <string><basename>.dll\n\
344 in preference to lib<basename>.dll \n"));
345 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to\n\
346 __imp_sym for DATA references\n"));
347 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
348 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\
349 adding pseudo-relocations resolved at\n\
351 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\
352 auto-imported DATA.\n"));
353 fprintf (file, _(" --enable-extra-pe-debug Enable verbose debug output when building\n\
354 or linking to DLLs (esp. auto-import)\n"));
356 fprintf (file, _(" --large-address-aware Executable supports virtual addresses\n\
357 greater than 2 gigabytes\n"));
362 set_pe_name (char *name, long val)
366 /* Find the name and set it. */
367 for (i = 0; init[i].ptr; i++)
369 if (strcmp (name, init[i].symbol) == 0)
381 set_pe_subsystem (void)
385 const char *initial_symbol_char;
390 unsigned long temp_subsystem;
399 { "native", 1, "NtProcessStartup" },
400 { "windows", 2, "WinMainCRTStartup" },
401 { "console", 3, "mainCRTStartup" },
402 { "posix", 7, "__PosixProcessStartup"},
403 { "wince", 9, "_WinMainCRTStartup" },
404 { "xbox", 14, "mainCRTStartup" },
407 /* Entry point name for arbitrary subsystem numbers. */
408 static const char default_entry[] = "mainCRTStartup";
410 /* Check for the presence of a version number. */
411 sver = strchr (optarg, ':');
413 len = strlen (optarg);
417 set_pe_name ("__major_subsystem_version__",
418 strtoul (sver + 1, &end, 0));
420 set_pe_name ("__minor_subsystem_version__",
421 strtoul (end + 1, &end, 0));
423 einfo (_("%P: warning: bad version number in -subsystem option\n"));
426 /* Check for numeric subsystem. */
427 temp_subsystem = strtoul (optarg, & end, 0);
428 if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
430 /* Search list for a numeric match to use its entry point. */
431 for (i = 0; v[i].name; i++)
432 if (v[i].value == (int) temp_subsystem)
435 /* If no match, use the default. */
436 if (v[i].name != NULL)
439 entry = default_entry;
441 /* Use this subsystem. */
442 subsystem = (int) temp_subsystem;
446 /* Search for subsystem by name. */
447 for (i = 0; v[i].name; i++)
448 if (strncmp (optarg, v[i].name, len) == 0
449 && v[i].name[len] == '\0')
452 if (v[i].name == NULL)
454 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
459 subsystem = v[i].value;
462 set_pe_name ("__subsystem__", subsystem);
464 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
465 if (*initial_symbol_char != '\0')
469 /* lang_default_entry expects its argument to be permanently
470 allocated, so we don't free this string. */
471 alc_entry = xmalloc (strlen (initial_symbol_char)
474 strcpy (alc_entry, initial_symbol_char);
475 strcat (alc_entry, entry);
479 lang_default_entry (entry);
486 set_pe_value (char *name)
490 set_pe_name (name, strtoul (optarg, &end, 0));
493 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
500 set_pe_stack_heap (char *resname, char *comname)
502 set_pe_value (resname);
507 set_pe_value (comname);
510 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
515 gld${EMULATION_NAME}_handle_option (int optc)
522 case OPTION_BASE_FILE:
523 link_info.base_file = fopen (optarg, FOPEN_WB);
524 if (link_info.base_file == NULL)
526 /* xgettext:c-format */
527 fprintf (stderr, _("%s: Can't open base file %s\n"),
528 program_name, optarg);
535 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
538 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
540 case OPTION_SUBSYSTEM:
543 case OPTION_MAJOR_OS_VERSION:
544 set_pe_value ("__major_os_version__");
546 case OPTION_MINOR_OS_VERSION:
547 set_pe_value ("__minor_os_version__");
549 case OPTION_MAJOR_SUBSYSTEM_VERSION:
550 set_pe_value ("__major_subsystem_version__");
552 case OPTION_MINOR_SUBSYSTEM_VERSION:
553 set_pe_value ("__minor_subsystem_version__");
555 case OPTION_MAJOR_IMAGE_VERSION:
556 set_pe_value ("__major_image_version__");
558 case OPTION_MINOR_IMAGE_VERSION:
559 set_pe_value ("__minor_image_version__");
561 case OPTION_FILE_ALIGNMENT:
562 set_pe_value ("__file_alignment__");
564 case OPTION_SECTION_ALIGNMENT:
565 set_pe_value ("__section_alignment__");
568 set_pe_name ("__dll__", 1);
570 case OPTION_IMAGE_BASE:
571 set_pe_value ("__image_base__");
573 case OPTION_SUPPORT_OLD_CODE:
574 support_old_code = 1;
576 case OPTION_THUMB_ENTRY:
577 thumb_entry_symbol = optarg;
581 pe_out_def_filename = xstrdup (optarg);
583 case OPTION_EXPORT_ALL:
584 pe_dll_export_everything = 1;
586 case OPTION_EXCLUDE_SYMBOLS:
587 pe_dll_add_excludes (optarg, 0);
589 case OPTION_EXCLUDE_LIBS:
590 pe_dll_add_excludes (optarg, 1);
592 case OPTION_KILL_ATS:
595 case OPTION_STDCALL_ALIASES:
596 pe_dll_stdcall_aliases = 1;
598 case OPTION_ENABLE_STDCALL_FIXUP:
599 pe_enable_stdcall_fixup = 1;
601 case OPTION_DISABLE_STDCALL_FIXUP:
602 pe_enable_stdcall_fixup = 0;
604 case OPTION_IMPLIB_FILENAME:
605 pe_implib_filename = xstrdup (optarg);
607 case OPTION_WARN_DUPLICATE_EXPORTS:
608 pe_dll_warn_dup_exports = 1;
610 case OPTION_IMP_COMPAT:
611 pe_dll_compat_implib = 1;
613 case OPTION_ENABLE_AUTO_IMAGE_BASE:
614 pe_enable_auto_image_base = 1;
616 case OPTION_DISABLE_AUTO_IMAGE_BASE:
617 pe_enable_auto_image_base = 0;
619 case OPTION_DLL_SEARCH_PREFIX:
620 pe_dll_search_prefix = xstrdup (optarg);
622 case OPTION_NO_DEFAULT_EXCLUDES:
623 pe_dll_do_default_excludes = 0;
625 case OPTION_DLL_ENABLE_AUTO_IMPORT:
626 link_info.pei386_auto_import = 1;
628 case OPTION_DLL_DISABLE_AUTO_IMPORT:
629 link_info.pei386_auto_import = 0;
631 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
632 link_info.pei386_runtime_pseudo_reloc = 1;
634 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
635 link_info.pei386_runtime_pseudo_reloc = 0;
637 case OPTION_ENABLE_EXTRA_PE_DEBUG:
638 pe_dll_extra_pe_debug = 1;
641 case OPTION_LARGE_ADDRESS_AWARE:
642 real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
651 strhash (const char *str)
653 const unsigned char *s;
660 s = (const unsigned char *) str;
661 while ((c = *s++) != '\0')
663 hash += c + (c << 17);
667 hash += len + (len << 17);
673 /* Use the output file to create a image base for relocatable DLLs. */
676 compute_dll_image_base (const char *ofile)
678 unsigned long hash = strhash (ofile);
679 return 0x61300000 + ((hash << 16) & 0x0FFC0000);
683 /* Assign values to the special symbols before the linker script is
687 gld_${EMULATION_NAME}_set_symbols (void)
689 /* Run through and invent symbols for all the
690 names and insert the defaults. */
692 lang_statement_list_type *save;
694 if (!init[IMAGEBASEOFF].inited)
696 if (link_info.relocatable)
697 init[IMAGEBASEOFF].value = 0;
698 else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
700 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
701 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
703 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
706 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
709 /* Don't do any symbol assignments if this is a relocatable link. */
710 if (link_info.relocatable)
713 /* Glue the assignments into the abs section. */
716 stat_ptr = &(abs_output_section->children);
718 for (j = 0; init[j].ptr; j++)
720 long val = init[j].value;
721 lang_assignment_statement_type *rv;
722 rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
724 if (init[j].size == sizeof (short))
725 *(short *) init[j].ptr = val;
726 else if (init[j].size == sizeof (int))
727 *(int *) init[j].ptr = val;
728 else if (init[j].size == sizeof (long))
729 *(long *) init[j].ptr = val;
730 /* This might be a long long or other special type. */
731 else if (init[j].size == sizeof (bfd_vma))
732 *(bfd_vma *) init[j].ptr = val;
734 if (j == IMAGEBASEOFF)
735 image_base_statement = rv;
737 /* Restore the pointer. */
740 if (pe.FileAlignment >
743 einfo (_("%P: warning, file alignment > section alignment.\n"));
747 /* This is called after the linker script and the command line options
751 gld_${EMULATION_NAME}_after_parse (void)
753 /* The Windows libraries are designed for the linker to treat the
754 entry point as an undefined symbol. Otherwise, the .obj that
755 defines mainCRTStartup is brought in because it is the first
756 encountered in libc.lib and it has other symbols in it which will
757 be pulled in by the link process. To avoid this, we act as
758 though the user specified -u with the entry point symbol.
760 This function is called after the linker script and command line
761 options have been read, so at this point we know the right entry
762 point. This function is called before the input files are
763 opened, so registering the symbol as undefined will make a
766 if (! link_info.relocatable && entry_symbol.name != NULL)
767 ldlang_add_undef (entry_symbol.name);
770 /* pe-dll.c directly accesses pe_data_import_dll,
771 so it must be defined outside of #ifdef DLL_SUPPORT.
772 Note - this variable is deliberately not initialised.
773 This allows it to be treated as a common varaible, and only
774 exist in one incarnation in a multiple target enabled linker. */
775 char * pe_data_import_dll;
778 static struct bfd_link_hash_entry *pe_undef_found_sym;
781 pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
786 sl = strlen (string);
787 if (h->type == bfd_link_hash_defined
788 && strncmp (h->root.string, string, sl) == 0
789 && h->root.string[sl] == '@')
791 pe_undef_found_sym = h;
798 pe_fixup_stdcalls (void)
800 static int gave_warning_message = 0;
801 struct bfd_link_hash_entry *undef, *sym;
803 if (pe_dll_extra_pe_debug)
804 printf ("%s\n", __FUNCTION__);
806 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
807 if (undef->type == bfd_link_hash_undefined)
809 char* at = strchr (undef->root.string, '@');
810 int lead_at = (*undef->root.string == '@');
811 /* For now, don't try to fixup fastcall symbols. */
815 /* The symbol is a stdcall symbol, so let's look for a
816 cdecl symbol with the same name and resolve to that. */
817 char *cname = xstrdup (undef->root.string /* + lead_at */);
818 at = strchr (cname, '@');
820 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
822 if (sym && sym->type == bfd_link_hash_defined)
824 undef->type = bfd_link_hash_defined;
825 undef->u.def.value = sym->u.def.value;
826 undef->u.def.section = sym->u.def.section;
828 if (pe_enable_stdcall_fixup == -1)
830 einfo (_("Warning: resolving %s by linking to %s\n"),
831 undef->root.string, cname);
832 if (! gave_warning_message)
834 gave_warning_message = 1;
835 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
836 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
843 /* The symbol is a cdecl symbol, so we look for stdcall
844 symbols - which means scanning the whole symbol table. */
845 pe_undef_found_sym = 0;
846 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
847 (char *) undef->root.string);
848 sym = pe_undef_found_sym;
851 undef->type = bfd_link_hash_defined;
852 undef->u.def.value = sym->u.def.value;
853 undef->u.def.section = sym->u.def.section;
855 if (pe_enable_stdcall_fixup == -1)
857 einfo (_("Warning: resolving %s by linking to %s\n"),
858 undef->root.string, sym->root.string);
859 if (! gave_warning_message)
861 gave_warning_message = 1;
862 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
863 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
872 make_import_fixup (arelent *rel, asection *s)
874 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
877 if (pe_dll_extra_pe_debug)
878 printf ("arelent: %s@%#lx: add=%li\n", sym->name,
879 (long) rel->address, (long) rel->addend);
881 if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
882 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
883 s->owner, s, rel->address);
885 pe_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));
891 pe_find_data_imports (void)
893 struct bfd_link_hash_entry *undef, *sym;
895 if (link_info.pei386_auto_import == 0)
898 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
900 if (undef->type == bfd_link_hash_undefined)
902 /* C++ symbols are *long*. */
905 if (pe_dll_extra_pe_debug)
906 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
908 sprintf (buf, "__imp_%s", undef->root.string);
910 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
912 if (sym && sym->type == bfd_link_hash_defined)
914 bfd *b = sym->u.def.section->owner;
916 int nsyms, symsize, i;
918 if (link_info.pei386_auto_import == -1)
919 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
920 undef->root.string, buf);
922 symsize = bfd_get_symtab_upper_bound (b);
923 symbols = (asymbol **) xmalloc (symsize);
924 nsyms = bfd_canonicalize_symtab (b, symbols);
926 for (i = 0; i < nsyms; i++)
928 if (! CONST_STRNEQ (symbols[i]->name, "__head_"))
931 if (pe_dll_extra_pe_debug)
932 printf ("->%s\n", symbols[i]->name);
934 pe_data_import_dll = (char*) (symbols[i]->name +
935 sizeof ("__head_") - 1);
939 pe_walk_relocs_of_symbol (&link_info, undef->root.string,
942 /* Let's differentiate it somehow from defined. */
943 undef->type = bfd_link_hash_defweak;
944 /* We replace original name with __imp_ prefixed, this
945 1) may trash memory 2) leads to duplicate symbol generation.
946 Still, IMHO it's better than having name poluted. */
947 undef->root.string = sym->root.string;
948 undef->u.def.value = sym->u.def.value;
949 undef->u.def.section = sym->u.def.section;
956 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
958 if (pe_dll_extra_pe_debug)
959 printf ("+%s\n", h->string);
963 #endif /* DLL_SUPPORT */
967 gld_${EMULATION_NAME}_after_open (void)
970 if (pe_dll_extra_pe_debug)
973 struct bfd_link_hash_entry *sym;
975 printf ("%s()\n", __FUNCTION__);
977 for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
978 printf ("-%s\n", sym->root.string);
979 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
981 for (a = link_info.input_bfds; a; a = a->link_next)
982 printf ("*%s\n",a->filename);
986 /* Pass the wacky PE command line options into the output bfd.
987 FIXME: This should be done via a function, rather than by
988 including an internal BFD header. */
990 if (coff_data (output_bfd) == NULL || coff_data (output_bfd)->pe == 0)
991 einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"), output_bfd);
993 pe_data (output_bfd)->pe_opthdr = pe;
994 pe_data (output_bfd)->dll = init[DLLOFF].value;
995 pe_data (output_bfd)->real_flags |= real_flags;
998 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
999 pe_fixup_stdcalls ();
1001 pe_process_import_defs (output_bfd, & link_info);
1003 pe_find_data_imports ();
1005 #if defined (TARGET_IS_i386pe) \
1006 || defined (TARGET_IS_armpe) \
1007 || defined (TARGET_IS_arm_epoc_pe) \
1008 || defined (TARGET_IS_arm_wince_pe)
1009 if (!link_info.relocatable)
1010 pe_dll_build_sections (output_bfd, &link_info);
1012 pe_exe_build_sections (output_bfd, &link_info);
1014 if (link_info.shared)
1015 pe_dll_build_sections (output_bfd, &link_info);
1017 #endif /* DLL_SUPPORT */
1019 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1020 if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
1022 /* The arm backend needs special fields in the output hash structure.
1023 These will only be created if the output format is an arm format,
1024 hence we do not support linking and changing output formats at the
1025 same time. Use a link followed by objcopy to change output formats. */
1026 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1030 /* Find a BFD that can hold the interworking stubs. */
1031 LANG_FOR_EACH_INPUT_STATEMENT (is)
1033 if (bfd_arm_get_bfd_for_interworking (is->the_bfd, & link_info))
1040 /* This next chunk of code tries to detect the case where you have
1041 two import libraries for the same DLL (specifically,
1042 symbolically linking libm.a and libc.a in cygwin to
1043 libcygwin.a). In those cases, it's possible for function
1044 thunks from the second implib to be used but without the
1045 head/tail objects, causing an improper import table. We detect
1046 those cases and rename the "other" import libraries to match
1047 the one the head/tail come from, so that the linker will sort
1048 things nicely and produce a valid import table. */
1050 LANG_FOR_EACH_INPUT_STATEMENT (is)
1052 if (is->the_bfd->my_archive)
1054 int idata2 = 0, reloc_count=0, is_imp = 0;
1057 /* See if this is an import library thunk. */
1058 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1060 if (strcmp (sec->name, ".idata\$2") == 0)
1062 if (CONST_STRNEQ (sec->name, ".idata\$"))
1064 reloc_count += sec->reloc_count;
1067 if (is_imp && !idata2 && reloc_count)
1069 /* It is, look for the reference to head and see if it's
1070 from our own library. */
1071 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1080 symsize = bfd_get_symtab_upper_bound (is->the_bfd);
1083 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1087 symbols = (asymbol **) xmalloc (symsize);
1088 symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
1091 einfo ("%X%P: unable to process symbols: %E");
1095 relocs = (arelent **) xmalloc ((size_t) relsize);
1096 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1101 einfo ("%X%P: unable to process relocs: %E");
1105 for (i = 0; i < nrelocs; i++)
1107 struct bfd_symbol *s;
1108 struct bfd_link_hash_entry * blhe;
1109 char *other_bfd_filename;
1112 s = (relocs[i]->sym_ptr_ptr)[0];
1114 if (s->flags & BSF_LOCAL)
1117 /* Thunk section with reloc to another bfd. */
1118 blhe = bfd_link_hash_lookup (link_info.hash,
1120 FALSE, FALSE, TRUE);
1123 || blhe->type != bfd_link_hash_defined)
1127 = blhe->u.def.section->owner->my_archive
1128 ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1129 : bfd_get_filename (blhe->u.def.section->owner);
1131 if (strcmp (bfd_get_filename (is->the_bfd->my_archive),
1132 other_bfd_filename) == 0)
1135 /* Rename this implib to match the other one. */
1136 n = xmalloc (strlen (other_bfd_filename) + 1);
1137 strcpy (n, other_bfd_filename);
1138 is->the_bfd->my_archive->filename = n;
1142 /* Note - we do not free the symbols,
1143 they are now cached in the BFD. */
1153 lang_input_statement_type *is2;
1154 lang_input_statement_type *is3;
1156 /* Careful - this is a shell script. Watch those dollar signs! */
1157 /* Microsoft import libraries have every member named the same,
1158 and not in the right order for us to link them correctly. We
1159 must detect these and rename the members so that they'll link
1160 correctly. There are three types of objects: the head, the
1161 thunks, and the sentinel(s). The head is easy; it's the one
1162 with idata2. We assume that the sentinels won't have relocs,
1163 and the thunks will. It's easier than checking the symbol
1164 table for external references. */
1165 LANG_FOR_EACH_INPUT_STATEMENT (is)
1167 if (is->the_bfd->my_archive)
1170 bfd *arch = is->the_bfd->my_archive;
1172 if (cur_arch != arch)
1178 is3 && is3->the_bfd->my_archive == arch;
1179 is3 = (lang_input_statement_type *) is3->next)
1181 /* A MS dynamic import library can also contain static
1182 members, so look for the first element with a .dll
1183 extension, and use that for the remainder of the
1185 pnt = strrchr (is3->the_bfd->filename, '.');
1186 if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1194 /* OK, found one. Now look to see if the remaining
1195 (dynamic import) members use the same name. */
1197 is2 && is2->the_bfd->my_archive == arch;
1198 is2 = (lang_input_statement_type *) is2->next)
1200 /* Skip static members, ie anything with a .obj
1202 pnt = strrchr (is2->the_bfd->filename, '.');
1203 if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1206 if (strcmp (is3->the_bfd->filename,
1207 is2->the_bfd->filename))
1216 /* This fragment might have come from an .obj file in a Microsoft
1217 import, and not an actual import record. If this is the case,
1218 then leave the filename alone. */
1219 pnt = strrchr (is->the_bfd->filename, '.');
1221 if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1223 int idata2 = 0, reloc_count=0;
1225 char *new_name, seq;
1227 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1229 if (strcmp (sec->name, ".idata\$2") == 0)
1231 reloc_count += sec->reloc_count;
1234 if (idata2) /* .idata2 is the TOC */
1236 else if (reloc_count > 0) /* thunks */
1241 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1242 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1243 is->the_bfd->filename = new_name;
1245 new_name = xmalloc (strlen (is->filename) + 3);
1246 sprintf (new_name, "%s.%c", is->filename, seq);
1247 is->filename = new_name;
1255 gld_${EMULATION_NAME}_before_allocation (void)
1257 #ifdef TARGET_IS_ppcpe
1258 /* Here we rummage through the found bfds to collect toc information. */
1260 LANG_FOR_EACH_INPUT_STATEMENT (is)
1262 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1264 /* xgettext:c-format */
1265 einfo (_("Errors encountered processing file %s\n"), is->filename);
1270 /* We have seen it all. Allocate it, and carry on. */
1271 ppc_allocate_toc_section (&link_info);
1272 #endif /* TARGET_IS_ppcpe */
1274 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1275 /* FIXME: we should be able to set the size of the interworking stub
1278 Here we rummage through the found bfds to collect glue
1279 information. FIXME: should this be based on a command line
1280 option? krk@cygnus.com. */
1282 LANG_FOR_EACH_INPUT_STATEMENT (is)
1284 if (! bfd_arm_process_before_allocation
1285 (is->the_bfd, & link_info, support_old_code))
1287 /* xgettext:c-format */
1288 einfo (_("Errors encountered processing file %s for interworking"),
1294 /* We have seen it all. Allocate it, and carry on. */
1295 bfd_arm_allocate_interworking_sections (& link_info);
1296 #endif /* TARGET_IS_armpe || TARGET_IS_arm_epoc_pe || TARGET_IS_arm_wince_pe */
1298 before_allocation_default ();
1302 /* This is called when an input file isn't recognized as a BFD. We
1303 check here for .DEF files and pull them in automatically. */
1306 saw_option (char *option)
1310 for (i = 0; init[i].ptr; i++)
1311 if (strcmp (init[i].symbol, option) == 0)
1312 return init[i].inited;
1315 #endif /* DLL_SUPPORT */
1318 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1321 const char *ext = entry->filename + strlen (entry->filename) - 4;
1323 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1325 pe_def_file = def_file_parse (entry->filename, pe_def_file);
1329 int i, buflen=0, len;
1332 for (i = 0; i < pe_def_file->num_exports; i++)
1334 len = strlen (pe_def_file->exports[i].internal_name);
1335 if (buflen < len + 2)
1339 buf = (char *) xmalloc (buflen);
1341 for (i = 0; i < pe_def_file->num_exports; i++)
1343 struct bfd_link_hash_entry *h;
1345 sprintf (buf, "_%s", pe_def_file->exports[i].internal_name);
1347 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1348 if (h == (struct bfd_link_hash_entry *) NULL)
1349 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1350 if (h->type == bfd_link_hash_new)
1352 h->type = bfd_link_hash_undefined;
1353 h->u.undef.abfd = NULL;
1354 bfd_link_add_undef (link_info.hash, h);
1359 /* def_file_print (stdout, pe_def_file); */
1360 if (pe_def_file->is_dll == 1)
1361 link_info.shared = 1;
1363 if (pe_def_file->base_address != (bfd_vma)(-1))
1366 pe_data (output_bfd)->pe_opthdr.ImageBase =
1367 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1368 init[IMAGEBASEOFF].inited = 1;
1369 if (image_base_statement)
1370 image_base_statement->exp =
1371 exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1374 if (pe_def_file->stack_reserve != -1
1375 && ! saw_option ("__size_of_stack_reserve__"))
1377 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1378 if (pe_def_file->stack_commit != -1)
1379 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1381 if (pe_def_file->heap_reserve != -1
1382 && ! saw_option ("__size_of_heap_reserve__"))
1384 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1385 if (pe_def_file->heap_commit != -1)
1386 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1396 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1399 #ifdef TARGET_IS_i386pe
1400 pe_dll_id_target ("pei-i386");
1402 #ifdef TARGET_IS_shpe
1403 pe_dll_id_target ("pei-shl");
1405 #ifdef TARGET_IS_mipspe
1406 pe_dll_id_target ("pei-mips");
1408 #ifdef TARGET_IS_armpe
1409 pe_dll_id_target ("pei-arm-little");
1411 #ifdef TARGET_IS_arm_epoc_pe
1412 pe_dll_id_target ("epoc-pei-arm-little");
1414 #ifdef TARGET_IS_arm_wince_pe
1415 pe_dll_id_target ("pei-arm-wince-little");
1417 if (bfd_get_format (entry->the_bfd) == bfd_object)
1419 char fbuf[LD_PATHMAX + 1];
1422 if (REALPATH (entry->filename, fbuf) == NULL)
1423 strncpy (fbuf, entry->filename, sizeof (fbuf));
1425 ext = fbuf + strlen (fbuf) - 4;
1427 if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1428 return pe_implied_import_dll (fbuf);
1435 gld_${EMULATION_NAME}_finish (void)
1437 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1438 struct bfd_link_hash_entry * h;
1440 if (thumb_entry_symbol != NULL)
1442 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1443 FALSE, FALSE, TRUE);
1445 if (h != (struct bfd_link_hash_entry *) NULL
1446 && (h->type == bfd_link_hash_defined
1447 || h->type == bfd_link_hash_defweak)
1448 && h->u.def.section->output_section != NULL)
1450 static char buffer[32];
1453 /* Special procesing is required for a Thumb entry symbol. The
1454 bottom bit of its address must be set. */
1455 val = (h->u.def.value
1456 + bfd_get_section_vma (output_bfd,
1457 h->u.def.section->output_section)
1458 + h->u.def.section->output_offset);
1462 /* Now convert this value into a string and store it in entry_symbol
1463 where the lang_finish() function will pick it up. */
1467 sprintf_vma (buffer + 2, val);
1469 if (entry_symbol.name != NULL && entry_from_cmdline)
1470 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1471 thumb_entry_symbol, entry_symbol.name);
1472 entry_symbol.name = buffer;
1475 einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1477 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe) */
1482 if (link_info.shared
1483 #if !defined(TARGET_IS_shpe) && !defined(TARGET_IS_mipspe)
1484 || (!link_info.relocatable && pe_def_file->num_exports != 0)
1488 pe_dll_fill_sections (output_bfd, &link_info);
1489 if (pe_implib_filename)
1490 pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1492 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1493 /* ARM doesn't need relocs. */
1496 pe_exe_fill_sections (output_bfd, &link_info);
1500 if (pe_out_def_filename)
1501 pe_dll_generate_def_file (pe_out_def_filename);
1502 #endif /* DLL_SUPPORT */
1504 /* I don't know where .idata gets set as code, but it shouldn't be. */
1506 asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1510 asec->flags &= ~SEC_CODE;
1511 asec->flags |= SEC_DATA;
1517 /* Place an orphan section.
1519 We use this to put sections in a reasonable place in the file, and
1520 to ensure that they are aligned as required.
1522 We handle grouped sections here as well. A section named .foo$nn
1523 goes into the output section .foo. All grouped sections are sorted
1526 Grouped sections for the default sections are handled by the
1527 default linker script using wildcards, and are sorted by
1531 gld_${EMULATION_NAME}_place_orphan (asection *s)
1533 const char *secname;
1534 const char *orig_secname;
1535 char *dollar = NULL;
1536 lang_output_section_statement_type *os;
1537 lang_statement_list_type add_child;
1539 secname = bfd_get_section_name (s->owner, s);
1541 /* Look through the script to see where to place this section. */
1542 orig_secname = secname;
1543 if (!link_info.relocatable
1544 && (dollar = strchr (secname, '$')) != NULL)
1546 size_t len = dollar - orig_secname;
1547 char *newname = xmalloc (len + 1);
1548 memcpy (newname, orig_secname, len);
1549 newname[len] = '\0';
1553 os = lang_output_section_find (secname);
1555 lang_list_init (&add_child);
1558 && (os->bfd_section == NULL
1559 || os->bfd_section->flags == 0
1560 || ((s->flags ^ os->bfd_section->flags)
1561 & (SEC_LOAD | SEC_ALLOC)) == 0))
1563 /* We already have an output section statement with this
1564 name, and its bfd section, if any, has compatible flags.
1565 If the section already exists but does not have any flags set,
1566 then it has been created by the linker, probably as a result of
1567 a --section-start command line switch. */
1568 lang_add_section (&add_child, s, os);
1572 static struct orphan_save hold[] =
1575 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1578 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1581 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1587 enum orphan_save_index
1594 static int orphan_init_done = 0;
1595 struct orphan_save *place;
1596 lang_output_section_statement_type *after;
1597 etree_type *address;
1599 if (!orphan_init_done)
1601 struct orphan_save *ho;
1602 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1603 if (ho->name != NULL)
1605 ho->os = lang_output_section_find (ho->name);
1606 if (ho->os != NULL && ho->os->flags == 0)
1607 ho->os->flags = ho->flags;
1609 orphan_init_done = 1;
1612 /* Try to put the new output section in a reasonable place based
1613 on the section name and section flags. */
1616 if ((s->flags & SEC_ALLOC) == 0)
1618 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1619 place = &hold[orphan_bss];
1620 else if ((s->flags & SEC_READONLY) == 0)
1621 place = &hold[orphan_data];
1622 else if ((s->flags & SEC_CODE) == 0)
1623 place = &hold[orphan_rodata];
1625 place = &hold[orphan_text];
1630 if (place->os == NULL)
1631 place->os = lang_output_section_find (place->name);
1634 after = lang_output_section_find_by_flags (s, &place->os, NULL);
1636 /* *ABS* is always the first output section statement. */
1637 after = (&lang_output_section_statement.head
1638 ->output_section_statement);
1641 /* Choose a unique name for the section. This will be needed if the
1642 same section name appears in the input file with different
1643 loadable or allocatable characteristics. */
1644 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1646 static int count = 1;
1647 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1648 if (secname == NULL)
1649 einfo ("%F%P: place_orphan failed: %E\n");
1652 /* All sections in an executable must be aligned to a page boundary. */
1653 address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
1654 os = lang_insert_orphan (s, secname, after, place, address, &add_child);
1658 lang_statement_union_type **pl = &os->children.head;
1662 bfd_boolean found_dollar;
1664 /* The section name has a '$'. Sort it with the other '$'
1666 found_dollar = FALSE;
1667 for ( ; *pl != NULL; pl = &(*pl)->header.next)
1669 lang_input_section_type *ls;
1672 if ((*pl)->header.type != lang_input_section_enum)
1675 ls = &(*pl)->input_section;
1677 lname = bfd_get_section_name (ls->section->owner, ls->section);
1678 if (strchr (lname, '$') == NULL)
1685 found_dollar = TRUE;
1686 if (strcmp (orig_secname, lname) < 0)
1692 if (add_child.head != NULL)
1694 add_child.head->header.next = *pl;
1695 *pl = add_child.head;
1703 gld_${EMULATION_NAME}_open_dynamic_archive
1704 (const char *arch ATTRIBUTE_UNUSED, search_dirs_type *search,
1705 lang_input_statement_type *entry)
1709 const char * format;
1710 bfd_boolean use_prefix;
1714 /* Preferred explicit import library for dll's. */
1715 { "lib%s.dll.a", FALSE },
1716 /* Alternate explicit import library for dll's. */
1717 { "%s.dll.a", FALSE },
1718 /* "libfoo.a" could be either an import lib or a static lib.
1719 For backwards compatibility, libfoo.a needs to precede
1720 libfoo.dll and foo.dll in the search. */
1721 { "lib%s.a", FALSE },
1722 /* The 'native' spelling of an import lib name is "foo.lib". */
1723 { "%s.lib", FALSE },
1725 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */
1726 { "%s%s.dll", TRUE },
1728 /* Try "libfoo.dll" (default preferred dll name). */
1729 { "lib%s.dll", FALSE },
1730 /* Finally try 'native' dll name "foo.dll". */
1731 { "%s.dll", FALSE },
1732 /* Note: If adding more formats to this table, make sure to check to
1733 see if their length is longer than libname_fmt[0].format, and if
1734 so, update the call to xmalloc() below. */
1737 static unsigned int format_max_len = 0;
1738 const char * filename;
1744 if (! entry->is_archive)
1747 filename = entry->filename;
1749 if (format_max_len == 0)
1750 /* We need to allow space in the memory that we are going to allocate
1751 for the characters in the format string. Since the format array is
1752 static we only need to calculate this information once. In theory
1753 this value could also be computed statically, but this introduces
1754 the possibility for a discrepancy and hence a possible memory
1755 corruption. The lengths we compute here will be too long because
1756 they will include any formating characters (%s) in the strings, but
1757 this will not matter. */
1758 for (i = 0; libname_fmt[i].format; i++)
1759 if (format_max_len < strlen (libname_fmt[i].format))
1760 format_max_len = strlen (libname_fmt[i].format);
1762 full_string = xmalloc (strlen (search->name)
1766 + (pe_dll_search_prefix
1767 ? strlen (pe_dll_search_prefix) : 0)
1769 /* Allow for the terminating NUL and for the path
1770 separator character that is inserted between
1771 search->name and the start of the format string. */
1774 sprintf (full_string, "%s/", search->name);
1775 base_string = full_string + strlen (full_string);
1777 for (i = 0; libname_fmt[i].format; i++)
1780 if (libname_fmt[i].use_prefix)
1782 if (!pe_dll_search_prefix)
1784 sprintf (base_string, libname_fmt[i].format, pe_dll_search_prefix, filename);
1788 sprintf (base_string, libname_fmt[i].format, filename);
1790 if (ldfile_try_open_bfd (full_string, entry))
1794 if (!libname_fmt[i].format)
1800 entry->filename = full_string;
1806 gld_${EMULATION_NAME}_find_potential_libraries
1807 (char *name, lang_input_statement_type *entry)
1809 return ldfile_open_file_search (name, entry, "", ".lib");
1813 gld_${EMULATION_NAME}_get_script (int *isfile)
1815 # Scripts compiled in.
1816 # sed commands to quote an ld script as a C string.
1817 sc="-f stringify.sed"
1819 cat >>e${EMULATION_NAME}.c <<EOF
1823 if (link_info.relocatable && config.build_constructors)
1826 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1827 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1828 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1829 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1830 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1831 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1832 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1833 echo ' ; else return' >> e${EMULATION_NAME}.c
1834 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1835 echo '; }' >> e${EMULATION_NAME}.c
1837 cat >>e${EMULATION_NAME}.c <<EOF
1840 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1842 gld_${EMULATION_NAME}_before_parse,
1845 gld_${EMULATION_NAME}_after_parse,
1846 gld_${EMULATION_NAME}_after_open,
1847 after_allocation_default,
1848 set_output_arch_default,
1849 ldemul_default_target,
1850 gld_${EMULATION_NAME}_before_allocation,
1851 gld_${EMULATION_NAME}_get_script,
1852 "${EMULATION_NAME}",
1854 gld_${EMULATION_NAME}_finish,
1855 NULL, /* Create output section statements. */
1856 gld_${EMULATION_NAME}_open_dynamic_archive,
1857 gld_${EMULATION_NAME}_place_orphan,
1858 gld_${EMULATION_NAME}_set_symbols,
1859 NULL, /* parse_args */
1860 gld${EMULATION_NAME}_add_options,
1861 gld${EMULATION_NAME}_handle_option,
1862 gld_${EMULATION_NAME}_unrecognized_file,
1863 gld_${EMULATION_NAME}_list_options,
1864 gld_${EMULATION_NAME}_recognized_file,
1865 gld_${EMULATION_NAME}_find_potential_libraries,
1866 NULL /* new_vers_pattern. */