| blob | f902812b176a325f0e51a6150cb69e6b542b53ae |
1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 test -z "${ENTRY}" && ENTRY="_mainCRTStartup"
4 if [ -z "$MACHINE" ]; then
5 OUTPUT_ARCH=${ARCH}
6 else
7 OUTPUT_ARCH=${ARCH}:${MACHINE}
8 fi
9 rm -f e${EMULATION_NAME}.c
10 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
11 fragment <<EOF
12 /* Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
13 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
15 This file is part of the GNU Binutils.
17 This program is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by
19 the Free Software Foundation; either version 3 of the License, or
20 (at your option) any later version.
22 This program is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details.
27 You should have received a copy of the GNU General Public License
28 along with this program; if not, write to the Free Software
29 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
30 MA 02110-1301, USA. */
33 /* For WINDOWS_NT */
34 /* The original file generated returned different default scripts depending
35 on whether certain switches were set, but these switches pertain to the
36 Linux system and that particular version of coff. In the NT case, we
37 only determine if the subsystem is console or windows in order to select
38 the correct entry point by default. */
40 #define TARGET_IS_${EMULATION_NAME}
42 /* Do this before including bfd.h, so we prototype the right functions. */
44 #if defined(TARGET_IS_armpe) \
45 || defined(TARGET_IS_arm_epoc_pe) \
46 || defined(TARGET_IS_arm_wince_pe)
47 #define bfd_arm_allocate_interworking_sections \
48 bfd_${EMULATION_NAME}_allocate_interworking_sections
49 #define bfd_arm_get_bfd_for_interworking \
50 bfd_${EMULATION_NAME}_get_bfd_for_interworking
51 #define bfd_arm_process_before_allocation \
52 bfd_${EMULATION_NAME}_process_before_allocation
53 #endif
55 #include "sysdep.h"
56 #include "bfd.h"
57 #include "bfdlink.h"
58 #include "getopt.h"
59 #include "libiberty.h"
60 #include "ld.h"
61 #include "ldmain.h"
62 #include "ldexp.h"
63 #include "ldlang.h"
64 #include "ldfile.h"
65 #include "ldemul.h"
66 #include <ldgram.h>
67 #include "ldlex.h"
68 #include "ldmisc.h"
69 #include "ldctor.h"
70 #include "coff/internal.h"
72 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
73 header in generic PE code. */
74 #include "coff/i386.h"
75 #include "coff/pe.h"
77 /* FIXME: This is a BFD internal header file, and we should not be
78 using it here. */
79 #include "../bfd/libcoff.h"
81 #include "deffile.h"
82 #include "pe-dll.h"
83 #include "safe-ctype.h"
85 /* Permit the emulation parameters to override the default section
86 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
87 it seem that include/coff/internal.h should not define
88 PE_DEF_SECTION_ALIGNMENT. */
89 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
90 #undef PE_DEF_SECTION_ALIGNMENT
91 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
92 #endif
94 #if defined(TARGET_IS_i386pe) \
95 || defined(TARGET_IS_shpe) \
96 || defined(TARGET_IS_mipspe) \
97 || defined(TARGET_IS_armpe) \
98 || defined(TARGET_IS_arm_epoc_pe) \
99 || defined(TARGET_IS_arm_wince_pe)
100 #define DLL_SUPPORT
101 #endif
103 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
104 #define PE_DEF_SUBSYSTEM 3
105 #else
106 #undef NT_EXE_IMAGE_BASE
107 #undef PE_DEF_SECTION_ALIGNMENT
108 #undef PE_DEF_FILE_ALIGNMENT
109 #define NT_EXE_IMAGE_BASE 0x00010000
111 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
112 #define PE_DEF_SECTION_ALIGNMENT 0x00001000
113 #define PE_DEF_SUBSYSTEM 9
114 #else
115 #define PE_DEF_SECTION_ALIGNMENT 0x00000400
116 #define PE_DEF_SUBSYSTEM 2
117 #endif
118 #define PE_DEF_FILE_ALIGNMENT 0x00000200
119 #endif
121 #define U(S) ${INITIAL_SYMBOL_CHAR} S
123 static struct internal_extra_pe_aouthdr pe;
124 static int dll;
125 static flagword real_flags = 0;
126 static int support_old_code = 0;
127 static char * thumb_entry_symbol = NULL;
128 static lang_assignment_statement_type *image_base_statement = 0;
130 #ifdef DLL_SUPPORT
131 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable. */
132 static char *pe_out_def_filename = NULL;
133 static char *pe_implib_filename = NULL;
134 static int pe_enable_auto_image_base = 0;
135 static char *pe_dll_search_prefix = NULL;
136 #endif
138 extern const char *output_filename;
140 static void
141 gld_${EMULATION_NAME}_before_parse (void)
142 {
143 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
144 output_filename = "${EXECUTABLE_NAME:-a.exe}";
145 #ifdef DLL_SUPPORT
146 config.dynamic_link = TRUE;
147 config.has_shared = 1;
148 link_info.pei386_auto_import = -1;
149 link_info.pei386_runtime_pseudo_reloc = 1; /* Use by default version 1. */
151 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
152 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe || defined TARGET_IS_arm_wince_pe
153 lang_default_entry ("WinMainCRTStartup");
154 #else
155 lang_default_entry ("_WinMainCRTStartup");
156 #endif
157 #else
158 lang_default_entry ("${ENTRY}");
159 #endif
160 #endif
161 }
162 \f
163 /* PE format extra command line options. */
165 /* Used for setting flags in the PE header. */
166 #define OPTION_BASE_FILE (300 + 1)
167 #define OPTION_DLL (OPTION_BASE_FILE + 1)
168 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
169 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
170 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
171 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
172 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
173 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
174 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
175 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
176 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
177 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
178 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
179 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
180 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
181 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
182 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
183 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
184 #define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
185 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
186 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
187 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
188 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
189 #define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
190 #define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
191 #define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
192 #define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
193 #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
194 #define OPTION_DLL_SEARCH_PREFIX (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
195 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_DLL_SEARCH_PREFIX + 1)
196 #define OPTION_DLL_ENABLE_AUTO_IMPORT (OPTION_NO_DEFAULT_EXCLUDES + 1)
197 #define OPTION_DLL_DISABLE_AUTO_IMPORT (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
198 #define OPTION_ENABLE_EXTRA_PE_DEBUG (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
199 #define OPTION_EXCLUDE_LIBS (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
200 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC \
201 (OPTION_EXCLUDE_LIBS + 1)
202 #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \
203 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
204 #define OPTION_LARGE_ADDRESS_AWARE \
205 (OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC + 1)
206 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1 \
207 (OPTION_LARGE_ADDRESS_AWARE + 1)
208 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2 \
209 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1 + 1)
210 #define OPTION_EXCLUDE_MODULES_FOR_IMPLIB \
211 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2 + 1)
213 static void
214 gld${EMULATION_NAME}_add_options
215 (int ns ATTRIBUTE_UNUSED, char **shortopts ATTRIBUTE_UNUSED, int nl,
216 struct option **longopts, int nrl ATTRIBUTE_UNUSED,
217 struct option **really_longopts ATTRIBUTE_UNUSED)
218 {
219 static const struct option xtra_long[] = {
220 /* PE options */
221 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
222 {"dll", no_argument, NULL, OPTION_DLL},
223 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
224 {"heap", required_argument, NULL, OPTION_HEAP},
225 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
226 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
227 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
228 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
229 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
230 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
231 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
232 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
233 {"stack", required_argument, NULL, OPTION_STACK},
234 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
235 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
236 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
237 #ifdef DLL_SUPPORT
238 /* getopt allows abbreviations, so we do this to stop it from treating -o
239 as an abbreviation for this option */
240 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
241 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
242 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
243 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
244 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
245 {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB},
246 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
247 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
248 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
249 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
250 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
251 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
252 /* getopt() allows abbreviations, so we do this to stop it from
253 treating -c as an abbreviation for these --compat-implib. */
254 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
255 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
256 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
257 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
258 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
259 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
260 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
261 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
262 {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
263 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
264 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
265 {"enable-runtime-pseudo-reloc-v1", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1},
266 {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2},
267 #endif
268 {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE},
269 {NULL, no_argument, NULL, 0}
270 };
272 *longopts = (struct option *)
273 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
274 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
275 }
277 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
278 parameters which may be input from the command line. */
280 typedef struct
281 {
282 void *ptr;
283 int size;
284 int value;
285 char *symbol;
286 int inited;
287 } definfo;
289 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
291 static definfo init[] =
292 {
293 /* imagebase must be first */
294 #define IMAGEBASEOFF 0
295 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
296 #define DLLOFF 1
297 {&dll, sizeof(dll), 0, "__dll__", 0},
298 #define MSIMAGEBASEOFF 2
299 D(ImageBase, U ("__ImageBase"), NT_EXE_IMAGE_BASE),
300 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
301 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
302 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
303 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
304 D(MajorImageVersion,"__major_image_version__", 1),
305 D(MinorImageVersion,"__minor_image_version__", 0),
306 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
307 D(MajorSubsystemVersion,"__major_subsystem_version__", 3),
308 #else
309 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
310 #endif
311 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
312 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
313 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
314 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
315 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
316 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
317 D(LoaderFlags,"__loader_flags__", 0x0),
318 { NULL, 0, 0, NULL, 0 }
319 };
322 static void
323 gld_${EMULATION_NAME}_list_options (FILE *file)
324 {
325 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
326 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
327 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
328 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
329 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
330 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
331 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
332 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
333 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
334 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
335 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
336 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
337 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
338 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
339 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
340 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
341 #ifdef DLL_SUPPORT
342 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
343 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
344 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
345 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
346 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n"));
347 fprintf (file, _(" --exclude-modules-for-implib mod,mod,...\n"));
348 fprintf (file, _(" Exclude objects, archive members from auto\n"));
349 fprintf (file, _(" export, place into import library instead.\n"));
350 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
351 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
352 fprintf (file, _(" --out-implib <file> Generate import library\n"));
353 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
354 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
355 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\
356 create __imp_<SYMBOL> as well.\n"));
357 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\
358 unless user specifies one\n"));
359 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
360 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\
361 an importlib, use <string><basename>.dll\n\
362 in preference to lib<basename>.dll \n"));
363 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to\n\
364 __imp_sym for DATA references\n"));
365 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
366 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\
367 adding pseudo-relocations resolved at\n\
368 runtime.\n"));
369 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\
370 auto-imported DATA.\n"));
371 fprintf (file, _(" --enable-extra-pe-debug Enable verbose debug output when building\n\
372 or linking to DLLs (esp. auto-import)\n"));
373 #endif
374 fprintf (file, _(" --large-address-aware Executable supports virtual addresses\n\
375 greater than 2 gigabytes\n"));
376 }
379 static void
380 set_pe_name (char *name, long val)
381 {
382 int i;
384 /* Find the name and set it. */
385 for (i = 0; init[i].ptr; i++)
386 {
387 if (strcmp (name, init[i].symbol) == 0)
388 {
389 init[i].value = val;
390 init[i].inited = 1;
391 if (strcmp (name,"__image_base__") == 0)
392 set_pe_name (U ("__ImageBase"), val);
393 return;
394 }
395 }
396 abort ();
397 }
400 static void
401 set_pe_subsystem (void)
402 {
403 const char *sver;
404 const char *entry;
405 const char *initial_symbol_char;
406 char *end;
407 int len;
408 int i;
409 int subsystem;
410 unsigned long temp_subsystem;
411 static const struct
412 {
413 const char *name;
414 const int value;
415 const char *entry;
416 }
417 v[] =
418 {
419 { "native", 1, "NtProcessStartup" },
420 { "windows", 2, "WinMainCRTStartup" },
421 { "console", 3, "mainCRTStartup" },
422 { "posix", 7, "__PosixProcessStartup"},
423 { "wince", 9, "WinMainCRTStartup" },
424 { "xbox", 14, "mainCRTStartup" },
425 { NULL, 0, NULL }
426 };
427 /* Entry point name for arbitrary subsystem numbers. */
428 static const char default_entry[] = "mainCRTStartup";
430 /* Check for the presence of a version number. */
431 sver = strchr (optarg, ':');
432 if (sver == NULL)
433 len = strlen (optarg);
434 else
435 {
436 len = sver - optarg;
437 set_pe_name ("__major_subsystem_version__",
438 strtoul (sver + 1, &end, 0));
439 if (*end == '.')
440 set_pe_name ("__minor_subsystem_version__",
441 strtoul (end + 1, &end, 0));
442 if (*end != '\0')
443 einfo (_("%P: warning: bad version number in -subsystem option\n"));
444 }
446 /* Check for numeric subsystem. */
447 temp_subsystem = strtoul (optarg, & end, 0);
448 if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
449 {
450 /* Search list for a numeric match to use its entry point. */
451 for (i = 0; v[i].name; i++)
452 if (v[i].value == (int) temp_subsystem)
453 break;
455 /* If no match, use the default. */
456 if (v[i].name != NULL)
457 entry = v[i].entry;
458 else
459 entry = default_entry;
461 /* Use this subsystem. */
462 subsystem = (int) temp_subsystem;
463 }
464 else
465 {
466 /* Search for subsystem by name. */
467 for (i = 0; v[i].name; i++)
468 if (strncmp (optarg, v[i].name, len) == 0
469 && v[i].name[len] == '\0')
470 break;
472 if (v[i].name == NULL)
473 {
474 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
475 return;
476 }
478 entry = v[i].entry;
479 subsystem = v[i].value;
480 }
482 set_pe_name ("__subsystem__", subsystem);
484 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
485 if (*initial_symbol_char != '\0')
486 {
487 char *alc_entry;
489 /* lang_default_entry expects its argument to be permanently
490 allocated, so we don't free this string. */
491 alc_entry = xmalloc (strlen (initial_symbol_char)
492 + strlen (entry)
493 + 1);
494 strcpy (alc_entry, initial_symbol_char);
495 strcat (alc_entry, entry);
496 entry = alc_entry;
497 }
499 lang_default_entry (entry);
501 return;
502 }
505 static void
506 set_pe_value (char *name)
507 {
508 char *end;
510 set_pe_name (name, strtoul (optarg, &end, 0));
512 if (end == optarg)
513 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
515 optarg = end;
516 }
519 static void
520 set_pe_stack_heap (char *resname, char *comname)
521 {
522 set_pe_value (resname);
524 if (*optarg == ',')
525 {
526 optarg++;
527 set_pe_value (comname);
528 }
529 else if (*optarg)
530 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
531 }
534 static bfd_boolean
535 gld${EMULATION_NAME}_handle_option (int optc)
536 {
537 switch (optc)
538 {
539 default:
540 return FALSE;
542 case OPTION_BASE_FILE:
543 link_info.base_file = fopen (optarg, FOPEN_WB);
544 if (link_info.base_file == NULL)
545 {
546 /* xgettext:c-format */
547 fprintf (stderr, _("%s: Can't open base file %s\n"),
548 program_name, optarg);
549 xexit (1);
550 }
551 break;
553 /* PE options. */
554 case OPTION_HEAP:
555 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
556 break;
557 case OPTION_STACK:
558 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
559 break;
560 case OPTION_SUBSYSTEM:
561 set_pe_subsystem ();
562 break;
563 case OPTION_MAJOR_OS_VERSION:
564 set_pe_value ("__major_os_version__");
565 break;
566 case OPTION_MINOR_OS_VERSION:
567 set_pe_value ("__minor_os_version__");
568 break;
569 case OPTION_MAJOR_SUBSYSTEM_VERSION:
570 set_pe_value ("__major_subsystem_version__");
571 break;
572 case OPTION_MINOR_SUBSYSTEM_VERSION:
573 set_pe_value ("__minor_subsystem_version__");
574 break;
575 case OPTION_MAJOR_IMAGE_VERSION:
576 set_pe_value ("__major_image_version__");
577 break;
578 case OPTION_MINOR_IMAGE_VERSION:
579 set_pe_value ("__minor_image_version__");
580 break;
581 case OPTION_FILE_ALIGNMENT:
582 set_pe_value ("__file_alignment__");
583 break;
584 case OPTION_SECTION_ALIGNMENT:
585 set_pe_value ("__section_alignment__");
586 break;
587 case OPTION_DLL:
588 set_pe_name ("__dll__", 1);
589 break;
590 case OPTION_IMAGE_BASE:
591 set_pe_value ("__image_base__");
592 break;
593 case OPTION_SUPPORT_OLD_CODE:
594 support_old_code = 1;
595 break;
596 case OPTION_THUMB_ENTRY:
597 thumb_entry_symbol = optarg;
598 break;
599 #ifdef DLL_SUPPORT
600 case OPTION_OUT_DEF:
601 pe_out_def_filename = xstrdup (optarg);
602 break;
603 case OPTION_EXPORT_ALL:
604 pe_dll_export_everything = 1;
605 break;
606 case OPTION_EXCLUDE_SYMBOLS:
607 pe_dll_add_excludes (optarg, EXCLUDESYMS);
608 break;
609 case OPTION_EXCLUDE_LIBS:
610 pe_dll_add_excludes (optarg, EXCLUDELIBS);
611 break;
612 case OPTION_EXCLUDE_MODULES_FOR_IMPLIB:
613 pe_dll_add_excludes (optarg, EXCLUDEFORIMPLIB);
614 break;
615 case OPTION_KILL_ATS:
616 pe_dll_kill_ats = 1;
617 break;
618 case OPTION_STDCALL_ALIASES:
619 pe_dll_stdcall_aliases = 1;
620 break;
621 case OPTION_ENABLE_STDCALL_FIXUP:
622 pe_enable_stdcall_fixup = 1;
623 break;
624 case OPTION_DISABLE_STDCALL_FIXUP:
625 pe_enable_stdcall_fixup = 0;
626 break;
627 case OPTION_IMPLIB_FILENAME:
628 pe_implib_filename = xstrdup (optarg);
629 break;
630 case OPTION_WARN_DUPLICATE_EXPORTS:
631 pe_dll_warn_dup_exports = 1;
632 break;
633 case OPTION_IMP_COMPAT:
634 pe_dll_compat_implib = 1;
635 break;
636 case OPTION_ENABLE_AUTO_IMAGE_BASE:
637 pe_enable_auto_image_base = 1;
638 break;
639 case OPTION_DISABLE_AUTO_IMAGE_BASE:
640 pe_enable_auto_image_base = 0;
641 break;
642 case OPTION_DLL_SEARCH_PREFIX:
643 pe_dll_search_prefix = xstrdup (optarg);
644 break;
645 case OPTION_NO_DEFAULT_EXCLUDES:
646 pe_dll_do_default_excludes = 0;
647 break;
648 case OPTION_DLL_ENABLE_AUTO_IMPORT:
649 link_info.pei386_auto_import = 1;
650 break;
651 case OPTION_DLL_DISABLE_AUTO_IMPORT:
652 link_info.pei386_auto_import = 0;
653 break;
654 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
655 link_info.pei386_runtime_pseudo_reloc = 1;
656 break;
657 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1:
658 link_info.pei386_runtime_pseudo_reloc = 1;
659 break;
660 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2:
661 link_info.pei386_runtime_pseudo_reloc = 2;
662 break;
663 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
664 link_info.pei386_runtime_pseudo_reloc = 0;
665 break;
666 case OPTION_ENABLE_EXTRA_PE_DEBUG:
667 pe_dll_extra_pe_debug = 1;
668 break;
669 #endif
670 case OPTION_LARGE_ADDRESS_AWARE:
671 real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
672 break;
673 }
674 return TRUE;
675 }
676 \f
678 #ifdef DLL_SUPPORT
679 static unsigned long
680 strhash (const char *str)
681 {
682 const unsigned char *s;
683 unsigned long hash;
684 unsigned int c;
685 unsigned int len;
687 hash = 0;
688 len = 0;
689 s = (const unsigned char *) str;
690 while ((c = *s++) != '\0')
691 {
692 hash += c + (c << 17);
693 hash ^= hash >> 2;
694 ++len;
695 }
696 hash += len + (len << 17);
697 hash ^= hash >> 2;
699 return hash;
700 }
702 /* Use the output file to create a image base for relocatable DLLs. */
704 static unsigned long
705 compute_dll_image_base (const char *ofile)
706 {
707 unsigned long hash = strhash (ofile);
708 return 0x61300000 + ((hash << 16) & 0x0FFC0000);
709 }
710 #endif
712 /* Assign values to the special symbols before the linker script is
713 read. */
715 static void
716 gld_${EMULATION_NAME}_set_symbols (void)
717 {
718 /* Run through and invent symbols for all the
719 names and insert the defaults. */
720 int j;
721 lang_statement_list_type *save;
723 if (!init[IMAGEBASEOFF].inited)
724 {
725 if (link_info.relocatable)
726 init[IMAGEBASEOFF].value = 0;
727 else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
728 #ifdef DLL_SUPPORT
729 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
730 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
731 #else
732 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
733 #endif
734 else
735 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
736 init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;
737 }
739 /* Don't do any symbol assignments if this is a relocatable link. */
740 if (link_info.relocatable)
741 return;
743 /* Glue the assignments into the abs section. */
744 save = stat_ptr;
746 stat_ptr = &(abs_output_section->children);
748 for (j = 0; init[j].ptr; j++)
749 {
750 long val = init[j].value;
751 lang_assignment_statement_type *rv;
752 rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
753 exp_intop (val)));
754 if (init[j].size == sizeof (short))
755 *(short *) init[j].ptr = val;
756 else if (init[j].size == sizeof (int))
757 *(int *) init[j].ptr = val;
758 else if (init[j].size == sizeof (long))
759 *(long *) init[j].ptr = val;
760 /* This might be a long long or other special type. */
761 else if (init[j].size == sizeof (bfd_vma))
762 *(bfd_vma *) init[j].ptr = val;
763 else abort ();
764 if (j == IMAGEBASEOFF)
765 image_base_statement = rv;
766 }
767 /* Restore the pointer. */
768 stat_ptr = save;
770 if (pe.FileAlignment >
771 pe.SectionAlignment)
772 {
773 einfo (_("%P: warning, file alignment > section alignment.\n"));
774 }
775 }
777 /* This is called after the linker script and the command line options
778 have been read. */
780 static void
781 gld_${EMULATION_NAME}_after_parse (void)
782 {
783 /* The Windows libraries are designed for the linker to treat the
784 entry point as an undefined symbol. Otherwise, the .obj that
785 defines mainCRTStartup is brought in because it is the first
786 encountered in libc.lib and it has other symbols in it which will
787 be pulled in by the link process. To avoid this, we act as
788 though the user specified -u with the entry point symbol.
790 This function is called after the linker script and command line
791 options have been read, so at this point we know the right entry
792 point. This function is called before the input files are
793 opened, so registering the symbol as undefined will make a
794 difference. */
796 if (! link_info.relocatable && entry_symbol.name != NULL)
797 ldlang_add_undef (entry_symbol.name);
798 }
800 /* pe-dll.c directly accesses pe_data_import_dll,
801 so it must be defined outside of #ifdef DLL_SUPPORT.
802 Note - this variable is deliberately not initialised.
803 This allows it to be treated as a common varaible, and only
804 exist in one incarnation in a multiple target enabled linker. */
805 char * pe_data_import_dll;
807 #ifdef DLL_SUPPORT
808 static struct bfd_link_hash_entry *pe_undef_found_sym;
810 static bfd_boolean
811 pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
812 {
813 int sl;
814 char *string = inf;
816 sl = strlen (string);
817 if (h->type == bfd_link_hash_defined
818 && strncmp (h->root.string, string, sl) == 0
819 && h->root.string[sl] == '@')
820 {
821 pe_undef_found_sym = h;
822 return FALSE;
823 }
824 return TRUE;
825 }
827 static void
828 pe_fixup_stdcalls (void)
829 {
830 static int gave_warning_message = 0;
831 struct bfd_link_hash_entry *undef, *sym;
833 if (pe_dll_extra_pe_debug)
834 printf ("%s\n", __FUNCTION__);
836 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
837 if (undef->type == bfd_link_hash_undefined)
838 {
839 char* at = strchr (undef->root.string, '@');
840 int lead_at = (*undef->root.string == '@');
841 /* For now, don't try to fixup fastcall symbols. */
843 if (at && !lead_at)
844 {
845 /* The symbol is a stdcall symbol, so let's look for a
846 cdecl symbol with the same name and resolve to that. */
847 char *cname = xstrdup (undef->root.string /* + lead_at */);
848 at = strchr (cname, '@');
849 *at = 0;
850 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
852 if (sym && sym->type == bfd_link_hash_defined)
853 {
854 undef->type = bfd_link_hash_defined;
855 undef->u.def.value = sym->u.def.value;
856 undef->u.def.section = sym->u.def.section;
858 if (pe_enable_stdcall_fixup == -1)
859 {
860 einfo (_("Warning: resolving %s by linking to %s\n"),
861 undef->root.string, cname);
862 if (! gave_warning_message)
863 {
864 gave_warning_message = 1;
865 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
866 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
867 }
868 }
869 }
870 }
871 else
872 {
873 /* The symbol is a cdecl symbol, so we look for stdcall
874 symbols - which means scanning the whole symbol table. */
875 pe_undef_found_sym = 0;
876 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
877 (char *) undef->root.string);
878 sym = pe_undef_found_sym;
879 if (sym)
880 {
881 undef->type = bfd_link_hash_defined;
882 undef->u.def.value = sym->u.def.value;
883 undef->u.def.section = sym->u.def.section;
885 if (pe_enable_stdcall_fixup == -1)
886 {
887 einfo (_("Warning: resolving %s by linking to %s\n"),
888 undef->root.string, sym->root.string);
889 if (! gave_warning_message)
890 {
891 gave_warning_message = 1;
892 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
893 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
894 }
895 }
896 }
897 }
898 }
899 }
901 static int
902 make_import_fixup (arelent *rel, asection *s)
903 {
904 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
905 char addend[4];
907 if (pe_dll_extra_pe_debug)
908 printf ("arelent: %s@%#lx: add=%li\n", sym->name,
909 (unsigned long) rel->address, (long) rel->addend);
911 if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
912 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
913 s->owner, s, rel->address);
915 pe_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));
917 return 1;
918 }
920 static void
921 pe_find_data_imports (void)
922 {
923 struct bfd_link_hash_entry *undef, *sym;
925 if (link_info.pei386_auto_import == 0)
926 return;
928 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
929 {
930 if (undef->type == bfd_link_hash_undefined)
931 {
932 /* C++ symbols are *long*. */
933 char buf[4096];
935 if (pe_dll_extra_pe_debug)
936 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
938 sprintf (buf, "__imp_%s", undef->root.string);
940 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
942 if (sym && sym->type == bfd_link_hash_defined)
943 {
944 bfd *b = sym->u.def.section->owner;
945 asymbol **symbols;
946 int nsyms, i;
948 if (link_info.pei386_auto_import == -1)
949 {
950 static bfd_boolean warned = FALSE;
952 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
953 undef->root.string, buf);
955 /* PR linker/4844. */
956 if (! warned)
957 {
958 warned = TRUE;
959 einfo (_("%P: warning: auto-importing has been activated without --enable-auto-import specified on the command line.\n\
960 This should work unless it involves constant data structures referencing symbols from auto-imported DLLs.\n"));
961 }
962 }
964 if (!bfd_generic_link_read_symbols (b))
965 {
966 einfo (_("%B%F: could not read symbols: %E\n"), b);
967 return;
968 }
970 symbols = bfd_get_outsymbols (b);
971 nsyms = bfd_get_symcount (b);
973 for (i = 0; i < nsyms; i++)
974 {
975 if (! CONST_STRNEQ (symbols[i]->name, U ("_head_")))
976 continue;
978 if (pe_dll_extra_pe_debug)
979 printf ("->%s\n", symbols[i]->name);
981 pe_data_import_dll = (char*) (symbols[i]->name +
982 sizeof (U ("_head_")) - 1);
983 break;
984 }
986 pe_walk_relocs_of_symbol (&link_info, undef->root.string,
987 make_import_fixup);
989 /* Let's differentiate it somehow from defined. */
990 undef->type = bfd_link_hash_defweak;
991 /* We replace original name with __imp_ prefixed, this
992 1) may trash memory 2) leads to duplicate symbol generation.
993 Still, IMHO it's better than having name poluted. */
994 undef->root.string = sym->root.string;
995 undef->u.def.value = sym->u.def.value;
996 undef->u.def.section = sym->u.def.section;
997 }
998 }
999 }
1000 }
1002 static bfd_boolean
1003 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
1004 {
1005 if (pe_dll_extra_pe_debug)
1006 printf ("+%s\n", h->string);
1008 return TRUE;
1009 }
1010 #endif /* DLL_SUPPORT */
1013 static void
1014 gld_${EMULATION_NAME}_after_open (void)
1015 {
1016 #ifdef DLL_SUPPORT
1017 if (pe_dll_extra_pe_debug)
1018 {
1019 bfd *a;
1020 struct bfd_link_hash_entry *sym;
1022 printf ("%s()\n", __FUNCTION__);
1024 for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
1025 printf ("-%s\n", sym->root.string);
1026 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
1028 for (a = link_info.input_bfds; a; a = a->link_next)
1029 printf ("*%s\n",a->filename);
1030 }
1031 #endif
1033 /* Pass the wacky PE command line options into the output bfd.
1034 FIXME: This should be done via a function, rather than by
1035 including an internal BFD header. */
1037 if (coff_data (link_info.output_bfd) == NULL
1038 || coff_data (link_info.output_bfd)->pe == 0)
1039 einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"),
1040 link_info.output_bfd);
1042 pe_data (link_info.output_bfd)->pe_opthdr = pe;
1043 pe_data (link_info.output_bfd)->dll = init[DLLOFF].value;
1044 pe_data (link_info.output_bfd)->real_flags |= real_flags;
1046 #ifdef DLL_SUPPORT
1047 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
1048 pe_fixup_stdcalls ();
1050 pe_process_import_defs (link_info.output_bfd, &link_info);
1052 pe_find_data_imports ();
1054 #if defined (TARGET_IS_i386pe) \
1055 || defined (TARGET_IS_armpe) \
1056 || defined (TARGET_IS_arm_epoc_pe) \
1057 || defined (TARGET_IS_arm_wince_pe)
1058 if (!link_info.relocatable)
1059 pe_dll_build_sections (link_info.output_bfd, &link_info);
1060 else
1061 pe_exe_build_sections (link_info.output_bfd, &link_info);
1062 #else
1063 if (link_info.shared)
1064 pe_dll_build_sections (link_info.output_bfd, &link_info);
1065 #endif
1066 #endif /* DLL_SUPPORT */
1068 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1069 if (strstr (bfd_get_target (link_info.output_bfd), "arm") == NULL)
1070 {
1071 /* The arm backend needs special fields in the output hash structure.
1072 These will only be created if the output format is an arm format,
1073 hence we do not support linking and changing output formats at the
1074 same time. Use a link followed by objcopy to change output formats. */
1075 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1076 return;
1077 }
1078 {
1079 /* Find a BFD that can hold the interworking stubs. */
1080 LANG_FOR_EACH_INPUT_STATEMENT (is)
1081 {
1082 if (bfd_arm_get_bfd_for_interworking (is->the_bfd, & link_info))
1083 break;
1084 }
1085 }
1086 #endif
1088 {
1089 /* This next chunk of code tries to detect the case where you have
1090 two import libraries for the same DLL (specifically,
1091 symbolically linking libm.a and libc.a in cygwin to
1092 libcygwin.a). In those cases, it's possible for function
1093 thunks from the second implib to be used but without the
1094 head/tail objects, causing an improper import table. We detect
1095 those cases and rename the "other" import libraries to match
1096 the one the head/tail come from, so that the linker will sort
1097 things nicely and produce a valid import table. */
1099 LANG_FOR_EACH_INPUT_STATEMENT (is)
1100 {
1101 if (is->the_bfd->my_archive)
1102 {
1103 int idata2 = 0, reloc_count=0, is_imp = 0;
1104 asection *sec;
1106 /* See if this is an import library thunk. */
1107 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1108 {
1109 if (strcmp (sec->name, ".idata\$2") == 0)
1110 idata2 = 1;
1111 if (CONST_STRNEQ (sec->name, ".idata\$"))
1112 is_imp = 1;
1113 reloc_count += sec->reloc_count;
1114 }
1116 if (is_imp && !idata2 && reloc_count)
1117 {
1118 /* It is, look for the reference to head and see if it's
1119 from our own library. */
1120 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1121 {
1122 int i;
1123 long relsize;
1124 asymbol **symbols;
1125 arelent **relocs;
1126 int nrelocs;
1128 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1129 if (relsize < 1)
1130 break;
1132 if (!bfd_generic_link_read_symbols (is->the_bfd))
1133 {
1134 einfo (_("%B%F: could not read symbols: %E\n"),
1135 is->the_bfd);
1136 return;
1137 }
1138 symbols = bfd_get_outsymbols (is->the_bfd);
1140 relocs = (arelent **) xmalloc ((size_t) relsize);
1141 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1142 relocs, symbols);
1143 if (nrelocs < 0)
1144 {
1145 free (relocs);
1146 einfo ("%X%P: unable to process relocs: %E\n");
1147 return;
1148 }
1150 for (i = 0; i < nrelocs; i++)
1151 {
1152 struct bfd_symbol *s;
1153 struct bfd_link_hash_entry * blhe;
1154 char *other_bfd_filename;
1155 char *n;
1157 s = (relocs[i]->sym_ptr_ptr)[0];
1159 if (s->flags & BSF_LOCAL)
1160 continue;
1162 /* Thunk section with reloc to another bfd. */
1163 blhe = bfd_link_hash_lookup (link_info.hash,
1164 s->name,
1165 FALSE, FALSE, TRUE);
1167 if (blhe == NULL
1168 || blhe->type != bfd_link_hash_defined)
1169 continue;
1171 other_bfd_filename
1172 = blhe->u.def.section->owner->my_archive
1173 ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1174 : bfd_get_filename (blhe->u.def.section->owner);
1176 if (strcmp (bfd_get_filename (is->the_bfd->my_archive),
1177 other_bfd_filename) == 0)
1178 continue;
1180 /* Rename this implib to match the other one. */
1181 n = xmalloc (strlen (other_bfd_filename) + 1);
1182 strcpy (n, other_bfd_filename);
1183 is->the_bfd->my_archive->filename = n;
1184 }
1186 free (relocs);
1187 /* Note - we do not free the symbols,
1188 they are now cached in the BFD. */
1189 }
1190 }
1191 }
1192 }
1193 }
1195 {
1196 int is_ms_arch = 0;
1197 bfd *cur_arch = 0;
1198 lang_input_statement_type *is2;
1199 lang_input_statement_type *is3;
1201 /* Careful - this is a shell script. Watch those dollar signs! */
1202 /* Microsoft import libraries have every member named the same,
1203 and not in the right order for us to link them correctly. We
1204 must detect these and rename the members so that they'll link
1205 correctly. There are three types of objects: the head, the
1206 thunks, and the sentinel(s). The head is easy; it's the one
1207 with idata2. We assume that the sentinels won't have relocs,
1208 and the thunks will. It's easier than checking the symbol
1209 table for external references. */
1210 LANG_FOR_EACH_INPUT_STATEMENT (is)
1211 {
1212 if (is->the_bfd->my_archive)
1213 {
1214 char *pnt;
1215 bfd *arch = is->the_bfd->my_archive;
1217 if (cur_arch != arch)
1218 {
1219 cur_arch = arch;
1220 is_ms_arch = 1;
1222 for (is3 = is;
1223 is3 && is3->the_bfd->my_archive == arch;
1224 is3 = (lang_input_statement_type *) is3->next)
1225 {
1226 /* A MS dynamic import library can also contain static
1227 members, so look for the first element with a .dll
1228 extension, and use that for the remainder of the
1229 comparisons. */
1230 pnt = strrchr (is3->the_bfd->filename, '.');
1231 if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1232 break;
1233 }
1235 if (is3 == NULL)
1236 is_ms_arch = 0;
1237 else
1238 {
1239 /* OK, found one. Now look to see if the remaining
1240 (dynamic import) members use the same name. */
1241 for (is2 = is;
1242 is2 && is2->the_bfd->my_archive == arch;
1243 is2 = (lang_input_statement_type *) is2->next)
1244 {
1245 /* Skip static members, ie anything with a .obj
1246 extension. */
1247 pnt = strrchr (is2->the_bfd->filename, '.');
1248 if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1249 continue;
1251 if (strcmp (is3->the_bfd->filename,
1252 is2->the_bfd->filename))
1253 {
1254 is_ms_arch = 0;
1255 break;
1256 }
1257 }
1258 }
1259 }
1261 /* This fragment might have come from an .obj file in a Microsoft
1262 import, and not an actual import record. If this is the case,
1263 then leave the filename alone. */
1264 pnt = strrchr (is->the_bfd->filename, '.');
1266 if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1267 {
1268 int idata2 = 0, reloc_count=0;
1269 asection *sec;
1270 char *new_name, seq;
1272 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1273 {
1274 if (strcmp (sec->name, ".idata\$2") == 0)
1275 idata2 = 1;
1276 reloc_count += sec->reloc_count;
1277 }
1279 if (idata2) /* .idata2 is the TOC */
1280 seq = 'a';
1281 else if (reloc_count > 0) /* thunks */
1282 seq = 'b';
1283 else /* sentinel */
1284 seq = 'c';
1286 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1287 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1288 is->the_bfd->filename = new_name;
1290 new_name = xmalloc (strlen (is->filename) + 3);
1291 sprintf (new_name, "%s.%c", is->filename, seq);
1292 is->filename = new_name;
1293 }
1294 }
1295 }
1296 }
1298 {
1299 /* The following chunk of code tries to identify jump stubs in
1300 import libraries which are dead code and eliminates them
1301 from the final link. For each exported symbol <sym>, there
1302 is a object file in the import library with a .text section
1303 and several .idata$* sections. The .text section contains the
1304 symbol definition for <sym> which is a jump stub of the form
1305 jmp *__imp_<sym>. The .idata$5 contains the symbol definition
1306 for __imp_<sym> which is the address of the slot for <sym> in
1307 the import address table. When a symbol is imported explicitly
1308 using __declspec(dllimport) declaration, the compiler generates
1309 a reference to __imp_<sym> which directly resolves to the
1310 symbol in .idata$5, in which case the jump stub code is not
1311 needed. The following code tries to identify jump stub sections
1312 in import libraries which are not referred to by anyone and
1313 marks them for exclusion from the final link. */
1314 LANG_FOR_EACH_INPUT_STATEMENT (is)
1315 {
1316 if (is->the_bfd->my_archive)
1317 {
1318 int is_imp = 0;
1319 asection *sec, *stub_sec = NULL;
1321 /* See if this is an import library thunk. */
1322 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1323 {
1324 if (strncmp (sec->name, ".idata\$", 7) == 0)
1325 is_imp = 1;
1326 /* The section containing the jmp stub has code
1327 and has a reloc. */
1328 if ((sec->flags & SEC_CODE) && sec->reloc_count)
1329 stub_sec = sec;
1330 }
1332 if (is_imp && stub_sec)
1333 {
1334 asymbol **symbols;
1335 long nsyms, src_count;
1336 struct bfd_link_hash_entry * blhe;
1338 if (!bfd_generic_link_read_symbols (is->the_bfd))
1339 {
1340 einfo (_("%B%F: could not read symbols: %E\n"),
1341 is->the_bfd);
1342 return;
1343 }
1344 symbols = bfd_get_outsymbols (is->the_bfd);
1345 nsyms = bfd_get_symcount (is->the_bfd);
1347 for (src_count = 0; src_count < nsyms; src_count++)
1348 {
1349 if (symbols[src_count]->section->id == stub_sec->id)
1350 {
1351 /* This symbol belongs to the section containing
1352 the stub. */
1353 blhe = bfd_link_hash_lookup (link_info.hash,
1354 symbols[src_count]->name,
1355 FALSE, FALSE, TRUE);
1356 /* If the symbol in the stub section has no other
1357 undefined references, exclude the stub section
1358 from the final link. */
1359 if (blhe && (blhe->type == bfd_link_hash_defined)
1360 && (blhe->u.undef.next == NULL))
1361 stub_sec->flags |= SEC_EXCLUDE;
1362 }
1363 }
1364 }
1365 }
1366 }
1367 }
1368 }
1369 \f
1370 static void
1371 gld_${EMULATION_NAME}_before_allocation (void)
1372 {
1373 #ifdef TARGET_IS_ppcpe
1374 /* Here we rummage through the found bfds to collect toc information. */
1375 {
1376 LANG_FOR_EACH_INPUT_STATEMENT (is)
1377 {
1378 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1379 {
1380 /* xgettext:c-format */
1381 einfo (_("Errors encountered processing file %s\n"), is->filename);
1382 }
1383 }
1384 }
1386 /* We have seen it all. Allocate it, and carry on. */
1387 ppc_allocate_toc_section (&link_info);
1388 #endif /* TARGET_IS_ppcpe */
1390 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1391 /* FIXME: we should be able to set the size of the interworking stub
1392 section.
1394 Here we rummage through the found bfds to collect glue
1395 information. FIXME: should this be based on a command line
1396 option? krk@cygnus.com. */
1397 {
1398 LANG_FOR_EACH_INPUT_STATEMENT (is)
1399 {
1400 if (! bfd_arm_process_before_allocation
1401 (is->the_bfd, & link_info, support_old_code))
1402 {
1403 /* xgettext:c-format */
1404 einfo (_("Errors encountered processing file %s for interworking\n"),
1405 is->filename);
1406 }
1407 }
1408 }
1410 /* We have seen it all. Allocate it, and carry on. */
1411 bfd_arm_allocate_interworking_sections (& link_info);
1412 #endif /* TARGET_IS_armpe || TARGET_IS_arm_epoc_pe || TARGET_IS_arm_wince_pe */
1414 before_allocation_default ();
1415 }
1416 \f
1417 #ifdef DLL_SUPPORT
1418 /* This is called when an input file isn't recognized as a BFD. We
1419 check here for .DEF files and pull them in automatically. */
1421 static int
1422 saw_option (char *option)
1423 {
1424 int i;
1426 for (i = 0; init[i].ptr; i++)
1427 if (strcmp (init[i].symbol, option) == 0)
1428 return init[i].inited;
1429 return 0;
1430 }
1431 #endif /* DLL_SUPPORT */
1433 static bfd_boolean
1434 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1435 {
1436 #ifdef DLL_SUPPORT
1437 const char *ext = entry->filename + strlen (entry->filename) - 4;
1439 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1440 {
1441 pe_def_file = def_file_parse (entry->filename, pe_def_file);
1443 if (pe_def_file)
1444 {
1445 int i, buflen=0, len;
1446 char *buf;
1448 for (i = 0; i < pe_def_file->num_exports; i++)
1449 {
1450 len = strlen (pe_def_file->exports[i].internal_name);
1451 if (buflen < len + 2)
1452 buflen = len + 2;
1453 }
1455 buf = (char *) xmalloc (buflen);
1457 for (i = 0; i < pe_def_file->num_exports; i++)
1458 {
1459 struct bfd_link_hash_entry *h;
1461 sprintf (buf, "%s%s", U (""), pe_def_file->exports[i].internal_name);
1463 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1464 if (h == (struct bfd_link_hash_entry *) NULL)
1465 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1466 if (h->type == bfd_link_hash_new)
1467 {
1468 h->type = bfd_link_hash_undefined;
1469 h->u.undef.abfd = NULL;
1470 bfd_link_add_undef (link_info.hash, h);
1471 }
1472 }
1473 free (buf);
1475 /* def_file_print (stdout, pe_def_file); */
1476 if (pe_def_file->is_dll == 1)
1477 link_info.shared = 1;
1479 if (pe_def_file->base_address != (bfd_vma)(-1))
1480 {
1481 pe.ImageBase
1482 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase
1483 = init[IMAGEBASEOFF].value
1484 = pe_def_file->base_address;
1485 init[IMAGEBASEOFF].inited = 1;
1486 if (image_base_statement)
1487 image_base_statement->exp = exp_assop ('=', "__image_base__",
1488 exp_intop (pe.ImageBase));
1489 }
1491 if (pe_def_file->stack_reserve != -1
1492 && ! saw_option ("__size_of_stack_reserve__"))
1493 {
1494 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1495 if (pe_def_file->stack_commit != -1)
1496 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1497 }
1498 if (pe_def_file->heap_reserve != -1
1499 && ! saw_option ("__size_of_heap_reserve__"))
1500 {
1501 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1502 if (pe_def_file->heap_commit != -1)
1503 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1504 }
1505 return TRUE;
1506 }
1507 }
1508 #endif
1509 return FALSE;
1510 }
1512 static bfd_boolean
1513 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1514 {
1515 #ifdef DLL_SUPPORT
1516 #ifdef TARGET_IS_i386pe
1517 pe_dll_id_target ("pei-i386");
1518 #endif
1519 #ifdef TARGET_IS_shpe
1520 pe_dll_id_target ("pei-shl");
1521 #endif
1522 #ifdef TARGET_IS_mipspe
1523 pe_dll_id_target ("pei-mips");
1524 #endif
1525 #ifdef TARGET_IS_armpe
1526 pe_dll_id_target ("pei-arm-little");
1527 #endif
1528 #ifdef TARGET_IS_arm_epoc_pe
1529 pe_dll_id_target ("epoc-pei-arm-little");
1530 #endif
1531 #ifdef TARGET_IS_arm_wince_pe
1532 pe_dll_id_target ("pei-arm-wince-little");
1533 #endif
1534 if (pe_bfd_is_dll (entry->the_bfd))
1535 return pe_implied_import_dll (entry->filename);
1536 #endif
1537 return FALSE;
1538 }
1540 static void
1541 gld_${EMULATION_NAME}_finish (void)
1542 {
1543 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1544 struct bfd_link_hash_entry * h;
1546 if (thumb_entry_symbol != NULL)
1547 {
1548 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1549 FALSE, FALSE, TRUE);
1551 if (h != (struct bfd_link_hash_entry *) NULL
1552 && (h->type == bfd_link_hash_defined
1553 || h->type == bfd_link_hash_defweak)
1554 && h->u.def.section->output_section != NULL)
1555 {
1556 static char buffer[32];
1557 bfd_vma val;
1559 /* Special procesing is required for a Thumb entry symbol. The
1560 bottom bit of its address must be set. */
1561 val = (h->u.def.value
1562 + bfd_get_section_vma (link_info.output_bfd,
1563 h->u.def.section->output_section)
1564 + h->u.def.section->output_offset);
1566 val |= 1;
1568 /* Now convert this value into a string and store it in entry_symbol
1569 where the lang_finish() function will pick it up. */
1570 buffer[0] = '0';
1571 buffer[1] = 'x';
1573 sprintf_vma (buffer + 2, val);
1575 if (entry_symbol.name != NULL && entry_from_cmdline)
1576 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1577 thumb_entry_symbol, entry_symbol.name);
1578 entry_symbol.name = buffer;
1579 }
1580 else
1581 einfo (_("%P: warning: cannot find thumb start symbol %s\n"), thumb_entry_symbol);
1582 }
1583 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe) */
1585 finish_default ();
1587 #ifdef DLL_SUPPORT
1588 if (link_info.shared
1589 #if !defined(TARGET_IS_shpe) && !defined(TARGET_IS_mipspe)
1590 || (!link_info.relocatable && pe_def_file->num_exports != 0)
1591 #endif
1592 )
1593 {
1594 pe_dll_fill_sections (link_info.output_bfd, &link_info);
1595 if (pe_implib_filename)
1596 pe_dll_generate_implib (pe_def_file, pe_implib_filename, &link_info);
1597 }
1598 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1599 /* ARM doesn't need relocs. */
1600 else
1601 {
1602 pe_exe_fill_sections (link_info.output_bfd, &link_info);
1603 }
1604 #endif
1606 if (pe_out_def_filename)
1607 pe_dll_generate_def_file (pe_out_def_filename);
1608 #endif /* DLL_SUPPORT */
1610 /* I don't know where .idata gets set as code, but it shouldn't be. */
1611 {
1612 asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata");
1614 if (asec)
1615 {
1616 asec->flags &= ~SEC_CODE;
1617 asec->flags |= SEC_DATA;
1618 }
1619 }
1620 }
1622 \f
1623 /* Place an orphan section.
1625 We use this to put sections in a reasonable place in the file, and
1626 to ensure that they are aligned as required.
1628 We handle grouped sections here as well. A section named .foo$nn
1629 goes into the output section .foo. All grouped sections are sorted
1630 by name.
1632 Grouped sections for the default sections are handled by the
1633 default linker script using wildcards, and are sorted by
1634 sort_sections. */
1636 static lang_output_section_statement_type *
1637 gld_${EMULATION_NAME}_place_orphan (asection *s,
1638 const char *secname,
1639 int constraint)
1640 {
1641 const char *orig_secname = secname;
1642 char *dollar = NULL;
1643 lang_output_section_statement_type *os;
1644 lang_statement_list_type add_child;
1646 /* Look through the script to see where to place this section. */
1647 if (!link_info.relocatable
1648 && (dollar = strchr (secname, '$')) != NULL)
1649 {
1650 size_t len = dollar - secname;
1651 char *newname = xmalloc (len + 1);
1652 memcpy (newname, secname, len);
1653 newname[len] = '\0';
1654 secname = newname;
1655 }
1657 lang_list_init (&add_child);
1659 if (constraint == 0
1660 && (os = lang_output_section_find (secname)) != NULL
1661 && os->bfd_section != NULL
1662 && (os->bfd_section->flags == 0
1663 || ((s->flags ^ os->bfd_section->flags)
1664 & (SEC_LOAD | SEC_ALLOC)) == 0))
1665 {
1666 /* We already have an output section statement with this
1667 name, and its bfd section has compatible flags.
1668 If the section already exists but does not have any flags set,
1669 then it has been created by the linker, probably as a result of
1670 a --section-start command line switch. */
1671 lang_add_section (&add_child, s, os);
1672 }
1673 else
1674 {
1675 static struct orphan_save hold[] =
1676 {
1677 { ".text",
1678 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1679 0, 0, 0, 0 },
1680 { ".rdata",
1681 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1682 0, 0, 0, 0 },
1683 { ".data",
1684 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1685 0, 0, 0, 0 },
1686 { ".bss",
1687 SEC_ALLOC,
1688 0, 0, 0, 0 }
1689 };
1690 enum orphan_save_index
1691 {
1692 orphan_text = 0,
1693 orphan_rodata,
1694 orphan_data,
1695 orphan_bss
1696 };
1697 static int orphan_init_done = 0;
1698 struct orphan_save *place;
1699 lang_output_section_statement_type *after;
1700 etree_type *address;
1702 if (!orphan_init_done)
1703 {
1704 struct orphan_save *ho;
1705 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1706 if (ho->name != NULL)
1707 {
1708 ho->os = lang_output_section_find (ho->name);
1709 if (ho->os != NULL && ho->os->flags == 0)
1710 ho->os->flags = ho->flags;
1711 }
1712 orphan_init_done = 1;
1713 }
1715 /* Try to put the new output section in a reasonable place based
1716 on the section name and section flags. */
1718 place = NULL;
1719 if ((s->flags & SEC_ALLOC) == 0)
1720 ;
1721 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1722 place = &hold[orphan_bss];
1723 else if ((s->flags & SEC_READONLY) == 0)
1724 place = &hold[orphan_data];
1725 else if ((s->flags & SEC_CODE) == 0)
1726 place = &hold[orphan_rodata];
1727 else
1728 place = &hold[orphan_text];
1730 after = NULL;
1731 if (place != NULL)
1732 {
1733 if (place->os == NULL)
1734 place->os = lang_output_section_find (place->name);
1735 after = place->os;
1736 if (after == NULL)
1737 after = lang_output_section_find_by_flags (s, &place->os, NULL);
1738 if (after == NULL)
1739 /* *ABS* is always the first output section statement. */
1740 after = (&lang_output_section_statement.head
1741 ->output_section_statement);
1742 }
1744 /* All sections in an executable must be aligned to a page boundary. */
1745 address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
1746 os = lang_insert_orphan (s, secname, constraint, after, place, address,
1747 &add_child);
1748 }
1750 {
1751 lang_statement_union_type **pl = &os->children.head;
1753 if (dollar != NULL)
1754 {
1755 bfd_boolean found_dollar;
1757 /* The section name has a '$'. Sort it with the other '$'
1758 sections. */
1759 found_dollar = FALSE;
1760 for ( ; *pl != NULL; pl = &(*pl)->header.next)
1761 {
1762 lang_input_section_type *ls;
1763 const char *lname;
1765 if ((*pl)->header.type != lang_input_section_enum)
1766 continue;
1768 ls = &(*pl)->input_section;
1770 lname = bfd_get_section_name (ls->section->owner, ls->section);
1771 if (strchr (lname, '$') == NULL)
1772 {
1773 if (found_dollar)
1774 break;
1775 }
1776 else
1777 {
1778 found_dollar = TRUE;
1779 if (strcmp (orig_secname, lname) < 0)
1780 break;
1781 }
1782 }
1783 }
1785 if (add_child.head != NULL)
1786 {
1787 add_child.head->header.next = *pl;
1788 *pl = add_child.head;
1789 }
1790 }
1792 return os;
1793 }
1795 static bfd_boolean
1796 gld_${EMULATION_NAME}_open_dynamic_archive
1797 (const char *arch ATTRIBUTE_UNUSED, search_dirs_type *search,
1798 lang_input_statement_type *entry)
1799 {
1800 static const struct
1801 {
1802 const char * format;
1803 bfd_boolean use_prefix;
1804 }
1805 libname_fmt [] =
1806 {
1807 /* Preferred explicit import library for dll's. */
1808 { "lib%s.dll.a", FALSE },
1809 /* Alternate explicit import library for dll's. */
1810 { "%s.dll.a", FALSE },
1811 /* "libfoo.a" could be either an import lib or a static lib.
1812 For backwards compatibility, libfoo.a needs to precede
1813 libfoo.dll and foo.dll in the search. */
1814 { "lib%s.a", FALSE },
1815 /* The 'native' spelling of an import lib name is "foo.lib". */
1816 { "%s.lib", FALSE },
1817 #ifdef DLL_SUPPORT
1818 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */
1819 { "%s%s.dll", TRUE },
1820 #endif
1821 /* Try "libfoo.dll" (default preferred dll name). */
1822 { "lib%s.dll", FALSE },
1823 /* Finally try 'native' dll name "foo.dll". */
1824 { "%s.dll", FALSE },
1825 /* Note: If adding more formats to this table, make sure to check to
1826 see if their length is longer than libname_fmt[0].format, and if
1827 so, update the call to xmalloc() below. */
1828 { NULL, FALSE }
1829 };
1830 static unsigned int format_max_len = 0;
1831 const char * filename;
1832 char * full_string;
1833 char * base_string;
1834 unsigned int i;
1837 if (! entry->is_archive)
1838 return FALSE;
1840 filename = entry->filename;
1842 if (format_max_len == 0)
1843 /* We need to allow space in the memory that we are going to allocate
1844 for the characters in the format string. Since the format array is
1845 static we only need to calculate this information once. In theory
1846 this value could also be computed statically, but this introduces
1847 the possibility for a discrepancy and hence a possible memory
1848 corruption. The lengths we compute here will be too long because
1849 they will include any formating characters (%s) in the strings, but
1850 this will not matter. */
1851 for (i = 0; libname_fmt[i].format; i++)
1852 if (format_max_len < strlen (libname_fmt[i].format))
1853 format_max_len = strlen (libname_fmt[i].format);
1855 full_string = xmalloc (strlen (search->name)
1856 + strlen (filename)
1857 + format_max_len
1858 #ifdef DLL_SUPPORT
1859 + (pe_dll_search_prefix
1860 ? strlen (pe_dll_search_prefix) : 0)
1861 #endif
1862 /* Allow for the terminating NUL and for the path
1863 separator character that is inserted between
1864 search->name and the start of the format string. */
1865 + 2);
1867 sprintf (full_string, "%s/", search->name);
1868 base_string = full_string + strlen (full_string);
1870 for (i = 0; libname_fmt[i].format; i++)
1871 {
1872 #ifdef DLL_SUPPORT
1873 if (libname_fmt[i].use_prefix)
1874 {
1875 if (!pe_dll_search_prefix)
1876 continue;
1877 sprintf (base_string, libname_fmt[i].format, pe_dll_search_prefix, filename);
1878 }
1879 else
1880 #endif
1881 sprintf (base_string, libname_fmt[i].format, filename);
1883 if (ldfile_try_open_bfd (full_string, entry))
1884 break;
1885 }
1887 if (!libname_fmt[i].format)
1888 {
1889 free (full_string);
1890 return FALSE;
1891 }
1893 entry->filename = full_string;
1895 return TRUE;
1896 }
1898 static int
1899 gld_${EMULATION_NAME}_find_potential_libraries
1900 (char *name, lang_input_statement_type *entry)
1901 {
1902 return ldfile_open_file_search (name, entry, "", ".lib");
1903 }
1904 \f
1905 static char *
1906 gld_${EMULATION_NAME}_get_script (int *isfile)
1907 EOF
1908 # Scripts compiled in.
1909 # sed commands to quote an ld script as a C string.
1910 sc="-f stringify.sed"
1912 fragment <<EOF
1913 {
1914 *isfile = 0;
1916 if (link_info.relocatable && config.build_constructors)
1917 return
1918 EOF
1919 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1920 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1921 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1922 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1923 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1924 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1925 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1926 if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then
1927 echo ' ; else if (link_info.pei386_auto_import == 1) return' >> e${EMULATION_NAME}.c
1928 sed $sc ldscripts/${EMULATION_NAME}.xa >> e${EMULATION_NAME}.c
1929 fi
1930 echo ' ; else return' >> e${EMULATION_NAME}.c
1931 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1932 echo '; }' >> e${EMULATION_NAME}.c
1934 fragment <<EOF
1937 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1938 {
1939 gld_${EMULATION_NAME}_before_parse,
1940 syslib_default,
1941 hll_default,
1942 gld_${EMULATION_NAME}_after_parse,
1943 gld_${EMULATION_NAME}_after_open,
1944 after_allocation_default,
1945 set_output_arch_default,
1946 ldemul_default_target,
1947 gld_${EMULATION_NAME}_before_allocation,
1948 gld_${EMULATION_NAME}_get_script,
1949 "${EMULATION_NAME}",
1950 "${OUTPUT_FORMAT}",
1951 gld_${EMULATION_NAME}_finish,
1952 NULL, /* Create output section statements. */
1953 gld_${EMULATION_NAME}_open_dynamic_archive,
1954 gld_${EMULATION_NAME}_place_orphan,
1955 gld_${EMULATION_NAME}_set_symbols,
1956 NULL, /* parse_args */
1957 gld${EMULATION_NAME}_add_options,
1958 gld${EMULATION_NAME}_handle_option,
1959 gld_${EMULATION_NAME}_unrecognized_file,
1960 gld_${EMULATION_NAME}_list_options,
1961 gld_${EMULATION_NAME}_recognized_file,
1962 gld_${EMULATION_NAME}_find_potential_libraries,
1963 NULL /* new_vers_pattern. */
1964 };
1965 EOF