| blob | 7c5b2d0d1ab352a24142210171dd449fef6acbab |
1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 if [ -z "$MACHINE" ]; then
4 OUTPUT_ARCH=${ARCH}
5 else
6 OUTPUT_ARCH=${ARCH}:${MACHINE}
7 fi
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, 2004
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. */
29 /* For WINDOWS_NT */
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
46 #endif
48 #include "bfd.h"
49 #include "sysdep.h"
50 #include "bfdlink.h"
51 #include "getopt.h"
52 #include "libiberty.h"
53 #include "ld.h"
54 #include "ldmain.h"
55 #include "ldexp.h"
56 #include "ldlang.h"
57 #include "ldfile.h"
58 #include "ldemul.h"
59 #include <ldgram.h>
60 #include "ldlex.h"
61 #include "ldmisc.h"
62 #include "ldctor.h"
63 #include "coff/internal.h"
65 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
66 header in generic PE code. */
67 #include "coff/i386.h"
68 #include "coff/pe.h"
70 /* FIXME: This is a BFD internal header file, and we should not be
71 using it here. */
72 #include "../bfd/libcoff.h"
74 #include "deffile.h"
75 #include "pe-dll.h"
76 #include "safe-ctype.h"
78 /* Permit the emulation parameters to override the default section
79 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
80 it seem that include/coff/internal.h should not define
81 PE_DEF_SECTION_ALIGNMENT. */
82 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
83 #undef PE_DEF_SECTION_ALIGNMENT
84 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
85 #endif
87 #if defined(TARGET_IS_i386pe)
88 #define DLL_SUPPORT
89 #endif
90 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe) || defined(TARGET_IS_armpe)
91 #define DLL_SUPPORT
92 #endif
94 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
95 #define PE_DEF_SUBSYSTEM 3
96 #else
97 #undef NT_EXE_IMAGE_BASE
98 #undef PE_DEF_SECTION_ALIGNMENT
99 #undef PE_DEF_FILE_ALIGNMENT
100 #define NT_EXE_IMAGE_BASE 0x00010000
101 #ifdef TARGET_IS_armpe
102 #define PE_DEF_SECTION_ALIGNMENT 0x00001000
103 #define PE_DEF_SUBSYSTEM 9
104 #else
105 #define PE_DEF_SECTION_ALIGNMENT 0x00000400
106 #define PE_DEF_SUBSYSTEM 2
107 #endif
108 #define PE_DEF_FILE_ALIGNMENT 0x00000200
109 #endif
112 static struct internal_extra_pe_aouthdr pe;
113 static int dll;
114 static flagword real_flags = 0;
115 static int support_old_code = 0;
116 static char * thumb_entry_symbol = NULL;
117 static lang_assignment_statement_type *image_base_statement = 0;
119 #ifdef DLL_SUPPORT
120 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable. */
121 static char *pe_out_def_filename = NULL;
122 static char *pe_implib_filename = NULL;
123 static int pe_enable_auto_image_base = 0;
124 static char *pe_dll_search_prefix = NULL;
125 #endif
127 extern const char *output_filename;
129 static void
130 gld_${EMULATION_NAME}_before_parse (void)
131 {
132 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
133 output_filename = "${EXECUTABLE_NAME:-a.exe}";
134 #ifdef DLL_SUPPORT
135 config.dynamic_link = TRUE;
136 config.has_shared = 1;
137 link_info.pei386_auto_import = -1;
138 link_info.pei386_runtime_pseudo_reloc = FALSE;
140 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
141 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
142 lang_add_entry ("WinMainCRTStartup", FALSE);
143 #else
144 lang_add_entry ("_WinMainCRTStartup", FALSE);
145 #endif
146 #endif
147 #endif
148 }
149 \f
150 /* PE format extra command line options. */
152 /* Used for setting flags in the PE header. */
153 #define OPTION_BASE_FILE (300 + 1)
154 #define OPTION_DLL (OPTION_BASE_FILE + 1)
155 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
156 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
157 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
158 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
159 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
160 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
161 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
162 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
163 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
164 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
165 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
166 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
167 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
168 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
169 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
170 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
171 #define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
172 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
173 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
174 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
175 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
176 #define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
177 #define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
178 #define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
179 #define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
180 #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
181 #define OPTION_DLL_SEARCH_PREFIX (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
182 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_DLL_SEARCH_PREFIX + 1)
183 #define OPTION_DLL_ENABLE_AUTO_IMPORT (OPTION_NO_DEFAULT_EXCLUDES + 1)
184 #define OPTION_DLL_DISABLE_AUTO_IMPORT (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
185 #define OPTION_ENABLE_EXTRA_PE_DEBUG (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
186 #define OPTION_EXCLUDE_LIBS (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
187 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC \
188 (OPTION_EXCLUDE_LIBS + 1)
189 #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \
190 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
191 #define OPTION_LARGE_ADDRESS_AWARE \
192 (OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC + 1)
194 static void
195 gld${EMULATION_NAME}_add_options
196 (int ns ATTRIBUTE_UNUSED, char **shortopts ATTRIBUTE_UNUSED, int nl,
197 struct option **longopts, int nrl ATTRIBUTE_UNUSED,
198 struct option **really_longopts ATTRIBUTE_UNUSED)
199 {
200 static const struct option xtra_long[] = {
201 /* PE options */
202 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
203 {"dll", no_argument, NULL, OPTION_DLL},
204 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
205 {"heap", required_argument, NULL, OPTION_HEAP},
206 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
207 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
208 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
209 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
210 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
211 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
212 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
213 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
214 {"stack", required_argument, NULL, OPTION_STACK},
215 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
216 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
217 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
218 #ifdef DLL_SUPPORT
219 /* getopt allows abbreviations, so we do this to stop it from treating -o
220 as an abbreviation for this option */
221 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
222 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
223 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
224 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
225 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
226 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
227 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
228 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
229 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
230 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
231 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
232 /* getopt() allows abbreviations, so we do this to stop it from
233 treating -c as an abbreviation for these --compat-implib. */
234 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
235 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
236 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
237 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
238 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
239 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
240 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
241 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
242 {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
243 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
244 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
245 #endif
246 {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE},
247 {NULL, no_argument, NULL, 0}
248 };
250 *longopts = (struct option *)
251 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
252 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
253 }
255 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
256 parameters which may be input from the command line. */
258 typedef struct
259 {
260 void *ptr;
261 int size;
262 int value;
263 char *symbol;
264 int inited;
265 } definfo;
267 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
269 static definfo init[] =
270 {
271 /* imagebase must be first */
272 #define IMAGEBASEOFF 0
273 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
274 #define DLLOFF 1
275 {&dll, sizeof(dll), 0, "__dll__", 0},
276 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
277 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
278 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
279 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
280 D(MajorImageVersion,"__major_image_version__", 1),
281 D(MinorImageVersion,"__minor_image_version__", 0),
282 #ifdef TARGET_IS_armpe
283 D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
284 #else
285 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
286 #endif
287 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
288 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
289 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
290 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
291 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
292 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
293 D(LoaderFlags,"__loader_flags__", 0x0),
294 { NULL, 0, 0, NULL, 0 }
295 };
298 static void
299 gld_${EMULATION_NAME}_list_options (FILE *file)
300 {
301 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
302 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
303 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
304 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
305 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
306 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
307 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
308 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
309 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
310 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
311 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
312 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
313 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
314 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
315 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
316 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
317 #ifdef DLL_SUPPORT
318 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
319 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
320 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
321 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
322 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n"));
323 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
324 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
325 fprintf (file, _(" --out-implib <file> Generate import library\n"));
326 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
327 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
328 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\
329 create __imp_<SYMBOL> as well.\n"));
330 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\
331 unless user specifies one\n"));
332 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
333 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\
334 an importlib, use <string><basename>.dll\n\
335 in preference to lib<basename>.dll \n"));
336 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to\n\
337 __imp_sym for DATA references\n"));
338 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
339 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\
340 adding pseudo-relocations resolved at\n\
341 runtime.\n"));
342 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\
343 auto-imported DATA.\n"));
344 fprintf (file, _(" --enable-extra-pe-debug Enable verbose debug output when building\n\
345 or linking to DLLs (esp. auto-import)\n"));
346 #endif
347 fprintf (file, _(" --large-address-aware Executable supports virtual addresses\n\
348 greater than 2 gigabytes\n"));
349 }
352 static void
353 set_pe_name (char *name, long val)
354 {
355 int i;
357 /* Find the name and set it. */
358 for (i = 0; init[i].ptr; i++)
359 {
360 if (strcmp (name, init[i].symbol) == 0)
361 {
362 init[i].value = val;
363 init[i].inited = 1;
364 return;
365 }
366 }
367 abort ();
368 }
371 static void
372 set_pe_subsystem (void)
373 {
374 const char *sver;
375 int len;
376 int i;
377 static const struct
378 {
379 const char *name;
380 const int value;
381 const char *entry;
382 }
383 v[] =
384 {
385 { "native", 1, "NtProcessStartup" },
386 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
387 { "windows", 2, "WinMainCRTStartup" },
388 #else
389 { "windows", 2, "WinMainCRTStartup" },
390 #endif
391 { "console", 3, "mainCRTStartup" },
392 #if 0
393 /* The Microsoft linker does not recognize this. */
394 { "os2", 5, "" },
395 #endif
396 { "posix", 7, "__PosixProcessStartup"},
397 { "wince", 9, "_WinMainCRTStartup" },
398 { 0, 0, 0 }
399 };
401 sver = strchr (optarg, ':');
402 if (sver == NULL)
403 len = strlen (optarg);
404 else
405 {
406 char *end;
408 len = sver - optarg;
409 set_pe_name ("__major_subsystem_version__",
410 strtoul (sver + 1, &end, 0));
411 if (*end == '.')
412 set_pe_name ("__minor_subsystem_version__",
413 strtoul (end + 1, &end, 0));
414 if (*end != '\0')
415 einfo (_("%P: warning: bad version number in -subsystem option\n"));
416 }
418 for (i = 0; v[i].name; i++)
419 {
420 if (strncmp (optarg, v[i].name, len) == 0
421 && v[i].name[len] == '\0')
422 {
423 const char *initial_symbol_char;
424 const char *entry;
426 set_pe_name ("__subsystem__", v[i].value);
428 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
429 if (*initial_symbol_char == '\0')
430 entry = v[i].entry;
431 else
432 {
433 char *alc_entry;
435 /* lang_add_entry expects its argument to be permanently
436 allocated, so we don't free this string. */
437 alc_entry = xmalloc (strlen (initial_symbol_char)
438 + strlen (v[i].entry)
439 + 1);
440 strcpy (alc_entry, initial_symbol_char);
441 strcat (alc_entry, v[i].entry);
442 entry = alc_entry;
443 }
445 lang_add_entry (entry, TRUE);
447 return;
448 }
449 }
451 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
452 }
455 static void
456 set_pe_value (char *name)
457 {
458 char *end;
460 set_pe_name (name, strtoul (optarg, &end, 0));
462 if (end == optarg)
463 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
465 optarg = end;
466 }
469 static void
470 set_pe_stack_heap (char *resname, char *comname)
471 {
472 set_pe_value (resname);
474 if (*optarg == ',')
475 {
476 optarg++;
477 set_pe_value (comname);
478 }
479 else if (*optarg)
480 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
481 }
484 static bfd_boolean
485 gld${EMULATION_NAME}_handle_option (int optc)
486 {
487 switch (optc)
488 {
489 default:
490 return FALSE;
492 case OPTION_BASE_FILE:
493 link_info.base_file = fopen (optarg, FOPEN_WB);
494 if (link_info.base_file == NULL)
495 {
496 /* xgettext:c-format */
497 fprintf (stderr, _("%s: Can't open base file %s\n"),
498 program_name, optarg);
499 xexit (1);
500 }
501 break;
503 /* PE options. */
504 case OPTION_HEAP:
505 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
506 break;
507 case OPTION_STACK:
508 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
509 break;
510 case OPTION_SUBSYSTEM:
511 set_pe_subsystem ();
512 break;
513 case OPTION_MAJOR_OS_VERSION:
514 set_pe_value ("__major_os_version__");
515 break;
516 case OPTION_MINOR_OS_VERSION:
517 set_pe_value ("__minor_os_version__");
518 break;
519 case OPTION_MAJOR_SUBSYSTEM_VERSION:
520 set_pe_value ("__major_subsystem_version__");
521 break;
522 case OPTION_MINOR_SUBSYSTEM_VERSION:
523 set_pe_value ("__minor_subsystem_version__");
524 break;
525 case OPTION_MAJOR_IMAGE_VERSION:
526 set_pe_value ("__major_image_version__");
527 break;
528 case OPTION_MINOR_IMAGE_VERSION:
529 set_pe_value ("__minor_image_version__");
530 break;
531 case OPTION_FILE_ALIGNMENT:
532 set_pe_value ("__file_alignment__");
533 break;
534 case OPTION_SECTION_ALIGNMENT:
535 set_pe_value ("__section_alignment__");
536 break;
537 case OPTION_DLL:
538 set_pe_name ("__dll__", 1);
539 break;
540 case OPTION_IMAGE_BASE:
541 set_pe_value ("__image_base__");
542 break;
543 case OPTION_SUPPORT_OLD_CODE:
544 support_old_code = 1;
545 break;
546 case OPTION_THUMB_ENTRY:
547 thumb_entry_symbol = optarg;
548 break;
549 #ifdef DLL_SUPPORT
550 case OPTION_OUT_DEF:
551 pe_out_def_filename = xstrdup (optarg);
552 break;
553 case OPTION_EXPORT_ALL:
554 pe_dll_export_everything = 1;
555 break;
556 case OPTION_EXCLUDE_SYMBOLS:
557 pe_dll_add_excludes (optarg, 0);
558 break;
559 case OPTION_EXCLUDE_LIBS:
560 pe_dll_add_excludes (optarg, 1);
561 break;
562 case OPTION_KILL_ATS:
563 pe_dll_kill_ats = 1;
564 break;
565 case OPTION_STDCALL_ALIASES:
566 pe_dll_stdcall_aliases = 1;
567 break;
568 case OPTION_ENABLE_STDCALL_FIXUP:
569 pe_enable_stdcall_fixup = 1;
570 break;
571 case OPTION_DISABLE_STDCALL_FIXUP:
572 pe_enable_stdcall_fixup = 0;
573 break;
574 case OPTION_IMPLIB_FILENAME:
575 pe_implib_filename = xstrdup (optarg);
576 break;
577 case OPTION_WARN_DUPLICATE_EXPORTS:
578 pe_dll_warn_dup_exports = 1;
579 break;
580 case OPTION_IMP_COMPAT:
581 pe_dll_compat_implib = 1;
582 break;
583 case OPTION_ENABLE_AUTO_IMAGE_BASE:
584 pe_enable_auto_image_base = 1;
585 break;
586 case OPTION_DISABLE_AUTO_IMAGE_BASE:
587 pe_enable_auto_image_base = 0;
588 break;
589 case OPTION_DLL_SEARCH_PREFIX:
590 pe_dll_search_prefix = xstrdup (optarg);
591 break;
592 case OPTION_NO_DEFAULT_EXCLUDES:
593 pe_dll_do_default_excludes = 0;
594 break;
595 case OPTION_DLL_ENABLE_AUTO_IMPORT:
596 link_info.pei386_auto_import = 1;
597 break;
598 case OPTION_DLL_DISABLE_AUTO_IMPORT:
599 link_info.pei386_auto_import = 0;
600 break;
601 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
602 link_info.pei386_runtime_pseudo_reloc = 1;
603 break;
604 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
605 link_info.pei386_runtime_pseudo_reloc = 0;
606 break;
607 case OPTION_ENABLE_EXTRA_PE_DEBUG:
608 pe_dll_extra_pe_debug = 1;
609 break;
610 #endif
611 case OPTION_LARGE_ADDRESS_AWARE:
612 real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
613 break;
614 }
615 return TRUE;
616 }
617 \f
619 #ifdef DLL_SUPPORT
620 static unsigned long
621 strhash (const char *str)
622 {
623 const unsigned char *s;
624 unsigned long hash;
625 unsigned int c;
626 unsigned int len;
628 hash = 0;
629 len = 0;
630 s = (const unsigned char *) str;
631 while ((c = *s++) != '\0')
632 {
633 hash += c + (c << 17);
634 hash ^= hash >> 2;
635 ++len;
636 }
637 hash += len + (len << 17);
638 hash ^= hash >> 2;
640 return hash;
641 }
643 /* Use the output file to create a image base for relocatable DLLs. */
645 static unsigned long
646 compute_dll_image_base (const char *ofile)
647 {
648 unsigned long hash = strhash (ofile);
649 return 0x60000000 | ((hash << 16) & 0x0FFC0000);
650 }
651 #endif
653 /* Assign values to the special symbols before the linker script is
654 read. */
656 static void
657 gld_${EMULATION_NAME}_set_symbols (void)
658 {
659 /* Run through and invent symbols for all the
660 names and insert the defaults. */
661 int j;
662 lang_statement_list_type *save;
664 if (!init[IMAGEBASEOFF].inited)
665 {
666 if (link_info.relocatable)
667 init[IMAGEBASEOFF].value = 0;
668 else if (init[DLLOFF].value || link_info.shared)
669 #ifdef DLL_SUPPORT
670 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
671 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
672 #else
673 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
674 #endif
675 else
676 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
677 }
679 /* Don't do any symbol assignments if this is a relocatable link. */
680 if (link_info.relocatable)
681 return;
683 /* Glue the assignments into the abs section. */
684 save = stat_ptr;
686 stat_ptr = &(abs_output_section->children);
688 for (j = 0; init[j].ptr; j++)
689 {
690 long val = init[j].value;
691 lang_assignment_statement_type *rv;
692 rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
693 exp_intop (val)));
694 if (init[j].size == sizeof (short))
695 *(short *) init[j].ptr = val;
696 else if (init[j].size == sizeof (int))
697 *(int *) init[j].ptr = val;
698 else if (init[j].size == sizeof (long))
699 *(long *) init[j].ptr = val;
700 /* This might be a long long or other special type. */
701 else if (init[j].size == sizeof (bfd_vma))
702 *(bfd_vma *) init[j].ptr = val;
703 else abort ();
704 if (j == IMAGEBASEOFF)
705 image_base_statement = rv;
706 }
707 /* Restore the pointer. */
708 stat_ptr = save;
710 if (pe.FileAlignment >
711 pe.SectionAlignment)
712 {
713 einfo (_("%P: warning, file alignment > section alignment.\n"));
714 }
715 }
717 /* This is called after the linker script and the command line options
718 have been read. */
720 static void
721 gld_${EMULATION_NAME}_after_parse (void)
722 {
723 /* The Windows libraries are designed for the linker to treat the
724 entry point as an undefined symbol. Otherwise, the .obj that
725 defines mainCRTStartup is brought in because it is the first
726 encountered in libc.lib and it has other symbols in it which will
727 be pulled in by the link process. To avoid this, we act as
728 though the user specified -u with the entry point symbol.
730 This function is called after the linker script and command line
731 options have been read, so at this point we know the right entry
732 point. This function is called before the input files are
733 opened, so registering the symbol as undefined will make a
734 difference. */
736 if (! link_info.relocatable && entry_symbol.name != NULL)
737 ldlang_add_undef (entry_symbol.name);
738 }
740 /* pe-dll.c directly accesses pe_data_import_dll,
741 so it must be defined outside of #ifdef DLL_SUPPORT.
742 Note - this variable is deliberately not initialised.
743 This allows it to be treated as a common varaible, and only
744 exist in one incarnation in a multiple target enabled linker. */
745 char * pe_data_import_dll;
747 #ifdef DLL_SUPPORT
748 static struct bfd_link_hash_entry *pe_undef_found_sym;
750 static bfd_boolean
751 pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
752 {
753 int sl;
754 char *string = inf;
756 sl = strlen (string);
757 if (h->type == bfd_link_hash_defined
758 && strncmp (h->root.string, string, sl) == 0
759 && h->root.string[sl] == '@')
760 {
761 pe_undef_found_sym = h;
762 return FALSE;
763 }
764 return TRUE;
765 }
767 static void
768 pe_fixup_stdcalls (void)
769 {
770 static int gave_warning_message = 0;
771 struct bfd_link_hash_entry *undef, *sym;
773 if (pe_dll_extra_pe_debug)
774 printf ("%s\n", __FUNCTION__);
776 for (undef = link_info.hash->undefs; undef; undef=undef->und_next)
777 if (undef->type == bfd_link_hash_undefined)
778 {
779 char* at = strchr (undef->root.string, '@');
780 int lead_at = (*undef->root.string == '@');
781 /* For now, don't try to fixup fastcall symbols. */
783 if (at && !lead_at)
784 {
785 /* The symbol is a stdcall symbol, so let's look for a
786 cdecl symbol with the same name and resolve to that. */
787 char *cname = xstrdup (undef->root.string /* + lead_at */);
788 at = strchr (cname, '@');
789 *at = 0;
790 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
792 if (sym && sym->type == bfd_link_hash_defined)
793 {
794 undef->type = bfd_link_hash_defined;
795 undef->u.def.value = sym->u.def.value;
796 undef->u.def.section = sym->u.def.section;
798 if (pe_enable_stdcall_fixup == -1)
799 {
800 einfo (_("Warning: resolving %s by linking to %s\n"),
801 undef->root.string, cname);
802 if (! gave_warning_message)
803 {
804 gave_warning_message = 1;
805 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
806 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
807 }
808 }
809 }
810 }
811 else
812 {
813 /* The symbol is a cdecl symbol, so we look for stdcall
814 symbols - which means scanning the whole symbol table. */
815 pe_undef_found_sym = 0;
816 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
817 (char *) undef->root.string);
818 sym = pe_undef_found_sym;
819 if (sym)
820 {
821 undef->type = bfd_link_hash_defined;
822 undef->u.def.value = sym->u.def.value;
823 undef->u.def.section = sym->u.def.section;
825 if (pe_enable_stdcall_fixup == -1)
826 {
827 einfo (_("Warning: resolving %s by linking to %s\n"),
828 undef->root.string, sym->root.string);
829 if (! gave_warning_message)
830 {
831 gave_warning_message = 1;
832 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
833 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
834 }
835 }
836 }
837 }
838 }
839 }
841 static int
842 make_import_fixup (arelent *rel, asection *s)
843 {
844 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
845 char addend[4];
847 if (pe_dll_extra_pe_debug)
848 printf ("arelent: %s@%#lx: add=%li\n", sym->name,
849 (long) rel->address, (long) rel->addend);
851 if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
852 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
853 s->owner, s, rel->address);
855 pe_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));
857 return 1;
858 }
860 static void
861 pe_find_data_imports (void)
862 {
863 struct bfd_link_hash_entry *undef, *sym;
865 if (link_info.pei386_auto_import == 0)
866 return;
868 for (undef = link_info.hash->undefs; undef; undef=undef->und_next)
869 {
870 if (undef->type == bfd_link_hash_undefined)
871 {
872 /* C++ symbols are *long*. */
873 char buf[4096];
875 if (pe_dll_extra_pe_debug)
876 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
878 sprintf (buf, "__imp_%s", undef->root.string);
880 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
882 if (sym && sym->type == bfd_link_hash_defined)
883 {
884 bfd *b = sym->u.def.section->owner;
885 asymbol **symbols;
886 int nsyms, symsize, i;
888 if (link_info.pei386_auto_import == -1)
889 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
890 undef->root.string, buf);
892 symsize = bfd_get_symtab_upper_bound (b);
893 symbols = (asymbol **) xmalloc (symsize);
894 nsyms = bfd_canonicalize_symtab (b, symbols);
896 for (i = 0; i < nsyms; i++)
897 {
898 if (memcmp (symbols[i]->name, "__head_",
899 sizeof ("__head_") - 1))
900 continue;
902 if (pe_dll_extra_pe_debug)
903 printf ("->%s\n", symbols[i]->name);
905 pe_data_import_dll = (char*) (symbols[i]->name +
906 sizeof ("__head_") - 1);
907 break;
908 }
910 pe_walk_relocs_of_symbol (&link_info, undef->root.string,
911 make_import_fixup);
913 /* Let's differentiate it somehow from defined. */
914 undef->type = bfd_link_hash_defweak;
915 /* We replace original name with __imp_ prefixed, this
916 1) may trash memory 2) leads to duplicate symbol generation.
917 Still, IMHO it's better than having name poluted. */
918 undef->root.string = sym->root.string;
919 undef->u.def.value = sym->u.def.value;
920 undef->u.def.section = sym->u.def.section;
921 }
922 }
923 }
924 }
926 static bfd_boolean
927 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
928 {
929 if (pe_dll_extra_pe_debug)
930 printf ("+%s\n", h->string);
932 return TRUE;
933 }
934 #endif /* DLL_SUPPORT */
937 static void
938 gld_${EMULATION_NAME}_after_open (void)
939 {
940 #ifdef DLL_SUPPORT
941 if (pe_dll_extra_pe_debug)
942 {
943 bfd *a;
944 struct bfd_link_hash_entry *sym;
946 printf ("%s()\n", __FUNCTION__);
948 for (sym = link_info.hash->undefs; sym; sym=sym->und_next)
949 printf ("-%s\n", sym->root.string);
950 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
952 for (a = link_info.input_bfds; a; a = a->link_next)
953 printf ("*%s\n",a->filename);
954 }
955 #endif
957 /* Pass the wacky PE command line options into the output bfd.
958 FIXME: This should be done via a function, rather than by
959 including an internal BFD header. */
961 if (coff_data (output_bfd) == NULL || coff_data (output_bfd)->pe == 0)
962 einfo (_("%F%P: PE operations on non PE file.\n"));
964 pe_data (output_bfd)->pe_opthdr = pe;
965 pe_data (output_bfd)->dll = init[DLLOFF].value;
966 pe_data (output_bfd)->real_flags |= real_flags;
968 #ifdef DLL_SUPPORT
969 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
970 pe_fixup_stdcalls ();
972 pe_process_import_defs (output_bfd, & link_info);
974 pe_find_data_imports ();
976 #if ! (defined (TARGET_IS_i386pe) || defined (TARGET_IS_armpe))
977 if (link_info.shared)
978 #else
979 if (!link_info.relocatable)
980 #endif
981 pe_dll_build_sections (output_bfd, &link_info);
983 #ifndef TARGET_IS_i386pe
984 #ifndef TARGET_IS_armpe
985 else
986 pe_exe_build_sections (output_bfd, &link_info);
987 #endif
988 #endif
989 #endif
991 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
992 if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
993 {
994 /* The arm backend needs special fields in the output hash structure.
995 These will only be created if the output format is an arm format,
996 hence we do not support linking and changing output formats at the
997 same time. Use a link followed by objcopy to change output formats. */
998 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
999 return;
1000 }
1001 {
1002 /* Find a BFD that can hold the interworking stubs. */
1003 LANG_FOR_EACH_INPUT_STATEMENT (is)
1004 {
1005 if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
1006 break;
1007 }
1008 }
1009 #endif
1011 {
1012 /* This next chunk of code tries to detect the case where you have
1013 two import libraries for the same DLL (specifically,
1014 symbolically linking libm.a and libc.a in cygwin to
1015 libcygwin.a). In those cases, it's possible for function
1016 thunks from the second implib to be used but without the
1017 head/tail objects, causing an improper import table. We detect
1018 those cases and rename the "other" import libraries to match
1019 the one the head/tail come from, so that the linker will sort
1020 things nicely and produce a valid import table. */
1022 LANG_FOR_EACH_INPUT_STATEMENT (is)
1023 {
1024 if (is->the_bfd->my_archive)
1025 {
1026 int idata2 = 0, reloc_count=0, is_imp = 0;
1027 asection *sec;
1029 /* See if this is an import library thunk. */
1030 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1031 {
1032 if (strcmp (sec->name, ".idata\$2") == 0)
1033 idata2 = 1;
1034 if (strncmp (sec->name, ".idata\$", 7) == 0)
1035 is_imp = 1;
1036 reloc_count += sec->reloc_count;
1037 }
1039 if (is_imp && !idata2 && reloc_count)
1040 {
1041 /* It is, look for the reference to head and see if it's
1042 from our own library. */
1043 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1044 {
1045 int i;
1046 long symsize;
1047 long relsize;
1048 asymbol **symbols;
1049 arelent **relocs;
1050 int nrelocs;
1052 symsize = bfd_get_symtab_upper_bound (is->the_bfd);
1053 if (symsize < 1)
1054 break;
1055 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1056 if (relsize < 1)
1057 break;
1059 symbols = (asymbol **) xmalloc (symsize);
1060 symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
1061 if (symsize < 0)
1062 {
1063 einfo ("%X%P: unable to process symbols: %E");
1064 return;
1065 }
1067 relocs = (arelent **) xmalloc ((size_t) relsize);
1068 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1069 relocs, symbols);
1070 if (nrelocs < 0)
1071 {
1072 free (relocs);
1073 einfo ("%X%P: unable to process relocs: %E");
1074 return;
1075 }
1077 for (i = 0; i < nrelocs; i++)
1078 {
1079 struct bfd_symbol *s;
1080 struct bfd_link_hash_entry * blhe;
1081 bfd *other_bfd;
1082 char *n;
1084 s = (relocs[i]->sym_ptr_ptr)[0];
1086 if (s->flags & BSF_LOCAL)
1087 continue;
1089 /* Thunk section with reloc to another bfd. */
1090 blhe = bfd_link_hash_lookup (link_info.hash,
1091 s->name,
1092 FALSE, FALSE, TRUE);
1094 if (blhe == NULL
1095 || blhe->type != bfd_link_hash_defined)
1096 continue;
1098 other_bfd = blhe->u.def.section->owner;
1100 if (strcmp (is->the_bfd->my_archive->filename,
1101 other_bfd->my_archive->filename) == 0)
1102 continue;
1104 /* Rename this implib to match the other. */
1105 n = (char *) xmalloc (strlen (other_bfd->my_archive->filename) + 1);
1107 strcpy (n, other_bfd->my_archive->filename);
1109 is->the_bfd->my_archive->filename = n;
1110 }
1112 free (relocs);
1113 /* Note - we do not free the symbols,
1114 they are now cached in the BFD. */
1115 }
1116 }
1117 }
1118 }
1119 }
1121 {
1122 int is_ms_arch = 0;
1123 bfd *cur_arch = 0;
1124 lang_input_statement_type *is2;
1125 lang_input_statement_type *is3;
1127 /* Careful - this is a shell script. Watch those dollar signs! */
1128 /* Microsoft import libraries have every member named the same,
1129 and not in the right order for us to link them correctly. We
1130 must detect these and rename the members so that they'll link
1131 correctly. There are three types of objects: the head, the
1132 thunks, and the sentinel(s). The head is easy; it's the one
1133 with idata2. We assume that the sentinels won't have relocs,
1134 and the thunks will. It's easier than checking the symbol
1135 table for external references. */
1136 LANG_FOR_EACH_INPUT_STATEMENT (is)
1137 {
1138 if (is->the_bfd->my_archive)
1139 {
1140 char *pnt;
1141 bfd *arch = is->the_bfd->my_archive;
1143 if (cur_arch != arch)
1144 {
1145 cur_arch = arch;
1146 is_ms_arch = 1;
1148 for (is3 = is;
1149 is3 && is3->the_bfd->my_archive == arch;
1150 is3 = (lang_input_statement_type *) is3->next)
1151 {
1152 /* A MS dynamic import library can also contain static
1153 members, so look for the first element with a .dll
1154 extension, and use that for the remainder of the
1155 comparisons. */
1156 pnt = strrchr (is3->the_bfd->filename, '.');
1157 if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1158 break;
1159 }
1161 if (is3 == NULL)
1162 is_ms_arch = 0;
1163 else
1164 {
1165 /* OK, found one. Now look to see if the remaining
1166 (dynamic import) members use the same name. */
1167 for (is2 = is;
1168 is2 && is2->the_bfd->my_archive == arch;
1169 is2 = (lang_input_statement_type *) is2->next)
1170 {
1171 /* Skip static members, ie anything with a .obj
1172 extension. */
1173 pnt = strrchr (is2->the_bfd->filename, '.');
1174 if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1175 continue;
1177 if (strcmp (is3->the_bfd->filename,
1178 is2->the_bfd->filename))
1179 {
1180 is_ms_arch = 0;
1181 break;
1182 }
1183 }
1184 }
1185 }
1187 /* This fragment might have come from an .obj file in a Microsoft
1188 import, and not an actual import record. If this is the case,
1189 then leave the filename alone. */
1190 pnt = strrchr (is->the_bfd->filename, '.');
1192 if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1193 {
1194 int idata2 = 0, reloc_count=0;
1195 asection *sec;
1196 char *new_name, seq;
1198 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1199 {
1200 if (strcmp (sec->name, ".idata\$2") == 0)
1201 idata2 = 1;
1202 reloc_count += sec->reloc_count;
1203 }
1205 if (idata2) /* .idata2 is the TOC */
1206 seq = 'a';
1207 else if (reloc_count > 0) /* thunks */
1208 seq = 'b';
1209 else /* sentinel */
1210 seq = 'c';
1212 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1213 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1214 is->the_bfd->filename = new_name;
1216 new_name = xmalloc (strlen (is->filename) + 3);
1217 sprintf (new_name, "%s.%c", is->filename, seq);
1218 is->filename = new_name;
1219 }
1220 }
1221 }
1222 }
1223 }
1224 \f
1225 static void
1226 gld_${EMULATION_NAME}_before_allocation (void)
1227 {
1228 #ifdef TARGET_IS_ppcpe
1229 /* Here we rummage through the found bfds to collect toc information. */
1230 {
1231 LANG_FOR_EACH_INPUT_STATEMENT (is)
1232 {
1233 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1234 {
1235 /* xgettext:c-format */
1236 einfo (_("Errors encountered processing file %s\n"), is->filename);
1237 }
1238 }
1239 }
1241 /* We have seen it all. Allocate it, and carry on. */
1242 ppc_allocate_toc_section (&link_info);
1243 #endif /* TARGET_IS_ppcpe */
1245 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1246 /* FIXME: we should be able to set the size of the interworking stub
1247 section.
1249 Here we rummage through the found bfds to collect glue
1250 information. FIXME: should this be based on a command line
1251 option? krk@cygnus.com. */
1252 {
1253 LANG_FOR_EACH_INPUT_STATEMENT (is)
1254 {
1255 if (! bfd_arm_pe_process_before_allocation
1256 (is->the_bfd, & link_info, support_old_code))
1257 {
1258 /* xgettext:c-format */
1259 einfo (_("Errors encountered processing file %s for interworking"),
1260 is->filename);
1261 }
1262 }
1263 }
1265 /* We have seen it all. Allocate it, and carry on. */
1266 bfd_arm_pe_allocate_interworking_sections (& link_info);
1267 #endif /* TARGET_IS_armpe */
1268 }
1269 \f
1270 #ifdef DLL_SUPPORT
1271 /* This is called when an input file isn't recognized as a BFD. We
1272 check here for .DEF files and pull them in automatically. */
1274 static int
1275 saw_option (char *option)
1276 {
1277 int i;
1279 for (i = 0; init[i].ptr; i++)
1280 if (strcmp (init[i].symbol, option) == 0)
1281 return init[i].inited;
1282 return 0;
1283 }
1284 #endif /* DLL_SUPPORT */
1286 static bfd_boolean
1287 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1288 {
1289 #ifdef DLL_SUPPORT
1290 const char *ext = entry->filename + strlen (entry->filename) - 4;
1292 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1293 {
1294 if (pe_def_file == 0)
1295 pe_def_file = def_file_empty ();
1297 def_file_parse (entry->filename, pe_def_file);
1299 if (pe_def_file)
1300 {
1301 int i, buflen=0, len;
1302 char *buf;
1304 for (i = 0; i < pe_def_file->num_exports; i++)
1305 {
1306 len = strlen (pe_def_file->exports[i].internal_name);
1307 if (buflen < len + 2)
1308 buflen = len + 2;
1309 }
1311 buf = (char *) xmalloc (buflen);
1313 for (i = 0; i < pe_def_file->num_exports; i++)
1314 {
1315 struct bfd_link_hash_entry *h;
1317 sprintf (buf, "_%s", pe_def_file->exports[i].internal_name);
1319 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1320 if (h == (struct bfd_link_hash_entry *) NULL)
1321 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1322 if (h->type == bfd_link_hash_new)
1323 {
1324 h->type = bfd_link_hash_undefined;
1325 h->u.undef.abfd = NULL;
1326 bfd_link_add_undef (link_info.hash, h);
1327 }
1328 }
1329 free (buf);
1331 /* def_file_print (stdout, pe_def_file); */
1332 if (pe_def_file->is_dll == 1)
1333 link_info.shared = 1;
1335 if (pe_def_file->base_address != (bfd_vma)(-1))
1336 {
1337 pe.ImageBase =
1338 pe_data (output_bfd)->pe_opthdr.ImageBase =
1339 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1340 init[IMAGEBASEOFF].inited = 1;
1341 if (image_base_statement)
1342 image_base_statement->exp =
1343 exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1344 }
1346 #if 0
1347 /* Not sure if these *should* be set. */
1348 if (pe_def_file->version_major != -1)
1349 {
1350 pe.MajorImageVersion = pe_def_file->version_major;
1351 pe.MinorImageVersion = pe_def_file->version_minor;
1352 }
1353 #endif
1354 if (pe_def_file->stack_reserve != -1
1355 && ! saw_option ("__size_of_stack_reserve__"))
1356 {
1357 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1358 if (pe_def_file->stack_commit != -1)
1359 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1360 }
1361 if (pe_def_file->heap_reserve != -1
1362 && ! saw_option ("__size_of_heap_reserve__"))
1363 {
1364 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1365 if (pe_def_file->heap_commit != -1)
1366 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1367 }
1368 return TRUE;
1369 }
1370 }
1371 #endif
1372 return FALSE;
1373 }
1375 static bfd_boolean
1376 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1377 {
1378 #ifdef DLL_SUPPORT
1379 #ifdef TARGET_IS_i386pe
1380 pe_dll_id_target ("pei-i386");
1381 #endif
1382 #ifdef TARGET_IS_shpe
1383 pe_dll_id_target ("pei-shl");
1384 #endif
1385 #ifdef TARGET_IS_mipspe
1386 pe_dll_id_target ("pei-mips");
1387 #endif
1388 #ifdef TARGET_IS_armpe
1389 pe_dll_id_target ("pei-arm-little");
1390 #endif
1391 if (bfd_get_format (entry->the_bfd) == bfd_object)
1392 {
1393 char fbuf[LD_PATHMAX + 1];
1394 const char *ext;
1396 if (REALPATH (entry->filename, fbuf) == NULL)
1397 strncpy (fbuf, entry->filename, sizeof (fbuf));
1399 ext = fbuf + strlen (fbuf) - 4;
1401 if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1402 return pe_implied_import_dll (fbuf);
1403 }
1404 #endif
1405 return FALSE;
1406 }
1408 static void
1409 gld_${EMULATION_NAME}_finish (void)
1410 {
1411 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1412 struct bfd_link_hash_entry * h;
1414 if (thumb_entry_symbol != NULL)
1415 {
1416 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1417 FALSE, FALSE, TRUE);
1419 if (h != (struct bfd_link_hash_entry *) NULL
1420 && (h->type == bfd_link_hash_defined
1421 || h->type == bfd_link_hash_defweak)
1422 && h->u.def.section->output_section != NULL)
1423 {
1424 static char buffer[32];
1425 bfd_vma val;
1427 /* Special procesing is required for a Thumb entry symbol. The
1428 bottom bit of its address must be set. */
1429 val = (h->u.def.value
1430 + bfd_get_section_vma (output_bfd,
1431 h->u.def.section->output_section)
1432 + h->u.def.section->output_offset);
1434 val |= 1;
1436 /* Now convert this value into a string and store it in entry_symbol
1437 where the lang_finish() function will pick it up. */
1438 buffer[0] = '0';
1439 buffer[1] = 'x';
1441 sprintf_vma (buffer + 2, val);
1443 if (entry_symbol.name != NULL && entry_from_cmdline)
1444 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1445 thumb_entry_symbol, entry_symbol.name);
1446 entry_symbol.name = buffer;
1447 }
1448 else
1449 einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1450 }
1451 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1453 #ifdef DLL_SUPPORT
1454 if (link_info.shared
1455 #if !defined(TARGET_IS_shpe) && !defined(TARGET_IS_mipspe)
1456 || (!link_info.relocatable && pe_def_file->num_exports != 0)
1457 #endif
1458 )
1459 {
1460 pe_dll_fill_sections (output_bfd, &link_info);
1461 if (pe_implib_filename)
1462 pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1463 }
1464 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1465 /* ARM doesn't need relocs. */
1466 else
1467 {
1468 pe_exe_fill_sections (output_bfd, &link_info);
1469 }
1470 #endif
1472 if (pe_out_def_filename)
1473 pe_dll_generate_def_file (pe_out_def_filename);
1474 #endif /* DLL_SUPPORT */
1476 /* I don't know where .idata gets set as code, but it shouldn't be. */
1477 {
1478 asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1480 if (asec)
1481 {
1482 asec->flags &= ~SEC_CODE;
1483 asec->flags |= SEC_DATA;
1484 }
1485 }
1486 }
1488 \f
1489 /* Find the last output section before given output statement.
1490 Used by place_orphan. */
1492 static asection *
1493 output_prev_sec_find (lang_output_section_statement_type *os)
1494 {
1495 asection *s = (asection *) NULL;
1496 lang_statement_union_type *u;
1497 lang_output_section_statement_type *lookup;
1499 for (u = lang_output_section_statement.head;
1500 u != (lang_statement_union_type *) NULL;
1501 u = lookup->next)
1502 {
1503 lookup = &u->output_section_statement;
1504 if (lookup->constraint == -1)
1505 continue;
1506 if (lookup == os)
1507 return s;
1509 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1510 s = lookup->bfd_section;
1511 }
1513 return NULL;
1514 }
1516 /* Place an orphan section.
1518 We use this to put sections in a reasonable place in the file, and
1519 to ensure that they are aligned as required.
1521 We handle grouped sections here as well. A section named .foo$nn
1522 goes into the output section .foo. All grouped sections are sorted
1523 by name.
1525 Grouped sections for the default sections are handled by the
1526 default linker script using wildcards, and are sorted by
1527 sort_sections. */
1529 struct orphan_save
1530 {
1531 lang_output_section_statement_type *os;
1532 asection **section;
1533 lang_statement_union_type **stmt;
1534 };
1536 static bfd_boolean
1537 gld_${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1538 {
1539 const char *secname;
1540 char *hold_section_name;
1541 char *dollar = NULL;
1542 const char *ps = NULL;
1543 lang_output_section_statement_type *os;
1544 lang_statement_list_type add_child;
1546 secname = bfd_get_section_name (s->owner, s);
1548 /* Look through the script to see where to place this section. */
1549 hold_section_name = xstrdup (secname);
1550 if (!link_info.relocatable)
1551 {
1552 dollar = strchr (hold_section_name, '$');
1553 if (dollar != NULL)
1554 *dollar = '\0';
1555 }
1557 os = lang_output_section_find (hold_section_name);
1559 lang_list_init (&add_child);
1561 if (os != NULL
1562 && (os->bfd_section == NULL
1563 || ((s->flags ^ os->bfd_section->flags)
1564 & (SEC_LOAD | SEC_ALLOC)) == 0))
1565 {
1566 /* We already have an output section statement with this
1567 name, and its bfd section, if any, has compatible flags. */
1568 lang_add_section (&add_child, s, os, file);
1569 }
1570 else
1571 {
1572 struct orphan_save *place;
1573 static struct orphan_save hold_text;
1574 static struct orphan_save hold_rdata;
1575 static struct orphan_save hold_data;
1576 static struct orphan_save hold_bss;
1577 char *outsecname;
1578 lang_statement_list_type *old;
1579 lang_statement_list_type add;
1580 etree_type *address;
1582 /* Try to put the new output section in a reasonable place based
1583 on the section name and section flags. */
1584 #define HAVE_SECTION(hold, name) \
1585 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1587 place = NULL;
1588 if ((s->flags & SEC_ALLOC) == 0)
1589 ;
1590 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1591 && HAVE_SECTION (hold_bss, ".bss"))
1592 place = &hold_bss;
1593 else if ((s->flags & SEC_READONLY) == 0
1594 && HAVE_SECTION (hold_data, ".data"))
1595 place = &hold_data;
1596 else if ((s->flags & SEC_CODE) == 0
1597 && (s->flags & SEC_READONLY) != 0
1598 && HAVE_SECTION (hold_rdata, ".rdata"))
1599 place = &hold_rdata;
1600 else if ((s->flags & SEC_READONLY) != 0
1601 && HAVE_SECTION (hold_text, ".text"))
1602 place = &hold_text;
1604 #undef HAVE_SECTION
1606 /* Choose a unique name for the section. This will be needed if
1607 the same section name appears in the input file with
1608 different loadable or allocatable characteristics. */
1609 outsecname = xstrdup (hold_section_name);
1610 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1611 {
1612 unsigned int len;
1613 char *newname;
1614 unsigned int i;
1616 len = strlen (outsecname);
1617 newname = xmalloc (len + 5);
1618 strcpy (newname, outsecname);
1619 i = 0;
1620 do
1621 {
1622 sprintf (newname + len, "%d", i);
1623 ++i;
1624 }
1625 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1627 free (outsecname);
1628 outsecname = newname;
1629 }
1631 /* Start building a list of statements for this section. */
1632 old = stat_ptr;
1633 stat_ptr = &add;
1634 lang_list_init (stat_ptr);
1636 if (config.build_constructors)
1637 {
1638 /* If the name of the section is representable in C, then create
1639 symbols to mark the start and the end of the section. */
1640 for (ps = outsecname; *ps != '\0'; ps++)
1641 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1642 break;
1643 if (*ps == '\0')
1644 {
1645 char *symname;
1646 etree_type *e_align;
1648 symname = (char *) xmalloc (ps - outsecname + sizeof "___start_");
1649 sprintf (symname, "___start_%s", outsecname);
1650 e_align = exp_unop (ALIGN_K,
1651 exp_intop ((bfd_vma) 1 << s->alignment_power));
1652 lang_add_assignment (exp_assop ('=', symname, e_align));
1653 }
1654 }
1656 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1657 address = exp_intop ((bfd_vma) 0);
1658 else
1659 {
1660 /* All sections in an executable must be aligned to a page
1661 boundary. */
1662 address = exp_unop (ALIGN_K,
1663 exp_nameop (NAME, "__section_alignment__"));
1664 }
1666 os = lang_enter_output_section_statement (outsecname, address, 0,
1667 (etree_type *) NULL,
1668 (etree_type *) NULL,
1669 (etree_type *) NULL, 0);
1671 lang_add_section (&add_child, s, os, file);
1673 lang_leave_output_section_statement
1674 ((bfd_vma) 0, "*default*",
1675 (struct lang_output_section_phdr_list *) NULL, NULL);
1677 if (config.build_constructors && *ps == '\0')
1678 {
1679 char *symname;
1681 /* lang_leave_ouput_section_statement resets stat_ptr.
1682 Put stat_ptr back where we want it. */
1683 if (place != NULL)
1684 stat_ptr = &add;
1686 symname = (char *) xmalloc (ps - outsecname + sizeof "___stop_");
1687 sprintf (symname, "___stop_%s", outsecname);
1688 lang_add_assignment (exp_assop ('=', symname,
1689 exp_nameop (NAME, ".")));
1690 }
1692 stat_ptr = old;
1694 if (place != NULL && os->bfd_section != NULL)
1695 {
1696 asection *snew, **pps;
1698 snew = os->bfd_section;
1700 /* Shuffle the bfd section list to make the output file look
1701 neater. This is really only cosmetic. */
1702 if (place->section == NULL)
1703 {
1704 asection *bfd_section = place->os->bfd_section;
1706 /* If the output statement hasn't been used to place
1707 any input sections (and thus doesn't have an output
1708 bfd_section), look for the closest prior output statement
1709 having an output section. */
1710 if (bfd_section == NULL)
1711 bfd_section = output_prev_sec_find (place->os);
1713 if (bfd_section != NULL && bfd_section != snew)
1714 place->section = &bfd_section->next;
1715 }
1717 if (place->section != NULL)
1718 {
1719 /* Unlink the section. */
1720 for (pps = &output_bfd->sections;
1721 *pps != snew;
1722 pps = &(*pps)->next)
1723 ;
1724 bfd_section_list_remove (output_bfd, pps);
1726 /* Now tack it on to the "place->os" section list. */
1727 bfd_section_list_insert (output_bfd, place->section, snew);
1728 }
1730 /* Save the end of this list. Further ophans of this type will
1731 follow the one we've just added. */
1732 place->section = &snew->next;
1734 /* The following is non-cosmetic. We try to put the output
1735 statements in some sort of reasonable order here, because
1736 they determine the final load addresses of the orphan
1737 sections. In addition, placing output statements in the
1738 wrong order may require extra segments. For instance,
1739 given a typical situation of all read-only sections placed
1740 in one segment and following that a segment containing all
1741 the read-write sections, we wouldn't want to place an orphan
1742 read/write section before or amongst the read-only ones. */
1743 if (add.head != NULL)
1744 {
1745 if (place->stmt == NULL)
1746 {
1747 /* Put the new statement list right at the head. */
1748 *add.tail = place->os->header.next;
1749 place->os->header.next = add.head;
1750 }
1751 else
1752 {
1753 /* Put it after the last orphan statement we added. */
1754 *add.tail = *place->stmt;
1755 *place->stmt = add.head;
1756 }
1758 /* Fix the global list pointer if we happened to tack our
1759 new list at the tail. */
1760 if (*old->tail == add.head)
1761 old->tail = add.tail;
1763 /* Save the end of this list. */
1764 place->stmt = add.tail;
1765 }
1766 }
1767 }
1769 {
1770 lang_statement_union_type **pl = &os->children.head;
1772 if (dollar != NULL)
1773 {
1774 bfd_boolean found_dollar;
1776 /* The section name has a '$'. Sort it with the other '$'
1777 sections. */
1778 found_dollar = FALSE;
1779 for ( ; *pl != NULL; pl = &(*pl)->header.next)
1780 {
1781 lang_input_section_type *ls;
1782 const char *lname;
1784 if ((*pl)->header.type != lang_input_section_enum)
1785 continue;
1787 ls = &(*pl)->input_section;
1789 lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1790 if (strchr (lname, '$') == NULL)
1791 {
1792 if (found_dollar)
1793 break;
1794 }
1795 else
1796 {
1797 found_dollar = TRUE;
1798 if (strcmp (secname, lname) < 0)
1799 break;
1800 }
1801 }
1802 }
1804 if (add_child.head != NULL)
1805 {
1806 add_child.head->header.next = *pl;
1807 *pl = add_child.head;
1808 }
1809 }
1811 free (hold_section_name);
1813 return TRUE;
1814 }
1816 static bfd_boolean
1817 gld_${EMULATION_NAME}_open_dynamic_archive
1818 (const char *arch ATTRIBUTE_UNUSED, search_dirs_type *search,
1819 lang_input_statement_type *entry)
1820 {
1821 const char * filename;
1822 char * string;
1824 if (! entry->is_archive)
1825 return FALSE;
1827 filename = entry->filename;
1829 string = (char *) xmalloc (strlen (search->name)
1830 + strlen (filename)
1831 + sizeof "/lib.a.dll"
1832 #ifdef DLL_SUPPORT
1833 + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1834 #endif
1835 + 1);
1837 /* Try "libfoo.dll.a" first (preferred explicit import library for dll's. */
1838 sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1840 if (! ldfile_try_open_bfd (string, entry))
1841 {
1842 /* Try "foo.dll.a" next (alternate explicit import library for dll's. */
1843 sprintf (string, "%s/%s.dll.a", search->name, filename);
1844 if (! ldfile_try_open_bfd (string, entry))
1845 {
1846 /* Try libfoo.a next. Normally, this would be interpreted as a static
1847 library, but it *could* be an import library. For backwards compatibility,
1848 libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1849 or sometimes errors occur when building legacy packages.
1851 Putting libfoo.a here means that in a failure case (i.e. the library
1852 -lfoo is not found) we will search for libfoo.a twice before
1853 giving up -- once here, and once when searching for a "static" lib.
1854 for a "static" lib. */
1855 /* Try "libfoo.a" (import lib, or static lib, but must
1856 take precedence over dll's). */
1857 sprintf (string, "%s/lib%s.a", search->name, filename);
1858 if (! ldfile_try_open_bfd (string, entry))
1859 {
1860 #ifdef DLL_SUPPORT
1861 if (pe_dll_search_prefix)
1862 {
1863 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */
1864 sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
1865 if (! ldfile_try_open_bfd (string, entry))
1866 {
1867 /* Try "libfoo.dll" (default preferred dll name). */
1868 sprintf (string, "%s/lib%s.dll", search->name, filename);
1869 if (! ldfile_try_open_bfd (string, entry))
1870 {
1871 /* Finally, try "foo.dll" (alternate dll name). */
1872 sprintf (string, "%s/%s.dll", search->name, filename);
1873 if (! ldfile_try_open_bfd (string, entry))
1874 {
1875 free (string);
1876 return FALSE;
1877 }
1878 }
1879 }
1880 }
1881 else /* pe_dll_search_prefix not specified. */
1882 #endif
1883 {
1884 /* Try "libfoo.dll" (preferred dll name). */
1885 sprintf (string, "%s/lib%s.dll", search->name, filename);
1886 if (! ldfile_try_open_bfd (string, entry))
1887 {
1888 /* Finally, try "foo.dll" (alternate dll name). */
1889 sprintf (string, "%s/%s.dll", search->name, filename);
1890 if (! ldfile_try_open_bfd (string, entry))
1891 {
1892 free (string);
1893 return FALSE;
1894 }
1895 }
1896 }
1897 }
1898 }
1899 }
1901 entry->filename = string;
1903 return TRUE;
1904 }
1906 static int
1907 gld_${EMULATION_NAME}_find_potential_libraries
1908 (char *name, lang_input_statement_type *entry)
1909 {
1910 return ldfile_open_file_search (name, entry, "", ".lib");
1911 }
1912 \f
1913 static char *
1914 gld_${EMULATION_NAME}_get_script (int *isfile)
1915 EOF
1916 # Scripts compiled in.
1917 # sed commands to quote an ld script as a C string.
1918 sc="-f stringify.sed"
1920 cat >>e${EMULATION_NAME}.c <<EOF
1921 {
1922 *isfile = 0;
1924 if (link_info.relocatable && config.build_constructors)
1925 return
1926 EOF
1927 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1928 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1929 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1930 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1931 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1932 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1933 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1934 echo ' ; else return' >> e${EMULATION_NAME}.c
1935 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1936 echo '; }' >> e${EMULATION_NAME}.c
1938 cat >>e${EMULATION_NAME}.c <<EOF
1941 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1942 {
1943 gld_${EMULATION_NAME}_before_parse,
1944 syslib_default,
1945 hll_default,
1946 gld_${EMULATION_NAME}_after_parse,
1947 gld_${EMULATION_NAME}_after_open,
1948 after_allocation_default,
1949 set_output_arch_default,
1950 ldemul_default_target,
1951 gld_${EMULATION_NAME}_before_allocation,
1952 gld_${EMULATION_NAME}_get_script,
1953 "${EMULATION_NAME}",
1954 "${OUTPUT_FORMAT}",
1955 gld_${EMULATION_NAME}_finish,
1956 NULL, /* Create output section statements. */
1957 gld_${EMULATION_NAME}_open_dynamic_archive,
1958 gld_${EMULATION_NAME}_place_orphan,
1959 gld_${EMULATION_NAME}_set_symbols,
1960 NULL, /* parse_args */
1961 gld${EMULATION_NAME}_add_options,
1962 gld${EMULATION_NAME}_handle_option,
1963 gld_${EMULATION_NAME}_unrecognized_file,
1964 gld_${EMULATION_NAME}_list_options,
1965 gld_${EMULATION_NAME}_recognized_file,
1966 gld_${EMULATION_NAME}_find_potential_libraries,
1967 NULL /* new_vers_pattern. */
1968 };
1969 EOF