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
106 static void gld_${EMULATION_NAME}_set_symbols PARAMS ((void));
107 static void gld_${EMULATION_NAME}_after_open PARAMS ((void));
108 static void gld_${EMULATION_NAME}_before_parse PARAMS ((void));
109 static void gld_${EMULATION_NAME}_after_parse PARAMS ((void));
110 static void gld_${EMULATION_NAME}_before_allocation PARAMS ((void));
111 static asection *output_prev_sec_find
112 PARAMS ((lang_output_section_statement_type *));
113 static bfd_boolean gld_${EMULATION_NAME}_place_orphan
114 PARAMS ((lang_input_statement_type *, asection *));
115 static char *gld_${EMULATION_NAME}_get_script PARAMS ((int *));
116 static void gld_${EMULATION_NAME}_finish PARAMS ((void));
117 static bfd_boolean gld_${EMULATION_NAME}_open_dynamic_archive
118 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
119 static void gld${EMULATION_NAME}_add_options
120 PARAMS ((int, char **, int, struct option **, int, struct option **));
121 static bfd_boolean gld${EMULATION_NAME}_handle_option PARAMS ((int));
122 static void gld_${EMULATION_NAME}_list_options PARAMS ((FILE *));
123 static void set_pe_name PARAMS ((char *, long));
124 static void set_pe_subsystem PARAMS ((void));
125 static void set_pe_value PARAMS ((char *));
126 static void set_pe_stack_heap PARAMS ((char *, char *));
129 static bfd_boolean pe_undef_cdecl_match
130 PARAMS ((struct bfd_link_hash_entry *, PTR));
131 static void pe_fixup_stdcalls PARAMS ((void));
132 static int make_import_fixup PARAMS ((arelent *, asection *));
133 static void pe_find_data_imports PARAMS ((void));
136 static bfd_boolean pr_sym PARAMS ((struct bfd_hash_entry *, PTR));
137 static bfd_boolean gld_${EMULATION_NAME}_unrecognized_file
138 PARAMS ((lang_input_statement_type *));
139 static bfd_boolean gld_${EMULATION_NAME}_recognized_file
140 PARAMS ((lang_input_statement_type *));
141 static int gld_${EMULATION_NAME}_find_potential_libraries
142 PARAMS ((char *, lang_input_statement_type *));
145 static struct internal_extra_pe_aouthdr pe;
147 static int support_old_code = 0;
148 static char * thumb_entry_symbol = NULL;
149 static lang_assignment_statement_type *image_base_statement = 0;
152 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable. */
153 static char *pe_out_def_filename = NULL;
154 static char *pe_implib_filename = NULL;
155 static int pe_enable_auto_image_base = 0;
156 static char *pe_dll_search_prefix = NULL;
159 extern const char *output_filename;
162 gld_${EMULATION_NAME}_before_parse()
164 const bfd_arch_info_type *arch = bfd_scan_arch ("${OUTPUT_ARCH}");
167 ldfile_output_architecture = arch->arch;
168 ldfile_output_machine = arch->mach;
169 ldfile_output_machine_name = arch->printable_name;
172 ldfile_output_architecture = bfd_arch_${ARCH};
173 output_filename = "${EXECUTABLE_NAME:-a.exe}";
175 config.dynamic_link = TRUE;
176 config.has_shared = 1;
177 link_info.pei386_auto_import = -1;
178 link_info.pei386_runtime_pseudo_reloc = FALSE;
180 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
181 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
182 lang_add_entry ("WinMainCRTStartup", 1);
184 lang_add_entry ("_WinMainCRTStartup", 1);
190 /* PE format extra command line options. */
192 /* Used for setting flags in the PE header. */
193 #define OPTION_BASE_FILE (300 + 1)
194 #define OPTION_DLL (OPTION_BASE_FILE + 1)
195 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
196 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
197 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
198 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
199 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
200 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
201 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
202 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
203 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
204 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
205 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
206 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
207 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
208 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
209 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
210 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
211 #define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
212 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
213 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
214 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
215 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
216 #define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
217 #define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
218 #define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
219 #define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
220 #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
221 #define OPTION_DLL_SEARCH_PREFIX (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
222 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_DLL_SEARCH_PREFIX + 1)
223 #define OPTION_DLL_ENABLE_AUTO_IMPORT (OPTION_NO_DEFAULT_EXCLUDES + 1)
224 #define OPTION_DLL_DISABLE_AUTO_IMPORT (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
225 #define OPTION_ENABLE_EXTRA_PE_DEBUG (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
226 #define OPTION_EXCLUDE_LIBS (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
227 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC \
228 (OPTION_EXCLUDE_LIBS + 1)
229 #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \
230 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
233 gld${EMULATION_NAME}_add_options (ns, shortopts, nl, longopts, nrl, really_longopts)
234 int ns ATTRIBUTE_UNUSED;
235 char **shortopts ATTRIBUTE_UNUSED;
237 struct option **longopts;
238 int nrl ATTRIBUTE_UNUSED;
239 struct option **really_longopts ATTRIBUTE_UNUSED;
241 static const struct option xtra_long[] = {
243 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
244 {"dll", no_argument, NULL, OPTION_DLL},
245 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
246 {"heap", required_argument, NULL, OPTION_HEAP},
247 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
248 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
249 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
250 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
251 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
252 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
253 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
254 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
255 {"stack", required_argument, NULL, OPTION_STACK},
256 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
257 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
258 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
260 /* getopt allows abbreviations, so we do this to stop it from treating -o
261 as an abbreviation for this option */
262 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
263 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
264 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
265 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
266 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
267 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
268 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
269 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
270 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
271 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
272 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
273 /* getopt() allows abbreviations, so we do this to stop it from
274 treating -c as an abbreviation for these --compat-implib. */
275 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
276 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
277 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
278 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
279 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
280 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
281 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
282 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
283 {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
284 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
285 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
287 {NULL, no_argument, NULL, 0}
290 *longopts = (struct option *)
291 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
292 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
295 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
296 parameters which may be input from the command line. */
307 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
309 static definfo init[] =
311 /* imagebase must be first */
312 #define IMAGEBASEOFF 0
313 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
315 {&dll, sizeof(dll), 0, "__dll__", 0},
316 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
317 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
318 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
319 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
320 D(MajorImageVersion,"__major_image_version__", 1),
321 D(MinorImageVersion,"__minor_image_version__", 0),
322 #ifdef TARGET_IS_armpe
323 D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
325 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
327 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
328 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
329 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
330 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
331 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
332 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
333 D(LoaderFlags,"__loader_flags__", 0x0),
334 { NULL, 0, 0, NULL, 0 }
339 gld_${EMULATION_NAME}_list_options (file)
342 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
343 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
344 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
345 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
346 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
347 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
348 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
349 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
350 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
351 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
352 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
353 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
354 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
355 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
356 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
357 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
359 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
360 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
361 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
362 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
363 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n"));
364 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
365 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
366 fprintf (file, _(" --out-implib <file> Generate import library\n"));
367 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
368 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
369 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\
370 create __imp_<SYMBOL> as well.\n"));
371 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\
372 unless user specifies one\n"));
373 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
374 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\
375 an importlib, use <string><basename>.dll\n\
376 in preference to lib<basename>.dll \n"));
377 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to\n\
378 __imp_sym for DATA references\n"));
379 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
380 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\
381 adding pseudo-relocations resolved at\n\
383 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\
384 auto-imported DATA.\n"));
385 fprintf (file, _(" --enable-extra-pe-debug Enable verbose debug output when building\n\
386 or linking to DLLs (esp. auto-import)\n"));
392 set_pe_name (name, val)
398 /* Find the name and set it. */
399 for (i = 0; init[i].ptr; i++)
401 if (strcmp (name, init[i].symbol) == 0)
426 { "native", 1, "NtProcessStartup" },
427 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
428 { "windows", 2, "WinMainCRTStartup" },
430 { "windows", 2, "WinMainCRTStartup" },
432 { "console", 3, "mainCRTStartup" },
434 /* The Microsoft linker does not recognize this. */
437 { "posix", 7, "__PosixProcessStartup"},
438 { "wince", 9, "_WinMainCRTStartup" },
442 sver = strchr (optarg, ':');
444 len = strlen (optarg);
450 set_pe_name ("__major_subsystem_version__",
451 strtoul (sver + 1, &end, 0));
453 set_pe_name ("__minor_subsystem_version__",
454 strtoul (end + 1, &end, 0));
456 einfo (_("%P: warning: bad version number in -subsystem option\n"));
459 for (i = 0; v[i].name; i++)
461 if (strncmp (optarg, v[i].name, len) == 0
462 && v[i].name[len] == '\0')
464 const char *initial_symbol_char;
467 set_pe_name ("__subsystem__", v[i].value);
469 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
470 if (*initial_symbol_char == '\0')
476 /* lang_add_entry expects its argument to be permanently
477 allocated, so we don't free this string. */
478 alc_entry = xmalloc (strlen (initial_symbol_char)
479 + strlen (v[i].entry)
481 strcpy (alc_entry, initial_symbol_char);
482 strcat (alc_entry, v[i].entry);
486 lang_add_entry (entry, 0);
492 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
503 set_pe_name (name, strtoul (optarg, &end, 0));
506 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
513 set_pe_stack_heap (resname, comname)
517 set_pe_value (resname);
522 set_pe_value (comname);
525 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
530 gld${EMULATION_NAME}_handle_option (optc)
538 case OPTION_BASE_FILE:
539 link_info.base_file = (PTR) fopen (optarg, FOPEN_WB);
540 if (link_info.base_file == NULL)
542 /* xgettext:c-format */
543 fprintf (stderr, _("%s: Can't open base file %s\n"),
544 program_name, optarg);
551 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
554 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
556 case OPTION_SUBSYSTEM:
559 case OPTION_MAJOR_OS_VERSION:
560 set_pe_value ("__major_os_version__");
562 case OPTION_MINOR_OS_VERSION:
563 set_pe_value ("__minor_os_version__");
565 case OPTION_MAJOR_SUBSYSTEM_VERSION:
566 set_pe_value ("__major_subsystem_version__");
568 case OPTION_MINOR_SUBSYSTEM_VERSION:
569 set_pe_value ("__minor_subsystem_version__");
571 case OPTION_MAJOR_IMAGE_VERSION:
572 set_pe_value ("__major_image_version__");
574 case OPTION_MINOR_IMAGE_VERSION:
575 set_pe_value ("__minor_image_version__");
577 case OPTION_FILE_ALIGNMENT:
578 set_pe_value ("__file_alignment__");
580 case OPTION_SECTION_ALIGNMENT:
581 set_pe_value ("__section_alignment__");
584 set_pe_name ("__dll__", 1);
586 case OPTION_IMAGE_BASE:
587 set_pe_value ("__image_base__");
589 case OPTION_SUPPORT_OLD_CODE:
590 support_old_code = 1;
592 case OPTION_THUMB_ENTRY:
593 thumb_entry_symbol = optarg;
597 pe_out_def_filename = xstrdup (optarg);
599 case OPTION_EXPORT_ALL:
600 pe_dll_export_everything = 1;
602 case OPTION_EXCLUDE_SYMBOLS:
603 pe_dll_add_excludes (optarg, 0);
605 case OPTION_EXCLUDE_LIBS:
606 pe_dll_add_excludes (optarg, 1);
608 case OPTION_KILL_ATS:
611 case OPTION_STDCALL_ALIASES:
612 pe_dll_stdcall_aliases = 1;
614 case OPTION_ENABLE_STDCALL_FIXUP:
615 pe_enable_stdcall_fixup = 1;
617 case OPTION_DISABLE_STDCALL_FIXUP:
618 pe_enable_stdcall_fixup = 0;
620 case OPTION_IMPLIB_FILENAME:
621 pe_implib_filename = xstrdup (optarg);
623 case OPTION_WARN_DUPLICATE_EXPORTS:
624 pe_dll_warn_dup_exports = 1;
626 case OPTION_IMP_COMPAT:
627 pe_dll_compat_implib = 1;
629 case OPTION_ENABLE_AUTO_IMAGE_BASE:
630 pe_enable_auto_image_base = 1;
632 case OPTION_DISABLE_AUTO_IMAGE_BASE:
633 pe_enable_auto_image_base = 0;
635 case OPTION_DLL_SEARCH_PREFIX:
636 pe_dll_search_prefix = xstrdup (optarg);
638 case OPTION_NO_DEFAULT_EXCLUDES:
639 pe_dll_do_default_excludes = 0;
641 case OPTION_DLL_ENABLE_AUTO_IMPORT:
642 link_info.pei386_auto_import = 1;
644 case OPTION_DLL_DISABLE_AUTO_IMPORT:
645 link_info.pei386_auto_import = 0;
647 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
648 link_info.pei386_runtime_pseudo_reloc = 1;
650 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
651 link_info.pei386_runtime_pseudo_reloc = 0;
653 case OPTION_ENABLE_EXTRA_PE_DEBUG:
654 pe_dll_extra_pe_debug = 1;
664 strhash (const char *str)
666 const unsigned char *s;
673 s = (const unsigned char *) str;
674 while ((c = *s++) != '\0')
676 hash += c + (c << 17);
680 hash += len + (len << 17);
686 /* Use the output file to create a image base for relocatable DLLs. */
689 compute_dll_image_base (const char *ofile)
691 unsigned long hash = strhash (ofile);
692 return 0x60000000 | ((hash << 16) & 0x0FFC0000);
696 /* Assign values to the special symbols before the linker script is
700 gld_${EMULATION_NAME}_set_symbols ()
702 /* Run through and invent symbols for all the
703 names and insert the defaults. */
705 lang_statement_list_type *save;
707 if (!init[IMAGEBASEOFF].inited)
709 if (link_info.relocateable)
710 init[IMAGEBASEOFF].value = 0;
711 else if (init[DLLOFF].value || link_info.shared)
713 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
714 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
716 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
719 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
722 /* Don't do any symbol assignments if this is a relocateable link. */
723 if (link_info.relocateable)
726 /* Glue the assignments into the abs section. */
729 stat_ptr = &(abs_output_section->children);
731 for (j = 0; init[j].ptr; j++)
733 long val = init[j].value;
734 lang_assignment_statement_type *rv;
735 rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
737 if (init[j].size == sizeof (short))
738 *(short *) init[j].ptr = val;
739 else if (init[j].size == sizeof (int))
740 *(int *) init[j].ptr = val;
741 else if (init[j].size == sizeof (long))
742 *(long *) init[j].ptr = val;
743 /* This might be a long long or other special type. */
744 else if (init[j].size == sizeof (bfd_vma))
745 *(bfd_vma *) init[j].ptr = val;
747 if (j == IMAGEBASEOFF)
748 image_base_statement = rv;
750 /* Restore the pointer. */
753 if (pe.FileAlignment >
756 einfo (_("%P: warning, file alignment > section alignment.\n"));
760 /* This is called after the linker script and the command line options
764 gld_${EMULATION_NAME}_after_parse ()
766 /* The Windows libraries are designed for the linker to treat the
767 entry point as an undefined symbol. Otherwise, the .obj that
768 defines mainCRTStartup is brought in because it is the first
769 encountered in libc.lib and it has other symbols in it which will
770 be pulled in by the link process. To avoid this, we act as
771 though the user specified -u with the entry point symbol.
773 This function is called after the linker script and command line
774 options have been read, so at this point we know the right entry
775 point. This function is called before the input files are
776 opened, so registering the symbol as undefined will make a
779 if (! link_info.relocateable && entry_symbol.name != NULL)
780 ldlang_add_undef (entry_symbol.name);
783 /* pe-dll.c directly accesses pe_data_import_dll,
784 so it must be defined outside of #ifdef DLL_SUPPORT.
785 Note - this variable is deliberately not initialised.
786 This allows it to be treated as a common varaible, and only
787 exist in one incarnation in a multiple target enabled linker. */
788 char * pe_data_import_dll;
791 static struct bfd_link_hash_entry *pe_undef_found_sym;
794 pe_undef_cdecl_match (h, string)
795 struct bfd_link_hash_entry *h;
800 sl = strlen (string); /* Silence compiler warning. */
801 if (h->type == bfd_link_hash_defined
802 && strncmp (h->root.string, string, sl) == 0
803 && h->root.string[sl] == '@')
805 pe_undef_found_sym = h;
814 static int gave_warning_message = 0;
815 struct bfd_link_hash_entry *undef, *sym;
817 if (pe_dll_extra_pe_debug)
818 printf ("%s\n", __FUNCTION__);
820 for (undef = link_info.hash->undefs; undef; undef=undef->next)
821 if (undef->type == bfd_link_hash_undefined)
823 char* at = strchr (undef->root.string, '@');
824 int lead_at = (*undef->root.string == '@');
825 /* For now, don't try to fixup fastcall symbols. */
829 /* The symbol is a stdcall symbol, so let's look for a
830 cdecl symbol with the same name and resolve to that. */
831 char *cname = xstrdup (undef->root.string /* + lead_at */);
832 at = strchr (cname, '@');
834 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
836 if (sym && sym->type == bfd_link_hash_defined)
838 undef->type = bfd_link_hash_defined;
839 undef->u.def.value = sym->u.def.value;
840 undef->u.def.section = sym->u.def.section;
842 if (pe_enable_stdcall_fixup == -1)
844 einfo (_("Warning: resolving %s by linking to %s\n"),
845 undef->root.string, cname);
846 if (! gave_warning_message)
848 gave_warning_message = 1;
849 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
850 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
857 /* The symbol is a cdecl symbol, so we look for stdcall
858 symbols - which means scanning the whole symbol table. */
859 pe_undef_found_sym = 0;
860 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
861 (PTR) undef->root.string);
862 sym = pe_undef_found_sym;
865 undef->type = bfd_link_hash_defined;
866 undef->u.def.value = sym->u.def.value;
867 undef->u.def.section = sym->u.def.section;
869 if (pe_enable_stdcall_fixup == -1)
871 einfo (_("Warning: resolving %s by linking to %s\n"),
872 undef->root.string, sym->root.string);
873 if (! gave_warning_message)
875 gave_warning_message = 1;
876 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
877 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
886 make_import_fixup (rel, s)
890 struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
893 if (pe_dll_extra_pe_debug)
894 printf ("arelent: %s@%#lx: add=%li\n", sym->name,
895 (long) rel->address, (long) rel->addend);
897 if (! bfd_get_section_contents (s->owner, s, &addend, rel->address, sizeof (addend)))
898 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
899 s->owner, s, rel->address);
901 pe_create_import_fixup (rel, s, addend);
907 pe_find_data_imports ()
909 struct bfd_link_hash_entry *undef, *sym;
911 if (link_info.pei386_auto_import == 0)
914 for (undef = link_info.hash->undefs; undef; undef=undef->next)
916 if (undef->type == bfd_link_hash_undefined)
918 /* C++ symbols are *long*. */
921 if (pe_dll_extra_pe_debug)
922 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
924 sprintf (buf, "__imp_%s", undef->root.string);
926 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
928 if (sym && sym->type == bfd_link_hash_defined)
930 bfd *b = sym->u.def.section->owner;
932 int nsyms, symsize, i;
934 if (link_info.pei386_auto_import == -1)
935 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
936 undef->root.string, buf);
938 symsize = bfd_get_symtab_upper_bound (b);
939 symbols = (asymbol **) xmalloc (symsize);
940 nsyms = bfd_canonicalize_symtab (b, symbols);
942 for (i = 0; i < nsyms; i++)
944 if (memcmp (symbols[i]->name, "__head_",
945 sizeof ("__head_") - 1))
948 if (pe_dll_extra_pe_debug)
949 printf ("->%s\n", symbols[i]->name);
951 pe_data_import_dll = (char*) (symbols[i]->name +
952 sizeof ("__head_") - 1);
956 pe_walk_relocs_of_symbol (&link_info, undef->root.string,
959 /* Let's differentiate it somehow from defined. */
960 undef->type = bfd_link_hash_defweak;
961 /* We replace original name with __imp_ prefixed, this
962 1) may trash memory 2) leads to duplicate symbol generation.
963 Still, IMHO it's better than having name poluted. */
964 undef->root.string = sym->root.string;
965 undef->u.def.value = sym->u.def.value;
966 undef->u.def.section = sym->u.def.section;
971 #endif /* DLL_SUPPORT */
975 struct bfd_hash_entry *h;
976 PTR string ATTRIBUTE_UNUSED;
978 if (pe_dll_extra_pe_debug)
979 printf ("+%s\n",h->string);
986 gld_${EMULATION_NAME}_after_open ()
988 if (pe_dll_extra_pe_debug)
991 struct bfd_link_hash_entry *sym;
993 printf ("%s()\n", __FUNCTION__);
995 for (sym = link_info.hash->undefs; sym; sym=sym->next)
996 printf ("-%s\n", sym->root.string);
997 bfd_hash_traverse (&link_info.hash->table, pr_sym,NULL);
999 for (a = link_info.input_bfds; a; a = a->link_next)
1000 printf ("*%s\n",a->filename);
1003 /* Pass the wacky PE command line options into the output bfd.
1004 FIXME: This should be done via a function, rather than by
1005 including an internal BFD header. */
1007 if (coff_data (output_bfd) == NULL || coff_data (output_bfd)->pe == 0)
1008 einfo (_("%F%P: PE operations on non PE file.\n"));
1010 pe_data (output_bfd)->pe_opthdr = pe;
1011 pe_data (output_bfd)->dll = init[DLLOFF].value;
1014 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
1015 pe_fixup_stdcalls ();
1017 pe_process_import_defs (output_bfd, & link_info);
1019 pe_find_data_imports ();
1021 #if ! (defined (TARGET_IS_i386pe) || defined (TARGET_IS_armpe))
1022 if (link_info.shared)
1024 if (!link_info.relocateable)
1026 pe_dll_build_sections (output_bfd, &link_info);
1028 #ifndef TARGET_IS_i386pe
1029 #ifndef TARGET_IS_armpe
1031 pe_exe_build_sections (output_bfd, &link_info);
1036 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1037 if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
1039 /* The arm backend needs special fields in the output hash structure.
1040 These will only be created if the output format is an arm format,
1041 hence we do not support linking and changing output formats at the
1042 same time. Use a link followed by objcopy to change output formats. */
1043 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1047 /* Find a BFD that can hold the interworking stubs. */
1048 LANG_FOR_EACH_INPUT_STATEMENT (is)
1050 if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
1057 /* This next chunk of code tries to detect the case where you have
1058 two import libraries for the same DLL (specifically,
1059 symbolically linking libm.a and libc.a in cygwin to
1060 libcygwin.a). In those cases, it's possible for function
1061 thunks from the second implib to be used but without the
1062 head/tail objects, causing an improper import table. We detect
1063 those cases and rename the "other" import libraries to match
1064 the one the head/tail come from, so that the linker will sort
1065 things nicely and produce a valid import table. */
1067 LANG_FOR_EACH_INPUT_STATEMENT (is)
1069 if (is->the_bfd->my_archive)
1071 int idata2 = 0, reloc_count=0, is_imp = 0;
1074 /* See if this is an import library thunk. */
1075 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1077 if (strcmp (sec->name, ".idata\$2") == 0)
1079 if (strncmp (sec->name, ".idata\$", 7) == 0)
1081 reloc_count += sec->reloc_count;
1084 if (is_imp && !idata2 && reloc_count)
1086 /* It is, look for the reference to head and see if it's
1087 from our own library. */
1088 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1097 symsize = bfd_get_symtab_upper_bound (is->the_bfd);
1100 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1104 symbols = (asymbol **) xmalloc (symsize);
1105 symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
1108 einfo ("%X%P: unable to process symbols: %E");
1112 relocs = (arelent **) xmalloc ((size_t) relsize);
1113 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1118 einfo ("%X%P: unable to process relocs: %E");
1122 for (i = 0; i < nrelocs; i++)
1124 struct symbol_cache_entry *s;
1125 struct bfd_link_hash_entry * blhe;
1129 s = (relocs[i]->sym_ptr_ptr)[0];
1131 if (s->flags & BSF_LOCAL)
1134 /* Thunk section with reloc to another bfd. */
1135 blhe = bfd_link_hash_lookup (link_info.hash,
1137 FALSE, FALSE, TRUE);
1140 || blhe->type != bfd_link_hash_defined)
1143 other_bfd = blhe->u.def.section->owner;
1145 if (strcmp (is->the_bfd->my_archive->filename,
1146 other_bfd->my_archive->filename) == 0)
1149 /* Rename this implib to match the other. */
1150 n = (char *) xmalloc (strlen (other_bfd->my_archive->filename) + 1);
1152 strcpy (n, other_bfd->my_archive->filename);
1154 is->the_bfd->my_archive->filename = n;
1158 /* Note - we do not free the symbols,
1159 they are now cached in the BFD. */
1169 lang_input_statement_type *is2;
1171 /* Careful - this is a shell script. Watch those dollar signs! */
1172 /* Microsoft import libraries have every member named the same,
1173 and not in the right order for us to link them correctly. We
1174 must detect these and rename the members so that they'll link
1175 correctly. There are three types of objects: the head, the
1176 thunks, and the sentinel(s). The head is easy; it's the one
1177 with idata2. We assume that the sentinels won't have relocs,
1178 and the thunks will. It's easier than checking the symbol
1179 table for external references. */
1180 LANG_FOR_EACH_INPUT_STATEMENT (is)
1182 if (is->the_bfd->my_archive)
1184 bfd *arch = is->the_bfd->my_archive;
1185 if (cur_arch != arch)
1190 is2 && is2->the_bfd->my_archive == arch;
1191 is2 = (lang_input_statement_type *)is2->next)
1193 if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
1200 int idata2 = 0, reloc_count=0;
1202 char *new_name, seq;
1204 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1206 if (strcmp (sec->name, ".idata\$2") == 0)
1208 reloc_count += sec->reloc_count;
1211 if (idata2) /* .idata2 is the TOC */
1213 else if (reloc_count > 0) /* thunks */
1218 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1219 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1220 is->the_bfd->filename = new_name;
1222 new_name = xmalloc (strlen (is->filename) + 3);
1223 sprintf (new_name, "%s.%c", is->filename, seq);
1224 is->filename = new_name;
1232 gld_${EMULATION_NAME}_before_allocation ()
1234 #ifdef TARGET_IS_ppcpe
1235 /* Here we rummage through the found bfds to collect toc information. */
1237 LANG_FOR_EACH_INPUT_STATEMENT (is)
1239 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1241 /* xgettext:c-format */
1242 einfo (_("Errors encountered processing file %s\n"), is->filename);
1247 /* We have seen it all. Allocate it, and carry on. */
1248 ppc_allocate_toc_section (&link_info);
1249 #endif /* TARGET_IS_ppcpe */
1251 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1252 /* FIXME: we should be able to set the size of the interworking stub
1255 Here we rummage through the found bfds to collect glue
1256 information. FIXME: should this be based on a command line
1257 option? krk@cygnus.com. */
1259 LANG_FOR_EACH_INPUT_STATEMENT (is)
1261 if (! bfd_arm_pe_process_before_allocation
1262 (is->the_bfd, & link_info, support_old_code))
1264 /* xgettext:c-format */
1265 einfo (_("Errors encountered processing file %s for interworking"),
1271 /* We have seen it all. Allocate it, and carry on. */
1272 bfd_arm_pe_allocate_interworking_sections (& link_info);
1273 #endif /* TARGET_IS_armpe */
1277 /* This is called when an input file isn't recognized as a BFD. We
1278 check here for .DEF files and pull them in automatically. */
1281 saw_option (char * option)
1285 for (i = 0; init[i].ptr; i++)
1286 if (strcmp (init[i].symbol, option) == 0)
1287 return init[i].inited;
1290 #endif /* DLL_SUPPORT */
1293 gld_${EMULATION_NAME}_unrecognized_file (entry)
1294 lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1297 const char *ext = entry->filename + strlen (entry->filename) - 4;
1299 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1301 if (pe_def_file == 0)
1302 pe_def_file = def_file_empty ();
1304 def_file_parse (entry->filename, pe_def_file);
1308 int i, buflen=0, len;
1311 for (i = 0; i < pe_def_file->num_exports; i++)
1313 len = strlen (pe_def_file->exports[i].internal_name);
1314 if (buflen < len + 2)
1318 buf = (char *) xmalloc (buflen);
1320 for (i = 0; i < pe_def_file->num_exports; i++)
1322 struct bfd_link_hash_entry *h;
1324 sprintf (buf, "_%s", pe_def_file->exports[i].internal_name);
1326 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1327 if (h == (struct bfd_link_hash_entry *) NULL)
1328 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1329 if (h->type == bfd_link_hash_new)
1331 h->type = bfd_link_hash_undefined;
1332 h->u.undef.abfd = NULL;
1333 bfd_link_add_undef (link_info.hash, h);
1338 /* def_file_print (stdout, pe_def_file); */
1339 if (pe_def_file->is_dll == 1)
1340 link_info.shared = 1;
1342 if (pe_def_file->base_address != (bfd_vma)(-1))
1345 pe_data (output_bfd)->pe_opthdr.ImageBase =
1346 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1347 init[IMAGEBASEOFF].inited = 1;
1348 if (image_base_statement)
1349 image_base_statement->exp =
1350 exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1354 /* Not sure if these *should* be set. */
1355 if (pe_def_file->version_major != -1)
1357 pe.MajorImageVersion = pe_def_file->version_major;
1358 pe.MinorImageVersion = pe_def_file->version_minor;
1361 if (pe_def_file->stack_reserve != -1
1362 && ! saw_option ("__size_of_stack_reserve__"))
1364 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1365 if (pe_def_file->stack_commit != -1)
1366 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1368 if (pe_def_file->heap_reserve != -1
1369 && ! saw_option ("__size_of_heap_reserve__"))
1371 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1372 if (pe_def_file->heap_commit != -1)
1373 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1383 gld_${EMULATION_NAME}_recognized_file (entry)
1384 lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1387 #ifdef TARGET_IS_i386pe
1388 pe_dll_id_target ("pei-i386");
1390 #ifdef TARGET_IS_shpe
1391 pe_dll_id_target ("pei-shl");
1393 #ifdef TARGET_IS_mipspe
1394 pe_dll_id_target ("pei-mips");
1396 #ifdef TARGET_IS_armpe
1397 pe_dll_id_target ("pei-arm-little");
1399 if (bfd_get_format (entry->the_bfd) == bfd_object)
1401 char fbuf[LD_PATHMAX + 1];
1404 if (REALPATH (entry->filename, fbuf) == NULL)
1405 strncpy (fbuf, entry->filename, sizeof (fbuf));
1407 ext = fbuf + strlen (fbuf) - 4;
1409 if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1410 return pe_implied_import_dll (fbuf);
1417 gld_${EMULATION_NAME}_finish ()
1419 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1420 struct bfd_link_hash_entry * h;
1422 if (thumb_entry_symbol != NULL)
1424 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1425 FALSE, FALSE, TRUE);
1427 if (h != (struct bfd_link_hash_entry *) NULL
1428 && (h->type == bfd_link_hash_defined
1429 || h->type == bfd_link_hash_defweak)
1430 && h->u.def.section->output_section != NULL)
1432 static char buffer[32];
1435 /* Special procesing is required for a Thumb entry symbol. The
1436 bottom bit of its address must be set. */
1437 val = (h->u.def.value
1438 + bfd_get_section_vma (output_bfd,
1439 h->u.def.section->output_section)
1440 + h->u.def.section->output_offset);
1444 /* Now convert this value into a string and store it in entry_symbol
1445 where the lang_finish() function will pick it up. */
1449 sprintf_vma (buffer + 2, val);
1451 if (entry_symbol.name != NULL && entry_from_cmdline)
1452 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1453 thumb_entry_symbol, entry_symbol.name);
1454 entry_symbol.name = buffer;
1457 einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1459 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1462 if (link_info.shared
1463 #if !defined(TARGET_IS_shpe) && !defined(TARGET_IS_mipspe)
1464 || (!link_info.relocateable && pe_def_file->num_exports != 0)
1468 pe_dll_fill_sections (output_bfd, &link_info);
1469 if (pe_implib_filename)
1470 pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1472 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1473 /* ARM doesn't need relocs. */
1476 pe_exe_fill_sections (output_bfd, &link_info);
1480 if (pe_out_def_filename)
1481 pe_dll_generate_def_file (pe_out_def_filename);
1482 #endif /* DLL_SUPPORT */
1484 /* I don't know where .idata gets set as code, but it shouldn't be. */
1486 asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1490 asec->flags &= ~SEC_CODE;
1491 asec->flags |= SEC_DATA;
1497 /* Find the last output section before given output statement.
1498 Used by place_orphan. */
1501 output_prev_sec_find (os)
1502 lang_output_section_statement_type *os;
1504 asection *s = (asection *) NULL;
1505 lang_statement_union_type *u;
1506 lang_output_section_statement_type *lookup;
1508 for (u = lang_output_section_statement.head;
1509 u != (lang_statement_union_type *) NULL;
1512 lookup = &u->output_section_statement;
1516 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1517 s = lookup->bfd_section;
1523 /* Place an orphan section.
1525 We use this to put sections in a reasonable place in the file, and
1526 to ensure that they are aligned as required.
1528 We handle grouped sections here as well. A section named .foo$nn
1529 goes into the output section .foo. All grouped sections are sorted
1532 Grouped sections for the default sections are handled by the
1533 default linker script using wildcards, and are sorted by
1538 lang_output_section_statement_type *os;
1540 lang_statement_union_type **stmt;
1544 gld_${EMULATION_NAME}_place_orphan (file, s)
1545 lang_input_statement_type *file;
1548 const char *secname;
1549 char *hold_section_name;
1550 char *dollar = NULL;
1551 const char *ps = NULL;
1552 lang_output_section_statement_type *os;
1553 lang_statement_list_type add_child;
1555 secname = bfd_get_section_name (s->owner, s);
1557 /* Look through the script to see where to place this section. */
1558 hold_section_name = xstrdup (secname);
1559 if (!link_info.relocateable)
1561 dollar = strchr (hold_section_name, '$');
1566 os = lang_output_section_find (hold_section_name);
1568 lang_list_init (&add_child);
1571 && (os->bfd_section == NULL
1572 || ((s->flags ^ os->bfd_section->flags)
1573 & (SEC_LOAD | SEC_ALLOC)) == 0))
1575 /* We already have an output section statement with this
1576 name, and its bfd section, if any, has compatible flags. */
1577 lang_add_section (&add_child, s, os, file);
1581 struct orphan_save *place;
1582 static struct orphan_save hold_text;
1583 static struct orphan_save hold_rdata;
1584 static struct orphan_save hold_data;
1585 static struct orphan_save hold_bss;
1587 lang_statement_list_type *old;
1588 lang_statement_list_type add;
1589 etree_type *address;
1591 /* Try to put the new output section in a reasonable place based
1592 on the section name and section flags. */
1593 #define HAVE_SECTION(hold, name) \
1594 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1597 if ((s->flags & SEC_ALLOC) == 0)
1599 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1600 && HAVE_SECTION (hold_bss, ".bss"))
1602 else if ((s->flags & SEC_READONLY) == 0
1603 && HAVE_SECTION (hold_data, ".data"))
1605 else if ((s->flags & SEC_CODE) == 0
1606 && (s->flags & SEC_READONLY) != 0
1607 && HAVE_SECTION (hold_rdata, ".rdata"))
1608 place = &hold_rdata;
1609 else if ((s->flags & SEC_READONLY) != 0
1610 && HAVE_SECTION (hold_text, ".text"))
1615 /* Choose a unique name for the section. This will be needed if
1616 the same section name appears in the input file with
1617 different loadable or allocatable characteristics. */
1618 outsecname = xstrdup (hold_section_name);
1619 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1625 len = strlen (outsecname);
1626 newname = xmalloc (len + 5);
1627 strcpy (newname, outsecname);
1631 sprintf (newname + len, "%d", i);
1634 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1637 outsecname = newname;
1640 /* Start building a list of statements for this section. */
1643 lang_list_init (stat_ptr);
1645 if (config.build_constructors)
1647 /* If the name of the section is representable in C, then create
1648 symbols to mark the start and the end of the section. */
1649 for (ps = outsecname; *ps != '\0'; ps++)
1650 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1655 etree_type *e_align;
1657 symname = (char *) xmalloc (ps - outsecname + sizeof "___start_");
1658 sprintf (symname, "___start_%s", outsecname);
1659 e_align = exp_unop (ALIGN_K,
1660 exp_intop ((bfd_vma) 1 << s->alignment_power));
1661 lang_add_assignment (exp_assop ('=', symname, e_align));
1665 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1666 address = exp_intop ((bfd_vma) 0);
1669 /* All sections in an executable must be aligned to a page
1671 address = exp_unop (ALIGN_K,
1672 exp_nameop (NAME, "__section_alignment__"));
1675 os = lang_enter_output_section_statement (outsecname, address, 0,
1677 (etree_type *) NULL,
1678 (etree_type *) NULL,
1679 (etree_type *) NULL);
1681 lang_add_section (&add_child, s, os, file);
1683 lang_leave_output_section_statement
1684 ((bfd_vma) 0, "*default*",
1685 (struct lang_output_section_phdr_list *) NULL, NULL);
1687 if (config.build_constructors && *ps == '\0')
1691 /* lang_leave_ouput_section_statement resets stat_ptr.
1692 Put stat_ptr back where we want it. */
1696 symname = (char *) xmalloc (ps - outsecname + sizeof "___stop_");
1697 sprintf (symname, "___stop_%s", outsecname);
1698 lang_add_assignment (exp_assop ('=', symname,
1699 exp_nameop (NAME, ".")));
1704 if (place != NULL && os->bfd_section != NULL)
1706 asection *snew, **pps;
1708 snew = os->bfd_section;
1710 /* Shuffle the bfd section list to make the output file look
1711 neater. This is really only cosmetic. */
1712 if (place->section == NULL)
1714 asection *bfd_section = place->os->bfd_section;
1716 /* If the output statement hasn't been used to place
1717 any input sections (and thus doesn't have an output
1718 bfd_section), look for the closest prior output statement
1719 having an output section. */
1720 if (bfd_section == NULL)
1721 bfd_section = output_prev_sec_find (place->os);
1723 if (bfd_section != NULL && bfd_section != snew)
1724 place->section = &bfd_section->next;
1727 if (place->section != NULL)
1729 /* Unlink the section. */
1730 for (pps = &output_bfd->sections;
1732 pps = &(*pps)->next)
1734 bfd_section_list_remove (output_bfd, pps);
1736 /* Now tack it on to the "place->os" section list. */
1737 bfd_section_list_insert (output_bfd, place->section, snew);
1740 /* Save the end of this list. Further ophans of this type will
1741 follow the one we've just added. */
1742 place->section = &snew->next;
1744 /* The following is non-cosmetic. We try to put the output
1745 statements in some sort of reasonable order here, because
1746 they determine the final load addresses of the orphan
1747 sections. In addition, placing output statements in the
1748 wrong order may require extra segments. For instance,
1749 given a typical situation of all read-only sections placed
1750 in one segment and following that a segment containing all
1751 the read-write sections, we wouldn't want to place an orphan
1752 read/write section before or amongst the read-only ones. */
1753 if (add.head != NULL)
1755 if (place->stmt == NULL)
1757 /* Put the new statement list right at the head. */
1758 *add.tail = place->os->header.next;
1759 place->os->header.next = add.head;
1763 /* Put it after the last orphan statement we added. */
1764 *add.tail = *place->stmt;
1765 *place->stmt = add.head;
1768 /* Fix the global list pointer if we happened to tack our
1769 new list at the tail. */
1770 if (*old->tail == add.head)
1771 old->tail = add.tail;
1773 /* Save the end of this list. */
1774 place->stmt = add.tail;
1780 lang_statement_union_type **pl = &os->children.head;
1784 bfd_boolean found_dollar;
1786 /* The section name has a '$'. Sort it with the other '$'
1788 found_dollar = FALSE;
1789 for ( ; *pl != NULL; pl = &(*pl)->header.next)
1791 lang_input_section_type *ls;
1794 if ((*pl)->header.type != lang_input_section_enum)
1797 ls = &(*pl)->input_section;
1799 lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1800 if (strchr (lname, '$') == NULL)
1807 found_dollar = TRUE;
1808 if (strcmp (secname, lname) < 0)
1814 if (add_child.head != NULL)
1816 add_child.head->header.next = *pl;
1817 *pl = add_child.head;
1821 free (hold_section_name);
1827 gld_${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
1828 const char * arch ATTRIBUTE_UNUSED;
1829 search_dirs_type * search;
1830 lang_input_statement_type * entry;
1832 const char * filename;
1835 if (! entry->is_archive)
1838 filename = entry->filename;
1840 string = (char *) xmalloc (strlen (search->name)
1842 + sizeof "/lib.a.dll"
1844 + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1848 /* Try "libfoo.dll.a" first (preferred explicit import library for dll's. */
1849 sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1851 if (! ldfile_try_open_bfd (string, entry))
1853 /* Try "foo.dll.a" next (alternate explicit import library for dll's. */
1854 sprintf (string, "%s/%s.dll.a", search->name, filename);
1855 if (! ldfile_try_open_bfd (string, entry))
1857 /* Try libfoo.a next. Normally, this would be interpreted as a static
1858 library, but it *could* be an import library. For backwards compatibility,
1859 libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1860 or sometimes errors occur when building legacy packages.
1862 Putting libfoo.a here means that in a failure case (i.e. the library
1863 -lfoo is not found) we will search for libfoo.a twice before
1864 giving up -- once here, and once when searching for a "static" lib.
1865 for a "static" lib. */
1866 /* Try "libfoo.a" (import lib, or static lib, but must
1867 take precedence over dll's). */
1868 sprintf (string, "%s/lib%s.a", search->name, filename);
1869 if (! ldfile_try_open_bfd (string, entry))
1872 if (pe_dll_search_prefix)
1874 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */
1875 sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
1876 if (! ldfile_try_open_bfd (string, entry))
1878 /* Try "libfoo.dll" (default preferred dll name). */
1879 sprintf (string, "%s/lib%s.dll", search->name, filename);
1880 if (! ldfile_try_open_bfd (string, entry))
1882 /* Finally, try "foo.dll" (alternate dll name). */
1883 sprintf (string, "%s/%s.dll", search->name, filename);
1884 if (! ldfile_try_open_bfd (string, entry))
1892 else /* pe_dll_search_prefix not specified. */
1895 /* Try "libfoo.dll" (preferred dll name). */
1896 sprintf (string, "%s/lib%s.dll", search->name, filename);
1897 if (! ldfile_try_open_bfd (string, entry))
1899 /* Finally, try "foo.dll" (alternate dll name). */
1900 sprintf (string, "%s/%s.dll", search->name, filename);
1901 if (! ldfile_try_open_bfd (string, entry))
1912 entry->filename = string;
1918 gld_${EMULATION_NAME}_find_potential_libraries (name, entry)
1920 lang_input_statement_type * entry;
1922 return ldfile_open_file_search (name, entry, "", ".lib");
1926 gld_${EMULATION_NAME}_get_script (isfile)
1929 # Scripts compiled in.
1930 # sed commands to quote an ld script as a C string.
1931 sc="-f stringify.sed"
1933 cat >>e${EMULATION_NAME}.c <<EOF
1937 if (link_info.relocateable && config.build_constructors)
1940 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1941 echo ' ; else if (link_info.relocateable) return' >> e${EMULATION_NAME}.c
1942 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1943 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1944 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1945 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1946 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1947 echo ' ; else return' >> e${EMULATION_NAME}.c
1948 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1949 echo '; }' >> e${EMULATION_NAME}.c
1951 cat >>e${EMULATION_NAME}.c <<EOF
1954 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1956 gld_${EMULATION_NAME}_before_parse,
1959 gld_${EMULATION_NAME}_after_parse,
1960 gld_${EMULATION_NAME}_after_open,
1961 after_allocation_default,
1962 set_output_arch_default,
1963 ldemul_default_target,
1964 gld_${EMULATION_NAME}_before_allocation,
1965 gld_${EMULATION_NAME}_get_script,
1966 "${EMULATION_NAME}",
1968 gld_${EMULATION_NAME}_finish,
1969 NULL, /* Create output section statements. */
1970 gld_${EMULATION_NAME}_open_dynamic_archive,
1971 gld_${EMULATION_NAME}_place_orphan,
1972 gld_${EMULATION_NAME}_set_symbols,
1973 NULL, /* parse_args */
1974 gld${EMULATION_NAME}_add_options,
1975 gld${EMULATION_NAME}_handle_option,
1976 gld_${EMULATION_NAME}_unrecognized_file,
1977 gld_${EMULATION_NAME}_list_options,
1978 gld_${EMULATION_NAME}_recognized_file,
1979 gld_${EMULATION_NAME}_find_potential_libraries,
1980 NULL /* new_vers_pattern. */