1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 (echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
4 cat >>e${EMULATION_NAME}.c <<EOF
5 /* This file is part of GLD, the Gnu Linker.
6 Copyright 1995, 96, 97, 1998 Free Software Foundation, Inc.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* The original file generated returned different default scripts depending
24 on whether certain switches were set, but these switches pertain to the
25 Linux system and that particular version of coff. In the NT case, we
26 only determine if the subsystem is console or windows in order to select
27 the correct entry point by default. */
33 #include "libiberty.h"
44 #include "coff/internal.h"
45 #include "../bfd/libcoff.h"
46 #include "../bfd/libbfd.h"
49 #define TARGET_IS_${EMULATION_NAME}
51 #if defined(TARGET_IS_i386pe)
55 #define PE_DEF_SUBSYSTEM 3
57 #ifdef TARGET_IS_arm_epoc_pe
58 #define bfd_arm_pe_allocate_interworking_sections \
59 bfd_arm_epoc_pe_allocate_interworking_sections
60 #define bfd_arm_pe_get_bfd_for_interworking \
61 bfd_arm_epoc_pe_get_bfd_for_interworking
62 #define bfd_arm_pe_process_before_allocation \
63 bfd_arm_epoc_pe_process_before_allocation
66 static void gld_${EMULATION_NAME}_set_symbols PARAMS ((void));
67 static void gld_${EMULATION_NAME}_after_open PARAMS ((void));
68 static void gld_${EMULATION_NAME}_before_parse PARAMS ((void));
69 static void gld_${EMULATION_NAME}_after_parse PARAMS ((void));
70 static void gld_${EMULATION_NAME}_before_allocation PARAMS ((void));
71 static boolean gld_${EMULATION_NAME}_place_orphan
72 PARAMS ((lang_input_statement_type *, asection *));
73 static void gld${EMULATION_NAME}_place_section
74 PARAMS ((lang_statement_union_type *));
75 static char *gld_${EMULATION_NAME}_get_script PARAMS ((int *));
76 static int gld_${EMULATION_NAME}_parse_args PARAMS ((int, char **));
78 static struct internal_extra_pe_aouthdr pe;
80 static int support_old_code = 0;
81 extern def_file *pe_def_file;
82 static lang_assignment_statement_type *image_base_statement = 0;
84 static char *pe_out_def_filename = 0;
85 extern int pe_dll_export_everything;
86 extern int pe_dll_kill_ats;
87 extern int pe_dll_stdcall_aliases;
88 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable */
89 static char *pe_implib_filename = 0;
91 extern const char *output_filename;
94 gld_${EMULATION_NAME}_before_parse()
96 output_filename = "a.exe";
97 ldfile_output_architecture = bfd_arch_${ARCH};
99 config.has_shared = 1;
103 /* PE format extra command line options. */
105 /* Used for setting flags in the PE header. */
106 #define OPTION_BASE_FILE (300 + 1)
107 #define OPTION_DLL (OPTION_BASE_FILE + 1)
108 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
109 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
110 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
111 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
112 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
113 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
114 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
115 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
116 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
117 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
118 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
119 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
120 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
121 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
122 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
123 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
124 #define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
125 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
126 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
127 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
128 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
130 static struct option longopts[] =
133 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
134 {"dll", no_argument, NULL, OPTION_DLL},
135 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
136 {"heap", required_argument, NULL, OPTION_HEAP},
137 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
138 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
139 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
140 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
141 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
142 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
143 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
144 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
145 {"stack", required_argument, NULL, OPTION_STACK},
146 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
147 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
149 /* getopt allows abbreviations, so we do this to stop it from treating -o
150 as an abbreviation for this option */
151 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
152 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
153 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
154 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
155 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
156 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
157 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
158 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
159 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
161 {NULL, no_argument, NULL, 0}
165 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
166 parameters which may be input from the command line */
177 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
179 static definfo init[] =
181 /* imagebase must be first */
182 #define IMAGEBASEOFF 0
183 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
185 {&dll, sizeof(dll), 0, "__dll__"},
186 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
187 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
188 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
189 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
190 D(MajorImageVersion,"__major_image_version__", 1),
191 D(MinorImageVersion,"__minor_image_version__", 0),
192 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
193 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
194 D(Subsystem,"__subsystem__", PE_DEF_SUBSYSTEM),
195 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x2000000),
196 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
197 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
198 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
199 D(LoaderFlags,"__loader_flags__", 0x0),
200 { NULL, 0, 0, NULL, 0 }
204 gld_${EMULATION_NAME}_list_options (file)
207 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
208 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
209 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
210 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
211 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
212 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
213 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
214 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
215 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
216 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
217 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
218 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
219 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
220 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
221 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
223 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
224 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
225 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
226 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
227 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
228 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
229 fprintf (file, _(" --out-implib <file> Generate import library\n"));
230 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
235 set_pe_name (name, val)
240 /* Find the name and set it. */
241 for (i = 0; init[i].ptr; i++)
243 if (strcmp (name, init[i].symbol) == 0)
268 { "native", 1, "_NtProcessStartup" },
269 { "windows", 2, "_WinMainCRTStartup" },
270 { "console", 3, "_mainCRTStartup" },
272 /* The Microsoft linker does not recognize this. */
275 { "posix", 7, "___PosixProcessStartup"},
279 sver = strchr (optarg, ':');
281 len = strlen (optarg);
287 set_pe_name ("__major_subsystem_version__",
288 strtoul (sver + 1, &end, 0));
290 set_pe_name ("__minor_subsystem_version__",
291 strtoul (end + 1, &end, 0));
293 einfo (_("%P: warning: bad version number in -subsystem option\n"));
296 for (i = 0; v[i].name; i++)
298 if (strncmp (optarg, v[i].name, len) == 0
299 && v[i].name[len] == '\0')
301 set_pe_name ("__subsystem__", v[i].value);
303 lang_add_entry (v[i].entry, 1);
309 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
321 set_pe_name (name, strtoul (optarg, &end, 0));
324 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
330 set_pe_stack_heap (resname, comname)
334 set_pe_value (resname);
339 set_pe_value (comname);
342 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
348 gld_${EMULATION_NAME}_parse_args(argc, argv)
354 int prevoptind = optind;
355 int prevopterr = opterr;
357 static int lastoptind = -1;
359 if (lastoptind != optind)
365 optc = getopt_long_only (argc, argv, "-", longopts, &longind);
376 case OPTION_BASE_FILE:
377 link_info.base_file = (PTR) fopen (optarg, FOPEN_WB);
378 if (link_info.base_file == NULL)
380 /* xgettext:c-format */
381 fprintf (stderr, _("%s: Can't open base file %s\n"),
382 program_name, optarg);
389 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
392 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
394 case OPTION_SUBSYSTEM:
397 case OPTION_MAJOR_OS_VERSION:
398 set_pe_value ("__major_os_version__");
400 case OPTION_MINOR_OS_VERSION:
401 set_pe_value ("__minor_os_version__");
403 case OPTION_MAJOR_SUBSYSTEM_VERSION:
404 set_pe_value ("__major_subsystem_version__");
406 case OPTION_MINOR_SUBSYSTEM_VERSION:
407 set_pe_value ("__minor_subsystem_version__");
409 case OPTION_MAJOR_IMAGE_VERSION:
410 set_pe_value ("__major_image_version__");
412 case OPTION_MINOR_IMAGE_VERSION:
413 set_pe_value ("__minor_image_version__");
415 case OPTION_FILE_ALIGNMENT:
416 set_pe_value ("__file_alignment__");
418 case OPTION_SECTION_ALIGNMENT:
419 set_pe_value ("__section_alignment__");
422 set_pe_name ("__dll__", 1);
424 case OPTION_IMAGE_BASE:
425 set_pe_value ("__image_base__");
427 case OPTION_SUPPORT_OLD_CODE:
428 support_old_code = 1;
432 pe_out_def_filename = xstrdup (optarg);
434 case OPTION_EXPORT_ALL:
435 pe_dll_export_everything = 1;
437 case OPTION_EXCLUDE_SYMBOLS:
438 pe_dll_add_excludes (optarg);
440 case OPTION_KILL_ATS:
443 case OPTION_STDCALL_ALIASES:
444 pe_dll_stdcall_aliases = 1;
446 case OPTION_ENABLE_STDCALL_FIXUP:
447 pe_enable_stdcall_fixup = 1;
449 case OPTION_DISABLE_STDCALL_FIXUP:
450 pe_enable_stdcall_fixup = 0;
452 case OPTION_IMPLIB_FILENAME:
453 pe_implib_filename = xstrdup (optarg);
460 /* Assign values to the special symbols before the linker script is
464 gld_${EMULATION_NAME}_set_symbols ()
466 /* Run through and invent symbols for all the
467 names and insert the defaults. */
469 lang_statement_list_type *save;
471 if (!init[IMAGEBASEOFF].inited)
473 if (link_info.relocateable)
474 init[IMAGEBASEOFF].value = 0;
475 else if (init[DLLOFF].value || link_info.shared)
476 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
478 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
481 /* Don't do any symbol assignments if this is a relocateable link. */
482 if (link_info.relocateable)
485 /* Glue the assignments into the abs section */
488 stat_ptr = &(abs_output_section->children);
490 for (j = 0; init[j].ptr; j++)
492 long val = init[j].value;
493 lang_assignment_statement_type *rv;
494 rv = lang_add_assignment (exp_assop ('=' ,init[j].symbol, exp_intop (val)));
495 if (init[j].size == sizeof(short))
496 *(short *)init[j].ptr = val;
497 else if (init[j].size == sizeof(int))
498 *(int *)init[j].ptr = val;
499 else if (init[j].size == sizeof(long))
500 *(long *)init[j].ptr = val;
501 /* This might be a long long or other special type. */
502 else if (init[j].size == sizeof(bfd_vma))
503 *(bfd_vma *)init[j].ptr = val;
505 if (j == IMAGEBASEOFF)
506 image_base_statement = rv;
508 /* Restore the pointer. */
511 if (pe.FileAlignment >
514 einfo (_("%P: warning, file alignment > section alignment.\n"));
518 /* This is called after the linker script and the command line options
522 gld_${EMULATION_NAME}_after_parse ()
524 /* The Windows libraries are designed for the linker to treat the
525 entry point as an undefined symbol. Otherwise, the .obj that
526 defines mainCRTStartup is brought in because it is the first
527 encountered in libc.lib and it has other symbols in it which will
528 be pulled in by the link process. To avoid this, we act as
529 though the user specified -u with the entry point symbol.
531 This function is called after the linker script and command line
532 options have been read, so at this point we know the right entry
533 point. This function is called before the input files are
534 opened, so registering the symbol as undefined will make a
538 ldlang_add_undef (entry_symbol);
541 static struct bfd_link_hash_entry *pe_undef_found_sym;
544 pe_undef_cdecl_match (h, string)
545 struct bfd_link_hash_entry *h;
548 int sl = strlen (string);
549 if (h->type == bfd_link_hash_defined
550 && strncmp (h->root.string, string, sl) == 0
551 && h->root.string[sl] == '@')
553 pe_undef_found_sym = h;
562 static int gave_warning_message = 0;
563 struct bfd_link_hash_entry *undef, *sym;
565 for (undef = link_info.hash->undefs; undef; undef=undef->next)
566 if (undef->type == bfd_link_hash_undefined)
568 at = strchr (undef->root.string, '@');
571 /* The symbol is a stdcall symbol, so let's look for a cdecl
572 symbol with the same name and resolve to that */
573 char *cname = xstrdup (undef->root.string);
574 at = strchr (cname, '@');
576 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
577 if (sym && sym->type == bfd_link_hash_defined)
579 undef->type = bfd_link_hash_defined;
580 undef->u.def.value = sym->u.def.value;
581 undef->u.def.section = sym->u.def.section;
582 if (pe_enable_stdcall_fixup == -1)
584 einfo (_("Warning: resolving %s by linking to %s\n"),
585 undef->root.string, cname);
586 if (! gave_warning_message)
588 gave_warning_message = 1;
589 einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
590 einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
597 /* The symbol is a cdecl symbol, so we look for stdcall
598 symbols - which means scanning the whole symbol table */
599 pe_undef_found_sym = 0;
600 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
601 (PTR) undef->root.string);
602 sym = pe_undef_found_sym;
605 undef->type = bfd_link_hash_defined;
606 undef->u.def.value = sym->u.def.value;
607 undef->u.def.section = sym->u.def.section;
608 if (pe_enable_stdcall_fixup == -1)
610 einfo (_("Warning: resolving %s by linking to %s\n"),
611 undef->root.string, sym->root.string);
612 if (! gave_warning_message)
614 gave_warning_message = 1;
615 einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
616 einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
625 gld_${EMULATION_NAME}_after_open ()
627 /* Pass the wacky PE command line options into the output bfd.
628 FIXME: This should be done via a function, rather than by
629 including an internal BFD header. */
631 if (!coff_data (output_bfd)->pe)
632 einfo (_("%F%P: PE operations on non PE file.\n"));
634 pe_data (output_bfd)->pe_opthdr = pe;
635 pe_data (output_bfd)->dll = init[DLLOFF].value;
638 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
639 pe_fixup_stdcalls ();
641 pe_process_import_defs(output_bfd, &link_info);
642 if (link_info.shared)
643 pe_dll_build_sections (output_bfd, &link_info);
646 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
648 /* Find a BFD that can hold the interworking stubs. */
649 LANG_FOR_EACH_INPUT_STATEMENT (is)
651 if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
658 static int sequence = 0;
660 bfd *cur_arch = 0, *elt;
661 lang_input_statement_type *is2;
662 /* Careful - this is a shell script. Watch those dollar signs! */
663 /* Microsoft import libraries have every member named the same,
664 and not in the right order for us to link them correctly. We
665 must detect these and rename the members so that they'll link
666 correctly. There are three types of objects: the head, the
667 thunks, and the sentinel(s). The head is easy; it's the one
668 with idata2. We assume that the sentinels won't have relocs,
669 and the thunks will. It's easier than checking the symbol
670 table for external references. */
671 LANG_FOR_EACH_INPUT_STATEMENT (is)
673 if (is->the_bfd->my_archive)
675 bfd *arch = is->the_bfd->my_archive;
676 if (cur_arch != arch)
681 is2 && is2->the_bfd->my_archive == arch;
682 is2 = (lang_input_statement_type *)is2->next)
684 if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
691 int idata2 = 0, i, reloc_count=0;
694 for (sec = is->the_bfd->sections; sec; sec = sec->next)
696 if (strcmp (sec->name, ".idata\$2") == 0)
698 reloc_count += sec->reloc_count;
701 if (idata2) /* .idata2 is the TOC */
703 else if (reloc_count > 0) /* thunks */
708 new_name = bfd_alloc (is->the_bfd,
709 strlen (is->the_bfd->filename)+2);
710 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
711 is->the_bfd->filename = new_name;
713 new_name = bfd_alloc(is->the_bfd, strlen(is->filename)+2);
714 sprintf (new_name, "%s.%c", is->filename, seq);
715 is->filename = new_name;
723 gld_${EMULATION_NAME}_before_allocation()
725 #ifdef TARGET_IS_ppcpe
726 /* Here we rummage through the found bfds to collect toc information */
728 LANG_FOR_EACH_INPUT_STATEMENT (is)
730 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
732 /* xgettext:c-format */
733 einfo (_("Errors encountered processing file %s\n"), is->filename);
738 /* We have seen it all. Allocate it, and carry on */
739 ppc_allocate_toc_section (&link_info);
740 #endif /* TARGET_IS_ppcpe */
742 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
743 /* FIXME: we should be able to set the size of the interworking stub
746 Here we rummage through the found bfds to collect glue
747 information. FIXME: should this be based on a command line
748 option? krk@cygnus.com */
750 LANG_FOR_EACH_INPUT_STATEMENT (is)
752 if (! bfd_arm_pe_process_before_allocation
753 (is->the_bfd, & link_info, support_old_code))
755 /* xgettext:c-format */
756 einfo (_("Errors encountered processing file %s for interworking"),
762 /* We have seen it all. Allocate it, and carry on */
763 bfd_arm_pe_allocate_interworking_sections (& link_info);
764 #endif /* TARGET_IS_armpe */
768 /* This is called when an input file isn't recognized as a BFD. We
769 check here for .DEF files and pull them in automatically. */
772 saw_option(char *option)
775 for (i=0; init[i].ptr; i++)
776 if (strcmp (init[i].symbol, option) == 0)
777 return init[i].inited;
782 gld_${EMULATION_NAME}_unrecognized_file(entry)
783 lang_input_statement_type *entry;
786 const char *ext = entry->filename + strlen (entry->filename) - 4;
788 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
790 if (pe_def_file == 0)
791 pe_def_file = def_file_empty ();
792 def_file_parse (entry->filename, pe_def_file);
795 int i, buflen=0, len;
797 for (i=0; i<pe_def_file->num_exports; i++)
799 len = strlen(pe_def_file->exports[i].internal_name);
803 buf = (char *) xmalloc (buflen);
804 for (i=0; i<pe_def_file->num_exports; i++)
806 struct bfd_link_hash_entry *h;
807 sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
809 h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true);
810 if (h == (struct bfd_link_hash_entry *) NULL)
811 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
812 if (h->type == bfd_link_hash_new)
814 h->type = bfd_link_hash_undefined;
815 h->u.undef.abfd = NULL;
816 bfd_link_add_undef (link_info.hash, h);
821 /* def_file_print (stdout, pe_def_file); */
822 if (pe_def_file->is_dll == 1)
823 link_info.shared = 1;
825 if (pe_def_file->base_address != (bfd_vma)(-1))
828 pe_data (output_bfd)->pe_opthdr.ImageBase =
829 init[IMAGEBASEOFF].value = pe_def_file->base_address;
830 init[IMAGEBASEOFF].inited = 1;
831 if (image_base_statement)
832 image_base_statement->exp =
833 exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
837 /* Not sure if these *should* be set */
838 if (pe_def_file->version_major != -1)
840 pe.MajorImageVersion = pe_def_file->version_major;
841 pe.MinorImageVersion = pe_def_file->version_minor;
844 if (pe_def_file->stack_reserve != -1
845 && ! saw_option ("__size_of_stack_reserve__"))
847 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
848 if (pe_def_file->stack_commit != -1)
849 pe.SizeOfStackCommit = pe_def_file->stack_commit;
851 if (pe_def_file->heap_reserve != -1
852 && ! saw_option ("__size_of_heap_reserve__"))
854 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
855 if (pe_def_file->heap_commit != -1)
856 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
867 gld_${EMULATION_NAME}_recognized_file(entry)
868 lang_input_statement_type *entry;
871 #ifdef TARGET_IS_i386pe
872 pe_dll_id_target ("pei-i386");
874 if (bfd_get_format (entry->the_bfd) == bfd_object)
876 const char *ext = entry->filename + strlen (entry->filename) - 4;
877 if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
878 return pe_implied_import_dll (entry->filename);
885 gld_${EMULATION_NAME}_finish ()
888 if (link_info.shared)
890 pe_dll_fill_sections (output_bfd, &link_info);
891 if (pe_implib_filename)
892 pe_dll_generate_implib (pe_def_file, pe_implib_filename);
894 if (pe_out_def_filename)
895 pe_dll_generate_def_file (pe_out_def_filename);
900 /* Place an orphan section.
902 We use this to put sections in a reasonable place in the file, and
903 to ensure that they are aligned as required.
905 We handle grouped sections here as well. A section named .foo$nn
906 goes into the output section .foo. All grouped sections are sorted
909 Grouped sections for the default sections are handled by the
910 default linker script using wildcards, and are sorted by
913 static asection *hold_section;
914 static char *hold_section_name;
915 static lang_output_section_statement_type *hold_use;
916 static lang_output_section_statement_type *hold_text;
917 static lang_output_section_statement_type *hold_rdata;
918 static lang_output_section_statement_type *hold_data;
919 static lang_output_section_statement_type *hold_bss;
921 /* Place an orphan section. We use this to put random SHF_ALLOC
922 sections in the right segment. */
926 gld_${EMULATION_NAME}_place_orphan (file, s)
927 lang_input_statement_type *file;
933 if ((s->flags & SEC_ALLOC) == 0)
936 secname = bfd_get_section_name (s->owner, s);
938 /* Look through the script to see where to place this section. */
942 hold_section_name = xstrdup (secname);
943 dollar = strchr (hold_section_name, '$');
948 lang_for_each_statement (gld${EMULATION_NAME}_place_section);
950 if (hold_use == NULL)
952 lang_output_section_statement_type *place;
954 asection *snew, **pps;
955 lang_statement_list_type *old;
956 lang_statement_list_type add;
959 /* Try to put the new output section in a reasonable place based
960 on the section name and section flags. */
962 if ((s->flags & SEC_HAS_CONTENTS) == 0
965 else if ((s->flags & SEC_READONLY) == 0
966 && hold_data != NULL)
968 else if ((s->flags & SEC_CODE) == 0
969 && (s->flags & SEC_READONLY) != 0
970 && hold_rdata != NULL)
972 else if ((s->flags & SEC_READONLY) != 0
973 && hold_text != NULL)
976 /* Choose a unique name for the section. This will be needed if
977 the same section name appears in the input file with
978 different loadable or allocateable characteristics. */
979 outsecname = xstrdup (hold_section_name);
980 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
986 len = strlen (outsecname);
987 newname = xmalloc (len + 5);
988 strcpy (newname, outsecname);
992 sprintf (newname + len, "%d", i);
995 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
998 outsecname = newname;
1001 /* We don't want to free OUTSECNAME, as it may get attached to
1002 the output section statement. */
1004 /* Create the section in the output file, and put it in the
1005 right place. This shuffling is to make the output file look
1007 snew = bfd_make_section (output_bfd, outsecname);
1009 einfo ("%P%F: output format %s cannot represent section called %s\n",
1010 output_bfd->xvec->name, outsecname);
1011 if (place != NULL && place->bfd_section != NULL)
1013 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1016 snew->next = place->bfd_section->next;
1017 place->bfd_section->next = snew;
1020 /* Start building a list of statements for this section. */
1023 lang_list_init (stat_ptr);
1025 if (link_info.relocateable)
1029 /* All sections in an executable must be aligned to a page
1031 address = exp_unop (ALIGN_K,
1032 exp_nameop (NAME, "__section_alignment__"));
1035 lang_enter_output_section_statement (outsecname, address, 0,
1037 (etree_type *) NULL,
1038 (etree_type *) NULL,
1039 (etree_type *) NULL);
1041 hold_use = lang_output_section_statement_lookup (outsecname);
1043 lang_leave_output_section_statement
1044 ((bfd_vma) 0, "*default*",
1045 (struct lang_output_section_phdr_list *) NULL);
1047 /* Now stick the new statement list right after PLACE. */
1050 *add.tail = place->header.next;
1051 place->header.next = add.head;
1058 wild_doit (&hold_use->children, s, hold_use, file);
1061 lang_statement_union_type **pl;
1062 boolean found_dollar;
1063 lang_statement_list_type list;
1065 /* The section name has a '$'. Sort it with the other '$'
1068 found_dollar = false;
1069 for (pl = &hold_use->children.head; *pl != NULL; pl = &(*pl)->next)
1071 lang_input_section_type *ls;
1074 if ((*pl)->header.type != lang_input_section_enum)
1077 ls = &(*pl)->input_section;
1079 lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1080 if (strchr (lname, '$') == NULL)
1087 found_dollar = true;
1088 if (strcmp (secname, lname) < 0)
1093 lang_list_init (&list);
1094 wild_doit (&list, s, hold_use, file);
1095 if (list.head != NULL)
1097 ASSERT (list.head->next == NULL);
1098 list.head->next = *pl;
1103 free (hold_section_name);
1109 gld${EMULATION_NAME}_place_section (s)
1110 lang_statement_union_type *s;
1112 lang_output_section_statement_type *os;
1114 if (s->header.type != lang_output_section_statement_enum)
1117 os = &s->output_section_statement;
1119 if (strcmp (os->name, hold_section_name) == 0
1120 && os->bfd_section != NULL
1121 && ((hold_section->flags & (SEC_LOAD | SEC_ALLOC))
1122 == (os->bfd_section->flags & (SEC_LOAD | SEC_ALLOC))))
1125 if (strcmp (os->name, ".text") == 0)
1127 else if (strcmp (os->name, ".rdata") == 0)
1129 else if (strcmp (os->name, ".data") == 0)
1131 else if (strcmp (os->name, ".bss") == 0)
1136 gld_${EMULATION_NAME}_get_script(isfile)
1139 # Scripts compiled in.
1140 # sed commands to quote an ld script as a C string.
1141 sc="-f ${srcdir}/emultempl/stringify.sed"
1143 cat >>e${EMULATION_NAME}.c <<EOF
1147 if (link_info.relocateable == true && config.build_constructors == true)
1150 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1151 echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1152 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1153 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1154 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1155 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1156 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1157 echo ' ; else return' >> e${EMULATION_NAME}.c
1158 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1159 echo '; }' >> e${EMULATION_NAME}.c
1161 cat >>e${EMULATION_NAME}.c <<EOF
1164 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1166 gld_${EMULATION_NAME}_before_parse,
1169 gld_${EMULATION_NAME}_after_parse,
1170 gld_${EMULATION_NAME}_after_open,
1171 after_allocation_default,
1172 set_output_arch_default,
1173 ldemul_default_target,
1174 gld_${EMULATION_NAME}_before_allocation,
1175 gld_${EMULATION_NAME}_get_script,
1176 "${EMULATION_NAME}",
1178 gld_${EMULATION_NAME}_finish, /* finish */
1179 NULL, /* create output section statements */
1180 NULL, /* open dynamic archive */
1181 gld_${EMULATION_NAME}_place_orphan,
1182 gld_${EMULATION_NAME}_set_symbols,
1183 gld_${EMULATION_NAME}_parse_args,
1184 gld_${EMULATION_NAME}_unrecognized_file,
1185 gld_${EMULATION_NAME}_list_options,
1186 gld_${EMULATION_NAME}_recognized_file