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 ;-)
10 cat >>e${EMULATION_NAME}.c <<EOF
11 /* This file is part of GLD, the Gnu Linker.
12 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
13 Free Software Foundation, Inc.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or
18 (at your option) any later version.
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 /* The original file generated returned different default scripts depending
31 on whether certain switches were set, but these switches pertain to the
32 Linux system and that particular version of coff. In the NT case, we
33 only determine if the subsystem is console or windows in order to select
34 the correct entry point by default. */
36 #define TARGET_IS_${EMULATION_NAME}
38 /* Do this before including bfd.h, so we prototype the right functions. */
39 #ifdef TARGET_IS_arm_epoc_pe
40 #define bfd_arm_pe_allocate_interworking_sections \
41 bfd_arm_epoc_pe_allocate_interworking_sections
42 #define bfd_arm_pe_get_bfd_for_interworking \
43 bfd_arm_epoc_pe_get_bfd_for_interworking
44 #define bfd_arm_pe_process_before_allocation \
45 bfd_arm_epoc_pe_process_before_allocation
52 #include "libiberty.h"
63 #include "coff/internal.h"
65 /* FIXME: This is a BFD internal header file, and we should not be
67 #include "../bfd/libcoff.h"
71 #include "safe-ctype.h"
73 /* Permit the emulation parameters to override the default section
74 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
75 it seem that include/coff/internal.h should not define
76 PE_DEF_SECTION_ALIGNMENT. */
77 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
78 #undef PE_DEF_SECTION_ALIGNMENT
79 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
82 #if defined(TARGET_IS_i386pe)
85 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe) || defined(TARGET_IS_armpe)
89 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
90 #define PE_DEF_SUBSYSTEM 3
92 #undef NT_EXE_IMAGE_BASE
93 #undef PE_DEF_SECTION_ALIGNMENT
94 #undef PE_DEF_FILE_ALIGNMENT
95 #define NT_EXE_IMAGE_BASE 0x00010000
96 #ifdef TARGET_IS_armpe
97 #define PE_DEF_SECTION_ALIGNMENT 0x00001000
98 #define PE_DEF_SUBSYSTEM 9
100 #define PE_DEF_SECTION_ALIGNMENT 0x00000400
101 #define PE_DEF_SUBSYSTEM 2
103 #define PE_DEF_FILE_ALIGNMENT 0x00000200
107 static struct internal_extra_pe_aouthdr pe;
109 static int support_old_code = 0;
110 static char * thumb_entry_symbol = NULL;
111 static lang_assignment_statement_type *image_base_statement = 0;
114 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable. */
115 static char *pe_out_def_filename = NULL;
116 static char *pe_implib_filename = NULL;
117 static int pe_enable_auto_image_base = 0;
118 static char *pe_dll_search_prefix = NULL;
121 extern const char *output_filename;
124 gld_${EMULATION_NAME}_before_parse (void)
126 const bfd_arch_info_type *arch = bfd_scan_arch ("${OUTPUT_ARCH}");
129 ldfile_output_architecture = arch->arch;
130 ldfile_output_machine = arch->mach;
131 ldfile_output_machine_name = arch->printable_name;
134 ldfile_output_architecture = bfd_arch_${ARCH};
135 output_filename = "${EXECUTABLE_NAME:-a.exe}";
137 config.dynamic_link = TRUE;
138 config.has_shared = 1;
139 link_info.pei386_auto_import = -1;
140 link_info.pei386_runtime_pseudo_reloc = FALSE;
142 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
143 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
144 lang_add_entry ("WinMainCRTStartup", FALSE);
146 lang_add_entry ("_WinMainCRTStartup", FALSE);
152 /* PE format extra command line options. */
154 /* Used for setting flags in the PE header. */
155 #define OPTION_BASE_FILE (300 + 1)
156 #define OPTION_DLL (OPTION_BASE_FILE + 1)
157 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
158 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
159 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
160 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
161 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
162 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
163 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
164 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
165 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
166 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
167 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
168 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
169 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
170 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
171 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
172 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
173 #define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
174 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
175 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
176 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
177 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
178 #define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
179 #define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
180 #define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
181 #define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
182 #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
183 #define OPTION_DLL_SEARCH_PREFIX (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
184 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_DLL_SEARCH_PREFIX + 1)
185 #define OPTION_DLL_ENABLE_AUTO_IMPORT (OPTION_NO_DEFAULT_EXCLUDES + 1)
186 #define OPTION_DLL_DISABLE_AUTO_IMPORT (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
187 #define OPTION_ENABLE_EXTRA_PE_DEBUG (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
188 #define OPTION_EXCLUDE_LIBS (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
189 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC \
190 (OPTION_EXCLUDE_LIBS + 1)
191 #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \
192 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
195 gld${EMULATION_NAME}_add_options
196 (int ns ATTRIBUTE_UNUSED, char **shortopts ATTRIBUTE_UNUSED, int nl,
197 struct option **longopts, int nrl ATTRIBUTE_UNUSED,
198 struct option **really_longopts ATTRIBUTE_UNUSED)
200 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 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
219 /* getopt allows abbreviations, so we do this to stop it from treating -o
220 as an abbreviation for this option */
221 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
222 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
223 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
224 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
225 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
226 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
227 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
228 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
229 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
230 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
231 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
232 /* getopt() allows abbreviations, so we do this to stop it from
233 treating -c as an abbreviation for these --compat-implib. */
234 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
235 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
236 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
237 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
238 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
239 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
240 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
241 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
242 {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
243 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
244 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
246 {NULL, no_argument, NULL, 0}
249 *longopts = (struct option *)
250 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
251 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
254 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
255 parameters which may be input from the command line. */
266 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
268 static definfo init[] =
270 /* imagebase must be first */
271 #define IMAGEBASEOFF 0
272 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
274 {&dll, sizeof(dll), 0, "__dll__", 0},
275 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
276 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
277 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
278 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
279 D(MajorImageVersion,"__major_image_version__", 1),
280 D(MinorImageVersion,"__minor_image_version__", 0),
281 #ifdef TARGET_IS_armpe
282 D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
284 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
286 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
287 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
288 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
289 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
290 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
291 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
292 D(LoaderFlags,"__loader_flags__", 0x0),
293 { NULL, 0, 0, NULL, 0 }
298 gld_${EMULATION_NAME}_list_options (FILE *file)
300 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
301 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
302 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
303 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
304 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
305 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
306 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
307 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
308 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
309 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
310 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
311 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
312 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
313 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
314 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
315 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
317 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
318 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
319 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
320 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
321 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n"));
322 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
323 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
324 fprintf (file, _(" --out-implib <file> Generate import library\n"));
325 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
326 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
327 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\
328 create __imp_<SYMBOL> as well.\n"));
329 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\
330 unless user specifies one\n"));
331 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
332 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\
333 an importlib, use <string><basename>.dll\n\
334 in preference to lib<basename>.dll \n"));
335 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to\n\
336 __imp_sym for DATA references\n"));
337 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
338 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\
339 adding pseudo-relocations resolved at\n\
341 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\
342 auto-imported DATA.\n"));
343 fprintf (file, _(" --enable-extra-pe-debug Enable verbose debug output when building\n\
344 or linking to DLLs (esp. auto-import)\n"));
350 set_pe_name (char *name, long val)
354 /* Find the name and set it. */
355 for (i = 0; init[i].ptr; i++)
357 if (strcmp (name, init[i].symbol) == 0)
369 set_pe_subsystem (void)
382 { "native", 1, "NtProcessStartup" },
383 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
384 { "windows", 2, "WinMainCRTStartup" },
386 { "windows", 2, "WinMainCRTStartup" },
388 { "console", 3, "mainCRTStartup" },
390 /* The Microsoft linker does not recognize this. */
393 { "posix", 7, "__PosixProcessStartup"},
394 { "wince", 9, "_WinMainCRTStartup" },
398 sver = strchr (optarg, ':');
400 len = strlen (optarg);
406 set_pe_name ("__major_subsystem_version__",
407 strtoul (sver + 1, &end, 0));
409 set_pe_name ("__minor_subsystem_version__",
410 strtoul (end + 1, &end, 0));
412 einfo (_("%P: warning: bad version number in -subsystem option\n"));
415 for (i = 0; v[i].name; i++)
417 if (strncmp (optarg, v[i].name, len) == 0
418 && v[i].name[len] == '\0')
420 const char *initial_symbol_char;
423 set_pe_name ("__subsystem__", v[i].value);
425 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
426 if (*initial_symbol_char == '\0')
432 /* lang_add_entry expects its argument to be permanently
433 allocated, so we don't free this string. */
434 alc_entry = xmalloc (strlen (initial_symbol_char)
435 + strlen (v[i].entry)
437 strcpy (alc_entry, initial_symbol_char);
438 strcat (alc_entry, v[i].entry);
442 lang_add_entry (entry, TRUE);
448 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
453 set_pe_value (char *name)
457 set_pe_name (name, strtoul (optarg, &end, 0));
460 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
467 set_pe_stack_heap (char *resname, char *comname)
469 set_pe_value (resname);
474 set_pe_value (comname);
477 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
482 gld${EMULATION_NAME}_handle_option (int optc)
489 case OPTION_BASE_FILE:
490 link_info.base_file = fopen (optarg, FOPEN_WB);
491 if (link_info.base_file == NULL)
493 /* xgettext:c-format */
494 fprintf (stderr, _("%s: Can't open base file %s\n"),
495 program_name, optarg);
502 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
505 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
507 case OPTION_SUBSYSTEM:
510 case OPTION_MAJOR_OS_VERSION:
511 set_pe_value ("__major_os_version__");
513 case OPTION_MINOR_OS_VERSION:
514 set_pe_value ("__minor_os_version__");
516 case OPTION_MAJOR_SUBSYSTEM_VERSION:
517 set_pe_value ("__major_subsystem_version__");
519 case OPTION_MINOR_SUBSYSTEM_VERSION:
520 set_pe_value ("__minor_subsystem_version__");
522 case OPTION_MAJOR_IMAGE_VERSION:
523 set_pe_value ("__major_image_version__");
525 case OPTION_MINOR_IMAGE_VERSION:
526 set_pe_value ("__minor_image_version__");
528 case OPTION_FILE_ALIGNMENT:
529 set_pe_value ("__file_alignment__");
531 case OPTION_SECTION_ALIGNMENT:
532 set_pe_value ("__section_alignment__");
535 set_pe_name ("__dll__", 1);
537 case OPTION_IMAGE_BASE:
538 set_pe_value ("__image_base__");
540 case OPTION_SUPPORT_OLD_CODE:
541 support_old_code = 1;
543 case OPTION_THUMB_ENTRY:
544 thumb_entry_symbol = optarg;
548 pe_out_def_filename = xstrdup (optarg);
550 case OPTION_EXPORT_ALL:
551 pe_dll_export_everything = 1;
553 case OPTION_EXCLUDE_SYMBOLS:
554 pe_dll_add_excludes (optarg, 0);
556 case OPTION_EXCLUDE_LIBS:
557 pe_dll_add_excludes (optarg, 1);
559 case OPTION_KILL_ATS:
562 case OPTION_STDCALL_ALIASES:
563 pe_dll_stdcall_aliases = 1;
565 case OPTION_ENABLE_STDCALL_FIXUP:
566 pe_enable_stdcall_fixup = 1;
568 case OPTION_DISABLE_STDCALL_FIXUP:
569 pe_enable_stdcall_fixup = 0;
571 case OPTION_IMPLIB_FILENAME:
572 pe_implib_filename = xstrdup (optarg);
574 case OPTION_WARN_DUPLICATE_EXPORTS:
575 pe_dll_warn_dup_exports = 1;
577 case OPTION_IMP_COMPAT:
578 pe_dll_compat_implib = 1;
580 case OPTION_ENABLE_AUTO_IMAGE_BASE:
581 pe_enable_auto_image_base = 1;
583 case OPTION_DISABLE_AUTO_IMAGE_BASE:
584 pe_enable_auto_image_base = 0;
586 case OPTION_DLL_SEARCH_PREFIX:
587 pe_dll_search_prefix = xstrdup (optarg);
589 case OPTION_NO_DEFAULT_EXCLUDES:
590 pe_dll_do_default_excludes = 0;
592 case OPTION_DLL_ENABLE_AUTO_IMPORT:
593 link_info.pei386_auto_import = 1;
595 case OPTION_DLL_DISABLE_AUTO_IMPORT:
596 link_info.pei386_auto_import = 0;
598 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
599 link_info.pei386_runtime_pseudo_reloc = 1;
601 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
602 link_info.pei386_runtime_pseudo_reloc = 0;
604 case OPTION_ENABLE_EXTRA_PE_DEBUG:
605 pe_dll_extra_pe_debug = 1;
615 strhash (const char *str)
617 const unsigned char *s;
624 s = (const unsigned char *) str;
625 while ((c = *s++) != '\0')
627 hash += c + (c << 17);
631 hash += len + (len << 17);
637 /* Use the output file to create a image base for relocatable DLLs. */
640 compute_dll_image_base (const char *ofile)
642 unsigned long hash = strhash (ofile);
643 return 0x60000000 | ((hash << 16) & 0x0FFC0000);
647 /* Assign values to the special symbols before the linker script is
651 gld_${EMULATION_NAME}_set_symbols (void)
653 /* Run through and invent symbols for all the
654 names and insert the defaults. */
656 lang_statement_list_type *save;
658 if (!init[IMAGEBASEOFF].inited)
660 if (link_info.relocatable)
661 init[IMAGEBASEOFF].value = 0;
662 else if (init[DLLOFF].value || link_info.shared)
664 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
665 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
667 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
670 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
673 /* Don't do any symbol assignments if this is a relocatable link. */
674 if (link_info.relocatable)
677 /* Glue the assignments into the abs section. */
680 stat_ptr = &(abs_output_section->children);
682 for (j = 0; init[j].ptr; j++)
684 long val = init[j].value;
685 lang_assignment_statement_type *rv;
686 rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
688 if (init[j].size == sizeof (short))
689 *(short *) init[j].ptr = val;
690 else if (init[j].size == sizeof (int))
691 *(int *) init[j].ptr = val;
692 else if (init[j].size == sizeof (long))
693 *(long *) init[j].ptr = val;
694 /* This might be a long long or other special type. */
695 else if (init[j].size == sizeof (bfd_vma))
696 *(bfd_vma *) init[j].ptr = val;
698 if (j == IMAGEBASEOFF)
699 image_base_statement = rv;
701 /* Restore the pointer. */
704 if (pe.FileAlignment >
707 einfo (_("%P: warning, file alignment > section alignment.\n"));
711 /* This is called after the linker script and the command line options
715 gld_${EMULATION_NAME}_after_parse (void)
717 /* The Windows libraries are designed for the linker to treat the
718 entry point as an undefined symbol. Otherwise, the .obj that
719 defines mainCRTStartup is brought in because it is the first
720 encountered in libc.lib and it has other symbols in it which will
721 be pulled in by the link process. To avoid this, we act as
722 though the user specified -u with the entry point symbol.
724 This function is called after the linker script and command line
725 options have been read, so at this point we know the right entry
726 point. This function is called before the input files are
727 opened, so registering the symbol as undefined will make a
730 if (! link_info.relocatable && entry_symbol.name != NULL)
731 ldlang_add_undef (entry_symbol.name);
734 /* pe-dll.c directly accesses pe_data_import_dll,
735 so it must be defined outside of #ifdef DLL_SUPPORT.
736 Note - this variable is deliberately not initialised.
737 This allows it to be treated as a common varaible, and only
738 exist in one incarnation in a multiple target enabled linker. */
739 char * pe_data_import_dll;
742 static struct bfd_link_hash_entry *pe_undef_found_sym;
745 pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
750 sl = strlen (string);
751 if (h->type == bfd_link_hash_defined
752 && strncmp (h->root.string, string, sl) == 0
753 && h->root.string[sl] == '@')
755 pe_undef_found_sym = h;
762 pe_fixup_stdcalls (void)
764 static int gave_warning_message = 0;
765 struct bfd_link_hash_entry *undef, *sym;
767 if (pe_dll_extra_pe_debug)
768 printf ("%s\n", __FUNCTION__);
770 for (undef = link_info.hash->undefs; undef; undef=undef->next)
771 if (undef->type == bfd_link_hash_undefined)
773 char* at = strchr (undef->root.string, '@');
774 int lead_at = (*undef->root.string == '@');
775 /* For now, don't try to fixup fastcall symbols. */
779 /* The symbol is a stdcall symbol, so let's look for a
780 cdecl symbol with the same name and resolve to that. */
781 char *cname = xstrdup (undef->root.string /* + lead_at */);
782 at = strchr (cname, '@');
784 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
786 if (sym && sym->type == bfd_link_hash_defined)
788 undef->type = bfd_link_hash_defined;
789 undef->u.def.value = sym->u.def.value;
790 undef->u.def.section = sym->u.def.section;
792 if (pe_enable_stdcall_fixup == -1)
794 einfo (_("Warning: resolving %s by linking to %s\n"),
795 undef->root.string, cname);
796 if (! gave_warning_message)
798 gave_warning_message = 1;
799 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
800 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
807 /* The symbol is a cdecl symbol, so we look for stdcall
808 symbols - which means scanning the whole symbol table. */
809 pe_undef_found_sym = 0;
810 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
811 (char *) undef->root.string);
812 sym = pe_undef_found_sym;
815 undef->type = bfd_link_hash_defined;
816 undef->u.def.value = sym->u.def.value;
817 undef->u.def.section = sym->u.def.section;
819 if (pe_enable_stdcall_fixup == -1)
821 einfo (_("Warning: resolving %s by linking to %s\n"),
822 undef->root.string, sym->root.string);
823 if (! gave_warning_message)
825 gave_warning_message = 1;
826 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
827 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
836 make_import_fixup (arelent *rel, asection *s)
838 struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
841 if (pe_dll_extra_pe_debug)
842 printf ("arelent: %s@%#lx: add=%li\n", sym->name,
843 (long) rel->address, (long) rel->addend);
845 if (! bfd_get_section_contents (s->owner, s, &addend, rel->address, sizeof (addend)))
846 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
847 s->owner, s, rel->address);
849 pe_create_import_fixup (rel, s, addend);
855 pe_find_data_imports (void)
857 struct bfd_link_hash_entry *undef, *sym;
859 if (link_info.pei386_auto_import == 0)
862 for (undef = link_info.hash->undefs; undef; undef=undef->next)
864 if (undef->type == bfd_link_hash_undefined)
866 /* C++ symbols are *long*. */
869 if (pe_dll_extra_pe_debug)
870 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
872 sprintf (buf, "__imp_%s", undef->root.string);
874 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
876 if (sym && sym->type == bfd_link_hash_defined)
878 bfd *b = sym->u.def.section->owner;
880 int nsyms, symsize, i;
882 if (link_info.pei386_auto_import == -1)
883 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
884 undef->root.string, buf);
886 symsize = bfd_get_symtab_upper_bound (b);
887 symbols = (asymbol **) xmalloc (symsize);
888 nsyms = bfd_canonicalize_symtab (b, symbols);
890 for (i = 0; i < nsyms; i++)
892 if (memcmp (symbols[i]->name, "__head_",
893 sizeof ("__head_") - 1))
896 if (pe_dll_extra_pe_debug)
897 printf ("->%s\n", symbols[i]->name);
899 pe_data_import_dll = (char*) (symbols[i]->name +
900 sizeof ("__head_") - 1);
904 pe_walk_relocs_of_symbol (&link_info, undef->root.string,
907 /* Let's differentiate it somehow from defined. */
908 undef->type = bfd_link_hash_defweak;
909 /* We replace original name with __imp_ prefixed, this
910 1) may trash memory 2) leads to duplicate symbol generation.
911 Still, IMHO it's better than having name poluted. */
912 undef->root.string = sym->root.string;
913 undef->u.def.value = sym->u.def.value;
914 undef->u.def.section = sym->u.def.section;
919 #endif /* DLL_SUPPORT */
922 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
924 if (pe_dll_extra_pe_debug)
925 printf ("+%s\n", h->string);
932 gld_${EMULATION_NAME}_after_open (void)
934 if (pe_dll_extra_pe_debug)
937 struct bfd_link_hash_entry *sym;
939 printf ("%s()\n", __FUNCTION__);
941 for (sym = link_info.hash->undefs; sym; sym=sym->next)
942 printf ("-%s\n", sym->root.string);
943 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
945 for (a = link_info.input_bfds; a; a = a->link_next)
946 printf ("*%s\n",a->filename);
949 /* Pass the wacky PE command line options into the output bfd.
950 FIXME: This should be done via a function, rather than by
951 including an internal BFD header. */
953 if (coff_data (output_bfd) == NULL || coff_data (output_bfd)->pe == 0)
954 einfo (_("%F%P: PE operations on non PE file.\n"));
956 pe_data (output_bfd)->pe_opthdr = pe;
957 pe_data (output_bfd)->dll = init[DLLOFF].value;
960 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
961 pe_fixup_stdcalls ();
963 pe_process_import_defs (output_bfd, & link_info);
965 pe_find_data_imports ();
967 #if ! (defined (TARGET_IS_i386pe) || defined (TARGET_IS_armpe))
968 if (link_info.shared)
970 if (!link_info.relocatable)
972 pe_dll_build_sections (output_bfd, &link_info);
974 #ifndef TARGET_IS_i386pe
975 #ifndef TARGET_IS_armpe
977 pe_exe_build_sections (output_bfd, &link_info);
982 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
983 if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
985 /* The arm backend needs special fields in the output hash structure.
986 These will only be created if the output format is an arm format,
987 hence we do not support linking and changing output formats at the
988 same time. Use a link followed by objcopy to change output formats. */
989 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
993 /* Find a BFD that can hold the interworking stubs. */
994 LANG_FOR_EACH_INPUT_STATEMENT (is)
996 if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
1003 /* This next chunk of code tries to detect the case where you have
1004 two import libraries for the same DLL (specifically,
1005 symbolically linking libm.a and libc.a in cygwin to
1006 libcygwin.a). In those cases, it's possible for function
1007 thunks from the second implib to be used but without the
1008 head/tail objects, causing an improper import table. We detect
1009 those cases and rename the "other" import libraries to match
1010 the one the head/tail come from, so that the linker will sort
1011 things nicely and produce a valid import table. */
1013 LANG_FOR_EACH_INPUT_STATEMENT (is)
1015 if (is->the_bfd->my_archive)
1017 int idata2 = 0, reloc_count=0, is_imp = 0;
1020 /* See if this is an import library thunk. */
1021 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1023 if (strcmp (sec->name, ".idata\$2") == 0)
1025 if (strncmp (sec->name, ".idata\$", 7) == 0)
1027 reloc_count += sec->reloc_count;
1030 if (is_imp && !idata2 && reloc_count)
1032 /* It is, look for the reference to head and see if it's
1033 from our own library. */
1034 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1043 symsize = bfd_get_symtab_upper_bound (is->the_bfd);
1046 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1050 symbols = (asymbol **) xmalloc (symsize);
1051 symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
1054 einfo ("%X%P: unable to process symbols: %E");
1058 relocs = (arelent **) xmalloc ((size_t) relsize);
1059 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1064 einfo ("%X%P: unable to process relocs: %E");
1068 for (i = 0; i < nrelocs; i++)
1070 struct symbol_cache_entry *s;
1071 struct bfd_link_hash_entry * blhe;
1075 s = (relocs[i]->sym_ptr_ptr)[0];
1077 if (s->flags & BSF_LOCAL)
1080 /* Thunk section with reloc to another bfd. */
1081 blhe = bfd_link_hash_lookup (link_info.hash,
1083 FALSE, FALSE, TRUE);
1086 || blhe->type != bfd_link_hash_defined)
1089 other_bfd = blhe->u.def.section->owner;
1091 if (strcmp (is->the_bfd->my_archive->filename,
1092 other_bfd->my_archive->filename) == 0)
1095 /* Rename this implib to match the other. */
1096 n = (char *) xmalloc (strlen (other_bfd->my_archive->filename) + 1);
1098 strcpy (n, other_bfd->my_archive->filename);
1100 is->the_bfd->my_archive->filename = n;
1104 /* Note - we do not free the symbols,
1105 they are now cached in the BFD. */
1115 lang_input_statement_type *is2;
1117 /* Careful - this is a shell script. Watch those dollar signs! */
1118 /* Microsoft import libraries have every member named the same,
1119 and not in the right order for us to link them correctly. We
1120 must detect these and rename the members so that they'll link
1121 correctly. There are three types of objects: the head, the
1122 thunks, and the sentinel(s). The head is easy; it's the one
1123 with idata2. We assume that the sentinels won't have relocs,
1124 and the thunks will. It's easier than checking the symbol
1125 table for external references. */
1126 LANG_FOR_EACH_INPUT_STATEMENT (is)
1128 if (is->the_bfd->my_archive)
1130 bfd *arch = is->the_bfd->my_archive;
1131 if (cur_arch != arch)
1136 is2 && is2->the_bfd->my_archive == arch;
1137 is2 = (lang_input_statement_type *)is2->next)
1139 if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
1146 int idata2 = 0, reloc_count=0;
1148 char *new_name, seq;
1150 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1152 if (strcmp (sec->name, ".idata\$2") == 0)
1154 reloc_count += sec->reloc_count;
1157 if (idata2) /* .idata2 is the TOC */
1159 else if (reloc_count > 0) /* thunks */
1164 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1165 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1166 is->the_bfd->filename = new_name;
1168 new_name = xmalloc (strlen (is->filename) + 3);
1169 sprintf (new_name, "%s.%c", is->filename, seq);
1170 is->filename = new_name;
1178 gld_${EMULATION_NAME}_before_allocation (void)
1180 #ifdef TARGET_IS_ppcpe
1181 /* Here we rummage through the found bfds to collect toc information. */
1183 LANG_FOR_EACH_INPUT_STATEMENT (is)
1185 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1187 /* xgettext:c-format */
1188 einfo (_("Errors encountered processing file %s\n"), is->filename);
1193 /* We have seen it all. Allocate it, and carry on. */
1194 ppc_allocate_toc_section (&link_info);
1195 #endif /* TARGET_IS_ppcpe */
1197 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1198 /* FIXME: we should be able to set the size of the interworking stub
1201 Here we rummage through the found bfds to collect glue
1202 information. FIXME: should this be based on a command line
1203 option? krk@cygnus.com. */
1205 LANG_FOR_EACH_INPUT_STATEMENT (is)
1207 if (! bfd_arm_pe_process_before_allocation
1208 (is->the_bfd, & link_info, support_old_code))
1210 /* xgettext:c-format */
1211 einfo (_("Errors encountered processing file %s for interworking"),
1217 /* We have seen it all. Allocate it, and carry on. */
1218 bfd_arm_pe_allocate_interworking_sections (& link_info);
1219 #endif /* TARGET_IS_armpe */
1223 /* This is called when an input file isn't recognized as a BFD. We
1224 check here for .DEF files and pull them in automatically. */
1227 saw_option (char *option)
1231 for (i = 0; init[i].ptr; i++)
1232 if (strcmp (init[i].symbol, option) == 0)
1233 return init[i].inited;
1236 #endif /* DLL_SUPPORT */
1239 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1242 const char *ext = entry->filename + strlen (entry->filename) - 4;
1244 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1246 if (pe_def_file == 0)
1247 pe_def_file = def_file_empty ();
1249 def_file_parse (entry->filename, pe_def_file);
1253 int i, buflen=0, len;
1256 for (i = 0; i < pe_def_file->num_exports; i++)
1258 len = strlen (pe_def_file->exports[i].internal_name);
1259 if (buflen < len + 2)
1263 buf = (char *) xmalloc (buflen);
1265 for (i = 0; i < pe_def_file->num_exports; i++)
1267 struct bfd_link_hash_entry *h;
1269 sprintf (buf, "_%s", pe_def_file->exports[i].internal_name);
1271 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1272 if (h == (struct bfd_link_hash_entry *) NULL)
1273 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1274 if (h->type == bfd_link_hash_new)
1276 h->type = bfd_link_hash_undefined;
1277 h->u.undef.abfd = NULL;
1278 bfd_link_add_undef (link_info.hash, h);
1283 /* def_file_print (stdout, pe_def_file); */
1284 if (pe_def_file->is_dll == 1)
1285 link_info.shared = 1;
1287 if (pe_def_file->base_address != (bfd_vma)(-1))
1290 pe_data (output_bfd)->pe_opthdr.ImageBase =
1291 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1292 init[IMAGEBASEOFF].inited = 1;
1293 if (image_base_statement)
1294 image_base_statement->exp =
1295 exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1299 /* Not sure if these *should* be set. */
1300 if (pe_def_file->version_major != -1)
1302 pe.MajorImageVersion = pe_def_file->version_major;
1303 pe.MinorImageVersion = pe_def_file->version_minor;
1306 if (pe_def_file->stack_reserve != -1
1307 && ! saw_option ("__size_of_stack_reserve__"))
1309 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1310 if (pe_def_file->stack_commit != -1)
1311 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1313 if (pe_def_file->heap_reserve != -1
1314 && ! saw_option ("__size_of_heap_reserve__"))
1316 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1317 if (pe_def_file->heap_commit != -1)
1318 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1328 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1331 #ifdef TARGET_IS_i386pe
1332 pe_dll_id_target ("pei-i386");
1334 #ifdef TARGET_IS_shpe
1335 pe_dll_id_target ("pei-shl");
1337 #ifdef TARGET_IS_mipspe
1338 pe_dll_id_target ("pei-mips");
1340 #ifdef TARGET_IS_armpe
1341 pe_dll_id_target ("pei-arm-little");
1343 if (bfd_get_format (entry->the_bfd) == bfd_object)
1345 char fbuf[LD_PATHMAX + 1];
1348 if (REALPATH (entry->filename, fbuf) == NULL)
1349 strncpy (fbuf, entry->filename, sizeof (fbuf));
1351 ext = fbuf + strlen (fbuf) - 4;
1353 if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1354 return pe_implied_import_dll (fbuf);
1361 gld_${EMULATION_NAME}_finish (void)
1363 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1364 struct bfd_link_hash_entry * h;
1366 if (thumb_entry_symbol != NULL)
1368 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1369 FALSE, FALSE, TRUE);
1371 if (h != (struct bfd_link_hash_entry *) NULL
1372 && (h->type == bfd_link_hash_defined
1373 || h->type == bfd_link_hash_defweak)
1374 && h->u.def.section->output_section != NULL)
1376 static char buffer[32];
1379 /* Special procesing is required for a Thumb entry symbol. The
1380 bottom bit of its address must be set. */
1381 val = (h->u.def.value
1382 + bfd_get_section_vma (output_bfd,
1383 h->u.def.section->output_section)
1384 + h->u.def.section->output_offset);
1388 /* Now convert this value into a string and store it in entry_symbol
1389 where the lang_finish() function will pick it up. */
1393 sprintf_vma (buffer + 2, val);
1395 if (entry_symbol.name != NULL && entry_from_cmdline)
1396 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1397 thumb_entry_symbol, entry_symbol.name);
1398 entry_symbol.name = buffer;
1401 einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1403 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1406 if (link_info.shared
1407 #if !defined(TARGET_IS_shpe) && !defined(TARGET_IS_mipspe)
1408 || (!link_info.relocatable && pe_def_file->num_exports != 0)
1412 pe_dll_fill_sections (output_bfd, &link_info);
1413 if (pe_implib_filename)
1414 pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1416 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1417 /* ARM doesn't need relocs. */
1420 pe_exe_fill_sections (output_bfd, &link_info);
1424 if (pe_out_def_filename)
1425 pe_dll_generate_def_file (pe_out_def_filename);
1426 #endif /* DLL_SUPPORT */
1428 /* I don't know where .idata gets set as code, but it shouldn't be. */
1430 asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1434 asec->flags &= ~SEC_CODE;
1435 asec->flags |= SEC_DATA;
1441 /* Find the last output section before given output statement.
1442 Used by place_orphan. */
1445 output_prev_sec_find (lang_output_section_statement_type *os)
1447 asection *s = (asection *) NULL;
1448 lang_statement_union_type *u;
1449 lang_output_section_statement_type *lookup;
1451 for (u = lang_output_section_statement.head;
1452 u != (lang_statement_union_type *) NULL;
1455 lookup = &u->output_section_statement;
1459 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1460 s = lookup->bfd_section;
1466 /* Place an orphan section.
1468 We use this to put sections in a reasonable place in the file, and
1469 to ensure that they are aligned as required.
1471 We handle grouped sections here as well. A section named .foo$nn
1472 goes into the output section .foo. All grouped sections are sorted
1475 Grouped sections for the default sections are handled by the
1476 default linker script using wildcards, and are sorted by
1481 lang_output_section_statement_type *os;
1483 lang_statement_union_type **stmt;
1487 gld_${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1489 const char *secname;
1490 char *hold_section_name;
1491 char *dollar = NULL;
1492 const char *ps = NULL;
1493 lang_output_section_statement_type *os;
1494 lang_statement_list_type add_child;
1496 secname = bfd_get_section_name (s->owner, s);
1498 /* Look through the script to see where to place this section. */
1499 hold_section_name = xstrdup (secname);
1500 if (!link_info.relocatable)
1502 dollar = strchr (hold_section_name, '$');
1507 os = lang_output_section_find (hold_section_name);
1509 lang_list_init (&add_child);
1512 && (os->bfd_section == NULL
1513 || ((s->flags ^ os->bfd_section->flags)
1514 & (SEC_LOAD | SEC_ALLOC)) == 0))
1516 /* We already have an output section statement with this
1517 name, and its bfd section, if any, has compatible flags. */
1518 lang_add_section (&add_child, s, os, file);
1522 struct orphan_save *place;
1523 static struct orphan_save hold_text;
1524 static struct orphan_save hold_rdata;
1525 static struct orphan_save hold_data;
1526 static struct orphan_save hold_bss;
1528 lang_statement_list_type *old;
1529 lang_statement_list_type add;
1530 etree_type *address;
1532 /* Try to put the new output section in a reasonable place based
1533 on the section name and section flags. */
1534 #define HAVE_SECTION(hold, name) \
1535 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1538 if ((s->flags & SEC_ALLOC) == 0)
1540 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1541 && HAVE_SECTION (hold_bss, ".bss"))
1543 else if ((s->flags & SEC_READONLY) == 0
1544 && HAVE_SECTION (hold_data, ".data"))
1546 else if ((s->flags & SEC_CODE) == 0
1547 && (s->flags & SEC_READONLY) != 0
1548 && HAVE_SECTION (hold_rdata, ".rdata"))
1549 place = &hold_rdata;
1550 else if ((s->flags & SEC_READONLY) != 0
1551 && HAVE_SECTION (hold_text, ".text"))
1556 /* Choose a unique name for the section. This will be needed if
1557 the same section name appears in the input file with
1558 different loadable or allocatable characteristics. */
1559 outsecname = xstrdup (hold_section_name);
1560 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1566 len = strlen (outsecname);
1567 newname = xmalloc (len + 5);
1568 strcpy (newname, outsecname);
1572 sprintf (newname + len, "%d", i);
1575 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1578 outsecname = newname;
1581 /* Start building a list of statements for this section. */
1584 lang_list_init (stat_ptr);
1586 if (config.build_constructors)
1588 /* If the name of the section is representable in C, then create
1589 symbols to mark the start and the end of the section. */
1590 for (ps = outsecname; *ps != '\0'; ps++)
1591 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1596 etree_type *e_align;
1598 symname = (char *) xmalloc (ps - outsecname + sizeof "___start_");
1599 sprintf (symname, "___start_%s", outsecname);
1600 e_align = exp_unop (ALIGN_K,
1601 exp_intop ((bfd_vma) 1 << s->alignment_power));
1602 lang_add_assignment (exp_assop ('=', symname, e_align));
1606 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1607 address = exp_intop ((bfd_vma) 0);
1610 /* All sections in an executable must be aligned to a page
1612 address = exp_unop (ALIGN_K,
1613 exp_nameop (NAME, "__section_alignment__"));
1616 os = lang_enter_output_section_statement (outsecname, address, 0,
1618 (etree_type *) NULL,
1619 (etree_type *) NULL,
1620 (etree_type *) NULL);
1622 lang_add_section (&add_child, s, os, file);
1624 lang_leave_output_section_statement
1625 ((bfd_vma) 0, "*default*",
1626 (struct lang_output_section_phdr_list *) NULL, NULL);
1628 if (config.build_constructors && *ps == '\0')
1632 /* lang_leave_ouput_section_statement resets stat_ptr.
1633 Put stat_ptr back where we want it. */
1637 symname = (char *) xmalloc (ps - outsecname + sizeof "___stop_");
1638 sprintf (symname, "___stop_%s", outsecname);
1639 lang_add_assignment (exp_assop ('=', symname,
1640 exp_nameop (NAME, ".")));
1645 if (place != NULL && os->bfd_section != NULL)
1647 asection *snew, **pps;
1649 snew = os->bfd_section;
1651 /* Shuffle the bfd section list to make the output file look
1652 neater. This is really only cosmetic. */
1653 if (place->section == NULL)
1655 asection *bfd_section = place->os->bfd_section;
1657 /* If the output statement hasn't been used to place
1658 any input sections (and thus doesn't have an output
1659 bfd_section), look for the closest prior output statement
1660 having an output section. */
1661 if (bfd_section == NULL)
1662 bfd_section = output_prev_sec_find (place->os);
1664 if (bfd_section != NULL && bfd_section != snew)
1665 place->section = &bfd_section->next;
1668 if (place->section != NULL)
1670 /* Unlink the section. */
1671 for (pps = &output_bfd->sections;
1673 pps = &(*pps)->next)
1675 bfd_section_list_remove (output_bfd, pps);
1677 /* Now tack it on to the "place->os" section list. */
1678 bfd_section_list_insert (output_bfd, place->section, snew);
1681 /* Save the end of this list. Further ophans of this type will
1682 follow the one we've just added. */
1683 place->section = &snew->next;
1685 /* The following is non-cosmetic. We try to put the output
1686 statements in some sort of reasonable order here, because
1687 they determine the final load addresses of the orphan
1688 sections. In addition, placing output statements in the
1689 wrong order may require extra segments. For instance,
1690 given a typical situation of all read-only sections placed
1691 in one segment and following that a segment containing all
1692 the read-write sections, we wouldn't want to place an orphan
1693 read/write section before or amongst the read-only ones. */
1694 if (add.head != NULL)
1696 if (place->stmt == NULL)
1698 /* Put the new statement list right at the head. */
1699 *add.tail = place->os->header.next;
1700 place->os->header.next = add.head;
1704 /* Put it after the last orphan statement we added. */
1705 *add.tail = *place->stmt;
1706 *place->stmt = add.head;
1709 /* Fix the global list pointer if we happened to tack our
1710 new list at the tail. */
1711 if (*old->tail == add.head)
1712 old->tail = add.tail;
1714 /* Save the end of this list. */
1715 place->stmt = add.tail;
1721 lang_statement_union_type **pl = &os->children.head;
1725 bfd_boolean found_dollar;
1727 /* The section name has a '$'. Sort it with the other '$'
1729 found_dollar = FALSE;
1730 for ( ; *pl != NULL; pl = &(*pl)->header.next)
1732 lang_input_section_type *ls;
1735 if ((*pl)->header.type != lang_input_section_enum)
1738 ls = &(*pl)->input_section;
1740 lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1741 if (strchr (lname, '$') == NULL)
1748 found_dollar = TRUE;
1749 if (strcmp (secname, lname) < 0)
1755 if (add_child.head != NULL)
1757 add_child.head->header.next = *pl;
1758 *pl = add_child.head;
1762 free (hold_section_name);
1768 gld_${EMULATION_NAME}_open_dynamic_archive
1769 (const char *arch ATTRIBUTE_UNUSED, search_dirs_type *search,
1770 lang_input_statement_type *entry)
1772 const char * filename;
1775 if (! entry->is_archive)
1778 filename = entry->filename;
1780 string = (char *) xmalloc (strlen (search->name)
1782 + sizeof "/lib.a.dll"
1784 + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1788 /* Try "libfoo.dll.a" first (preferred explicit import library for dll's. */
1789 sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1791 if (! ldfile_try_open_bfd (string, entry))
1793 /* Try "foo.dll.a" next (alternate explicit import library for dll's. */
1794 sprintf (string, "%s/%s.dll.a", search->name, filename);
1795 if (! ldfile_try_open_bfd (string, entry))
1797 /* Try libfoo.a next. Normally, this would be interpreted as a static
1798 library, but it *could* be an import library. For backwards compatibility,
1799 libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1800 or sometimes errors occur when building legacy packages.
1802 Putting libfoo.a here means that in a failure case (i.e. the library
1803 -lfoo is not found) we will search for libfoo.a twice before
1804 giving up -- once here, and once when searching for a "static" lib.
1805 for a "static" lib. */
1806 /* Try "libfoo.a" (import lib, or static lib, but must
1807 take precedence over dll's). */
1808 sprintf (string, "%s/lib%s.a", search->name, filename);
1809 if (! ldfile_try_open_bfd (string, entry))
1812 if (pe_dll_search_prefix)
1814 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */
1815 sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
1816 if (! ldfile_try_open_bfd (string, entry))
1818 /* Try "libfoo.dll" (default preferred dll name). */
1819 sprintf (string, "%s/lib%s.dll", search->name, filename);
1820 if (! ldfile_try_open_bfd (string, entry))
1822 /* Finally, try "foo.dll" (alternate dll name). */
1823 sprintf (string, "%s/%s.dll", search->name, filename);
1824 if (! ldfile_try_open_bfd (string, entry))
1832 else /* pe_dll_search_prefix not specified. */
1835 /* Try "libfoo.dll" (preferred dll name). */
1836 sprintf (string, "%s/lib%s.dll", search->name, filename);
1837 if (! ldfile_try_open_bfd (string, entry))
1839 /* Finally, try "foo.dll" (alternate dll name). */
1840 sprintf (string, "%s/%s.dll", search->name, filename);
1841 if (! ldfile_try_open_bfd (string, entry))
1852 entry->filename = string;
1858 gld_${EMULATION_NAME}_find_potential_libraries
1859 (char *name, lang_input_statement_type *entry)
1861 return ldfile_open_file_search (name, entry, "", ".lib");
1865 gld_${EMULATION_NAME}_get_script (int *isfile)
1867 # Scripts compiled in.
1868 # sed commands to quote an ld script as a C string.
1869 sc="-f stringify.sed"
1871 cat >>e${EMULATION_NAME}.c <<EOF
1875 if (link_info.relocatable && config.build_constructors)
1878 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1879 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1880 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1881 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1882 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1883 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1884 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1885 echo ' ; else return' >> e${EMULATION_NAME}.c
1886 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1887 echo '; }' >> e${EMULATION_NAME}.c
1889 cat >>e${EMULATION_NAME}.c <<EOF
1892 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1894 gld_${EMULATION_NAME}_before_parse,
1897 gld_${EMULATION_NAME}_after_parse,
1898 gld_${EMULATION_NAME}_after_open,
1899 after_allocation_default,
1900 set_output_arch_default,
1901 ldemul_default_target,
1902 gld_${EMULATION_NAME}_before_allocation,
1903 gld_${EMULATION_NAME}_get_script,
1904 "${EMULATION_NAME}",
1906 gld_${EMULATION_NAME}_finish,
1907 NULL, /* Create output section statements. */
1908 gld_${EMULATION_NAME}_open_dynamic_archive,
1909 gld_${EMULATION_NAME}_place_orphan,
1910 gld_${EMULATION_NAME}_set_symbols,
1911 NULL, /* parse_args */
1912 gld${EMULATION_NAME}_add_options,
1913 gld${EMULATION_NAME}_handle_option,
1914 gld_${EMULATION_NAME}_unrecognized_file,
1915 gld_${EMULATION_NAME}_list_options,
1916 gld_${EMULATION_NAME}_recognized_file,
1917 gld_${EMULATION_NAME}_find_potential_libraries,
1918 NULL /* new_vers_pattern. */