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