2005-09-01 Dmitry Diky <diwil@spec.ru>
[binutils.git] / ld / emultempl / pe.em
blobdf7692d680c169052d99cc8a1306482dc00d2882
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    2005 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, 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)
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 = -1;
140 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
141 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
142   lang_default_entry ("WinMainCRTStartup");
143 #else
144   lang_default_entry ("_WinMainCRTStartup");
145 #endif
146 #endif
147 #endif
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)
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));
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
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[] =
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 }
298 static void
299 gld_${EMULATION_NAME}_list_options (FILE *file)
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"));
352 static void
353 set_pe_name (char *name, long val)
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 ();
371 static void
372 set_pe_subsystem (void)
374   const char *sver;
375   const char *entry;
376   const char *initial_symbol_char;
377   char *end;
378   int len;
379   int i;
380   int subsystem;
381   unsigned long temp_subsystem;
382   static const struct
383     {
384       const char *name;
385       const int value;
386       const char *entry;
387     }
388   v[] =
389     {
390       { "native",  1, "NtProcessStartup" },
391       { "windows", 2, "WinMainCRTStartup" },
392       { "console", 3, "mainCRTStartup" },
393       { "posix",   7, "__PosixProcessStartup"},
394       { "wince",   9, "_WinMainCRTStartup" },
395       { "xbox",   14, "mainCRTStartup" },
396       { NULL, 0, NULL }
397     };
398   /* Entry point name for arbitrary subsystem numbers.  */
399   static const char default_entry[] = "mainCRTStartup";
401   /* Check for the presence of a version number.  */
402   sver = strchr (optarg, ':');
403   if (sver == NULL)
404     len = strlen (optarg);
405   else
406     {
407       len = sver - optarg;
408       set_pe_name ("__major_subsystem_version__",
409                    strtoul (sver + 1, &end, 0));
410       if (*end == '.')
411         set_pe_name ("__minor_subsystem_version__",
412                      strtoul (end + 1, &end, 0));
413       if (*end != '\0')
414         einfo (_("%P: warning: bad version number in -subsystem option\n"));
415     }
417   /* Check for numeric subsystem.  */
418   temp_subsystem = strtoul (optarg, & end, 0);
419   if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
420     {
421       /* Search list for a numeric match to use its entry point.  */
422       for (i = 0; v[i].name; i++)
423         if (v[i].value == (int) temp_subsystem)
424           break;
426       /* If no match, use the default.  */
427       if (v[i].name != NULL)
428         entry = v[i].entry;
429       else
430         entry = default_entry;
432       /* Use this subsystem.  */
433       subsystem = (int) temp_subsystem;
434     }
435   else
436     {
437       /* Search for subsystem by name.  */
438       for (i = 0; v[i].name; i++)
439         if (strncmp (optarg, v[i].name, len) == 0
440             && v[i].name[len] == '\0')
441           break;
443       if (v[i].name == NULL)
444         {
445           einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
446           return;
447         }
449       entry = v[i].entry;
450       subsystem = v[i].value;
451     }
453   set_pe_name ("__subsystem__", subsystem);
455   initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
456   if (*initial_symbol_char != '\0')
457     {
458       char *alc_entry;
460       /* lang_default_entry expects its argument to be permanently
461          allocated, so we don't free this string.  */
462       alc_entry = xmalloc (strlen (initial_symbol_char)
463                            + strlen (entry)
464                            + 1);
465       strcpy (alc_entry, initial_symbol_char);
466       strcat (alc_entry, entry);
467       entry = alc_entry;
468     }
470   lang_default_entry (entry);
472   return;
476 static void
477 set_pe_value (char *name)
479   char *end;
481   set_pe_name (name,  strtoul (optarg, &end, 0));
483   if (end == optarg)
484     einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
486   optarg = end;
490 static void
491 set_pe_stack_heap (char *resname, char *comname)
493   set_pe_value (resname);
495   if (*optarg == ',')
496     {
497       optarg++;
498       set_pe_value (comname);
499     }
500   else if (*optarg)
501     einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
505 static bfd_boolean
506 gld${EMULATION_NAME}_handle_option (int optc)
508   switch (optc)
509     {
510     default:
511       return FALSE;
513     case OPTION_BASE_FILE:
514       link_info.base_file = fopen (optarg, FOPEN_WB);
515       if (link_info.base_file == NULL)
516         {
517           /* xgettext:c-format */
518           fprintf (stderr, _("%s: Can't open base file %s\n"),
519                    program_name, optarg);
520           xexit (1);
521         }
522       break;
524       /* PE options.  */
525     case OPTION_HEAP:
526       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
527       break;
528     case OPTION_STACK:
529       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
530       break;
531     case OPTION_SUBSYSTEM:
532       set_pe_subsystem ();
533       break;
534     case OPTION_MAJOR_OS_VERSION:
535       set_pe_value ("__major_os_version__");
536       break;
537     case OPTION_MINOR_OS_VERSION:
538       set_pe_value ("__minor_os_version__");
539       break;
540     case OPTION_MAJOR_SUBSYSTEM_VERSION:
541       set_pe_value ("__major_subsystem_version__");
542       break;
543     case OPTION_MINOR_SUBSYSTEM_VERSION:
544       set_pe_value ("__minor_subsystem_version__");
545       break;
546     case OPTION_MAJOR_IMAGE_VERSION:
547       set_pe_value ("__major_image_version__");
548       break;
549     case OPTION_MINOR_IMAGE_VERSION:
550       set_pe_value ("__minor_image_version__");
551       break;
552     case OPTION_FILE_ALIGNMENT:
553       set_pe_value ("__file_alignment__");
554       break;
555     case OPTION_SECTION_ALIGNMENT:
556       set_pe_value ("__section_alignment__");
557       break;
558     case OPTION_DLL:
559       set_pe_name ("__dll__", 1);
560       break;
561     case OPTION_IMAGE_BASE:
562       set_pe_value ("__image_base__");
563       break;
564     case OPTION_SUPPORT_OLD_CODE:
565       support_old_code = 1;
566       break;
567     case OPTION_THUMB_ENTRY:
568       thumb_entry_symbol = optarg;
569       break;
570 #ifdef DLL_SUPPORT
571     case OPTION_OUT_DEF:
572       pe_out_def_filename = xstrdup (optarg);
573       break;
574     case OPTION_EXPORT_ALL:
575       pe_dll_export_everything = 1;
576       break;
577     case OPTION_EXCLUDE_SYMBOLS:
578       pe_dll_add_excludes (optarg, 0);
579       break;
580     case OPTION_EXCLUDE_LIBS:
581       pe_dll_add_excludes (optarg, 1);
582       break;
583     case OPTION_KILL_ATS:
584       pe_dll_kill_ats = 1;
585       break;
586     case OPTION_STDCALL_ALIASES:
587       pe_dll_stdcall_aliases = 1;
588       break;
589     case OPTION_ENABLE_STDCALL_FIXUP:
590       pe_enable_stdcall_fixup = 1;
591       break;
592     case OPTION_DISABLE_STDCALL_FIXUP:
593       pe_enable_stdcall_fixup = 0;
594       break;
595     case OPTION_IMPLIB_FILENAME:
596       pe_implib_filename = xstrdup (optarg);
597       break;
598     case OPTION_WARN_DUPLICATE_EXPORTS:
599       pe_dll_warn_dup_exports = 1;
600       break;
601     case OPTION_IMP_COMPAT:
602       pe_dll_compat_implib = 1;
603       break;
604     case OPTION_ENABLE_AUTO_IMAGE_BASE:
605       pe_enable_auto_image_base = 1;
606       break;
607     case OPTION_DISABLE_AUTO_IMAGE_BASE:
608       pe_enable_auto_image_base = 0;
609       break;
610     case OPTION_DLL_SEARCH_PREFIX:
611       pe_dll_search_prefix = xstrdup (optarg);
612       break;
613     case OPTION_NO_DEFAULT_EXCLUDES:
614       pe_dll_do_default_excludes = 0;
615       break;
616     case OPTION_DLL_ENABLE_AUTO_IMPORT:
617       link_info.pei386_auto_import = 1;
618       break;
619     case OPTION_DLL_DISABLE_AUTO_IMPORT:
620       link_info.pei386_auto_import = 0;
621       break;
622     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
623       link_info.pei386_runtime_pseudo_reloc = 1;
624       break;
625     case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
626       link_info.pei386_runtime_pseudo_reloc = 0;
627       break;
628     case OPTION_ENABLE_EXTRA_PE_DEBUG:
629       pe_dll_extra_pe_debug = 1;
630       break;
631 #endif
632     case OPTION_LARGE_ADDRESS_AWARE:
633       real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
634       break;
635     }
636   return TRUE;
640 #ifdef DLL_SUPPORT
641 static unsigned long
642 strhash (const char *str)
644   const unsigned char *s;
645   unsigned long hash;
646   unsigned int c;
647   unsigned int len;
649   hash = 0;
650   len = 0;
651   s = (const unsigned char *) str;
652   while ((c = *s++) != '\0')
653     {
654       hash += c + (c << 17);
655       hash ^= hash >> 2;
656       ++len;
657     }
658   hash += len + (len << 17);
659   hash ^= hash >> 2;
661   return hash;
664 /* Use the output file to create a image base for relocatable DLLs.  */
666 static unsigned long
667 compute_dll_image_base (const char *ofile)
669   unsigned long hash = strhash (ofile);
670   return 0x61300000 + ((hash << 16) & 0x0FFC0000);
672 #endif
674 /* Assign values to the special symbols before the linker script is
675    read.  */
677 static void
678 gld_${EMULATION_NAME}_set_symbols (void)
680   /* Run through and invent symbols for all the
681      names and insert the defaults.  */
682   int j;
683   lang_statement_list_type *save;
685   if (!init[IMAGEBASEOFF].inited)
686     {
687       if (link_info.relocatable)
688         init[IMAGEBASEOFF].value = 0;
689       else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
690 #ifdef DLL_SUPPORT
691         init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
692           compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
693 #else
694         init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
695 #endif
696       else
697         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
698     }
700   /* Don't do any symbol assignments if this is a relocatable link.  */
701   if (link_info.relocatable)
702     return;
704   /* Glue the assignments into the abs section.  */
705   save = stat_ptr;
707   stat_ptr = &(abs_output_section->children);
709   for (j = 0; init[j].ptr; j++)
710     {
711       long val = init[j].value;
712       lang_assignment_statement_type *rv;
713       rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
714                                            exp_intop (val)));
715       if (init[j].size == sizeof (short))
716         *(short *) init[j].ptr = val;
717       else if (init[j].size == sizeof (int))
718         *(int *) init[j].ptr = val;
719       else if (init[j].size == sizeof (long))
720         *(long *) init[j].ptr = val;
721       /* This might be a long long or other special type.  */
722       else if (init[j].size == sizeof (bfd_vma))
723         *(bfd_vma *) init[j].ptr = val;
724       else      abort ();
725       if (j == IMAGEBASEOFF)
726         image_base_statement = rv;
727     }
728   /* Restore the pointer.  */
729   stat_ptr = save;
731   if (pe.FileAlignment >
732       pe.SectionAlignment)
733     {
734       einfo (_("%P: warning, file alignment > section alignment.\n"));
735     }
738 /* This is called after the linker script and the command line options
739    have been read.  */
741 static void
742 gld_${EMULATION_NAME}_after_parse (void)
744   /* The Windows libraries are designed for the linker to treat the
745      entry point as an undefined symbol.  Otherwise, the .obj that
746      defines mainCRTStartup is brought in because it is the first
747      encountered in libc.lib and it has other symbols in it which will
748      be pulled in by the link process.  To avoid this, we act as
749      though the user specified -u with the entry point symbol.
751      This function is called after the linker script and command line
752      options have been read, so at this point we know the right entry
753      point.  This function is called before the input files are
754      opened, so registering the symbol as undefined will make a
755      difference.  */
757   if (! link_info.relocatable && entry_symbol.name != NULL)
758     ldlang_add_undef (entry_symbol.name);
761 /* pe-dll.c directly accesses pe_data_import_dll,
762    so it must be defined outside of #ifdef DLL_SUPPORT.
763    Note - this variable is deliberately not initialised.
764    This allows it to be treated as a common varaible, and only
765    exist in one incarnation in a multiple target enabled linker.  */
766 char * pe_data_import_dll;
768 #ifdef DLL_SUPPORT
769 static struct bfd_link_hash_entry *pe_undef_found_sym;
771 static bfd_boolean
772 pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
774   int sl;
775   char *string = inf;
777   sl = strlen (string);
778   if (h->type == bfd_link_hash_defined
779       && strncmp (h->root.string, string, sl) == 0
780       && h->root.string[sl] == '@')
781     {
782       pe_undef_found_sym = h;
783       return FALSE;
784     }
785   return TRUE;
788 static void
789 pe_fixup_stdcalls (void)
791   static int gave_warning_message = 0;
792   struct bfd_link_hash_entry *undef, *sym;
794   if (pe_dll_extra_pe_debug)
795     printf ("%s\n", __FUNCTION__);
797   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
798     if (undef->type == bfd_link_hash_undefined)
799       {
800         char* at = strchr (undef->root.string, '@');
801         int lead_at = (*undef->root.string == '@');
802         /* For now, don't try to fixup fastcall symbols.  */
804         if (at && !lead_at)
805           {
806             /* The symbol is a stdcall symbol, so let's look for a
807                cdecl symbol with the same name and resolve to that.  */
808             char *cname = xstrdup (undef->root.string /* + lead_at */);
809             at = strchr (cname, '@');
810             *at = 0;
811             sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
813             if (sym && sym->type == bfd_link_hash_defined)
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, cname);
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         else
833           {
834             /* The symbol is a cdecl symbol, so we look for stdcall
835                symbols - which means scanning the whole symbol table.  */
836             pe_undef_found_sym = 0;
837             bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
838                                     (char *) undef->root.string);
839             sym = pe_undef_found_sym;
840             if (sym)
841               {
842                 undef->type = bfd_link_hash_defined;
843                 undef->u.def.value = sym->u.def.value;
844                 undef->u.def.section = sym->u.def.section;
846                 if (pe_enable_stdcall_fixup == -1)
847                   {
848                     einfo (_("Warning: resolving %s by linking to %s\n"),
849                            undef->root.string, sym->root.string);
850                     if (! gave_warning_message)
851                       {
852                         gave_warning_message = 1;
853                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
854                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
855                       }
856                   }
857               }
858           }
859       }
862 static int
863 make_import_fixup (arelent *rel, asection *s)
865   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
866   char addend[4];
868   if (pe_dll_extra_pe_debug)
869     printf ("arelent: %s@%#lx: add=%li\n", sym->name,
870             (long) rel->address, (long) rel->addend);
872   if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
873     einfo (_("%C: Cannot get section contents - auto-import exception\n"),
874            s->owner, s, rel->address);
876   pe_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));
878   return 1;
881 static void
882 pe_find_data_imports (void)
884   struct bfd_link_hash_entry *undef, *sym;
886   if (link_info.pei386_auto_import == 0)
887     return;
889   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
890     {
891       if (undef->type == bfd_link_hash_undefined)
892         {
893           /* C++ symbols are *long*.  */
894           char buf[4096];
896           if (pe_dll_extra_pe_debug)
897             printf ("%s:%s\n", __FUNCTION__, undef->root.string);
899           sprintf (buf, "__imp_%s", undef->root.string);
901           sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
903           if (sym && sym->type == bfd_link_hash_defined)
904             {
905               bfd *b = sym->u.def.section->owner;
906               asymbol **symbols;
907               int nsyms, symsize, i;
909               if (link_info.pei386_auto_import == -1)
910                 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
911                           undef->root.string, buf);
913               symsize = bfd_get_symtab_upper_bound (b);
914               symbols = (asymbol **) xmalloc (symsize);
915               nsyms = bfd_canonicalize_symtab (b, symbols);
917               for (i = 0; i < nsyms; i++)
918                 {
919                   if (memcmp (symbols[i]->name, "__head_",
920                               sizeof ("__head_") - 1))
921                     continue;
923                   if (pe_dll_extra_pe_debug)
924                     printf ("->%s\n", symbols[i]->name);
926                   pe_data_import_dll = (char*) (symbols[i]->name +
927                                                 sizeof ("__head_") - 1);
928                   break;
929                 }
931               pe_walk_relocs_of_symbol (&link_info, undef->root.string,
932                                         make_import_fixup);
934               /* Let's differentiate it somehow from defined.  */
935               undef->type = bfd_link_hash_defweak;
936               /* We replace original name with __imp_ prefixed, this
937                  1) may trash memory 2) leads to duplicate symbol generation.
938                  Still, IMHO it's better than having name poluted.  */
939               undef->root.string = sym->root.string;
940               undef->u.def.value = sym->u.def.value;
941               undef->u.def.section = sym->u.def.section;
942             }
943         }
944     }
947 static bfd_boolean
948 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
950   if (pe_dll_extra_pe_debug)
951     printf ("+%s\n", h->string);
953   return TRUE;
955 #endif /* DLL_SUPPORT */
958 static void
959 gld_${EMULATION_NAME}_after_open (void)
961 #ifdef DLL_SUPPORT
962   if (pe_dll_extra_pe_debug)
963     {
964       bfd *a;
965       struct bfd_link_hash_entry *sym;
967       printf ("%s()\n", __FUNCTION__);
969       for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
970         printf ("-%s\n", sym->root.string);
971       bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
973       for (a = link_info.input_bfds; a; a = a->link_next)
974         printf ("*%s\n",a->filename);
975     }
976 #endif
978   /* Pass the wacky PE command line options into the output bfd.
979      FIXME: This should be done via a function, rather than by
980      including an internal BFD header.  */
982   if (coff_data (output_bfd) == NULL || coff_data (output_bfd)->pe == 0)
983     einfo (_("%F%P: PE operations on non PE file.\n"));
985   pe_data (output_bfd)->pe_opthdr = pe;
986   pe_data (output_bfd)->dll = init[DLLOFF].value;
987   pe_data (output_bfd)->real_flags |= real_flags;
989 #ifdef DLL_SUPPORT
990   if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
991     pe_fixup_stdcalls ();
993   pe_process_import_defs (output_bfd, & link_info);
995   pe_find_data_imports ();
997 #if ! (defined (TARGET_IS_i386pe) || defined (TARGET_IS_armpe))
998   if (link_info.shared)
999 #else
1000   if (!link_info.relocatable)
1001 #endif
1002     pe_dll_build_sections (output_bfd, &link_info);
1004 #ifndef TARGET_IS_i386pe
1005 #ifndef TARGET_IS_armpe
1006   else
1007     pe_exe_build_sections (output_bfd, &link_info);
1008 #endif
1009 #endif
1010 #endif
1012 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1013   if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
1014     {
1015       /* The arm backend needs special fields in the output hash structure.
1016          These will only be created if the output format is an arm format,
1017          hence we do not support linking and changing output formats at the
1018          same time.  Use a link followed by objcopy to change output formats.  */
1019       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1020       return;
1021     }
1022   {
1023     /* Find a BFD that can hold the interworking stubs.  */
1024     LANG_FOR_EACH_INPUT_STATEMENT (is)
1025       {
1026         if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
1027           break;
1028       }
1029   }
1030 #endif
1032   {
1033     /* This next chunk of code tries to detect the case where you have
1034        two import libraries for the same DLL (specifically,
1035        symbolically linking libm.a and libc.a in cygwin to
1036        libcygwin.a).  In those cases, it's possible for function
1037        thunks from the second implib to be used but without the
1038        head/tail objects, causing an improper import table.  We detect
1039        those cases and rename the "other" import libraries to match
1040        the one the head/tail come from, so that the linker will sort
1041        things nicely and produce a valid import table.  */
1043     LANG_FOR_EACH_INPUT_STATEMENT (is)
1044       {
1045         if (is->the_bfd->my_archive)
1046           {
1047             int idata2 = 0, reloc_count=0, is_imp = 0;
1048             asection *sec;
1050             /* See if this is an import library thunk.  */
1051             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1052               {
1053                 if (strcmp (sec->name, ".idata\$2") == 0)
1054                   idata2 = 1;
1055                 if (strncmp (sec->name, ".idata\$", 7) == 0)
1056                   is_imp = 1;
1057                 reloc_count += sec->reloc_count;
1058               }
1060             if (is_imp && !idata2 && reloc_count)
1061               {
1062                 /* It is, look for the reference to head and see if it's
1063                    from our own library.  */
1064                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1065                   {
1066                     int i;
1067                     long symsize;
1068                     long relsize;
1069                     asymbol **symbols;
1070                     arelent **relocs;
1071                     int nrelocs;
1073                     symsize = bfd_get_symtab_upper_bound (is->the_bfd);
1074                     if (symsize < 1)
1075                       break;
1076                     relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1077                     if (relsize < 1)
1078                       break;
1080                     symbols = (asymbol **) xmalloc (symsize);
1081                     symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
1082                     if (symsize < 0)
1083                       {
1084                         einfo ("%X%P: unable to process symbols: %E");
1085                         return;
1086                       }
1088                     relocs = (arelent **) xmalloc ((size_t) relsize);
1089                     nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1090                                                       relocs, symbols);
1091                     if (nrelocs < 0)
1092                       {
1093                         free (relocs);
1094                         einfo ("%X%P: unable to process relocs: %E");
1095                         return;
1096                       }
1098                     for (i = 0; i < nrelocs; i++)
1099                       {
1100                         struct bfd_symbol *s;
1101                         struct bfd_link_hash_entry * blhe;
1102                         char *other_bfd_filename;
1103                         char *n;
1105                         s = (relocs[i]->sym_ptr_ptr)[0];
1107                         if (s->flags & BSF_LOCAL)
1108                           continue;
1110                         /* Thunk section with reloc to another bfd.  */
1111                         blhe = bfd_link_hash_lookup (link_info.hash,
1112                                                      s->name,
1113                                                      FALSE, FALSE, TRUE);
1115                         if (blhe == NULL
1116                             || blhe->type != bfd_link_hash_defined)
1117                           continue;
1119                         other_bfd_filename
1120                           = blhe->u.def.section->owner->my_archive
1121                             ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1122                             : bfd_get_filename (blhe->u.def.section->owner);
1124                         if (strcmp (bfd_get_filename (is->the_bfd->my_archive),
1125                                     other_bfd_filename) == 0)
1126                           continue;
1128                         /* Rename this implib to match the other one.  */
1129                         n = xmalloc (strlen (other_bfd_filename) + 1);
1130                         strcpy (n, other_bfd_filename);
1131                         is->the_bfd->my_archive->filename = n;
1132                       }
1134                     free (relocs);
1135                     /* Note - we do not free the symbols,
1136                        they are now cached in the BFD.  */
1137                   }
1138               }
1139           }
1140       }
1141   }
1143   {
1144     int is_ms_arch = 0;
1145     bfd *cur_arch = 0;
1146     lang_input_statement_type *is2;
1147     lang_input_statement_type *is3;
1149     /* Careful - this is a shell script.  Watch those dollar signs! */
1150     /* Microsoft import libraries have every member named the same,
1151        and not in the right order for us to link them correctly.  We
1152        must detect these and rename the members so that they'll link
1153        correctly.  There are three types of objects: the head, the
1154        thunks, and the sentinel(s).  The head is easy; it's the one
1155        with idata2.  We assume that the sentinels won't have relocs,
1156        and the thunks will.  It's easier than checking the symbol
1157        table for external references.  */
1158     LANG_FOR_EACH_INPUT_STATEMENT (is)
1159       {
1160         if (is->the_bfd->my_archive)
1161           {
1162             char *pnt;
1163             bfd *arch = is->the_bfd->my_archive;
1165             if (cur_arch != arch)
1166               {
1167                 cur_arch = arch;
1168                 is_ms_arch = 1;
1170                 for (is3 = is;
1171                      is3 && is3->the_bfd->my_archive == arch;
1172                      is3 = (lang_input_statement_type *) is3->next)
1173                   {
1174                     /* A MS dynamic import library can also contain static
1175                        members, so look for the first element with a .dll
1176                        extension, and use that for the remainder of the
1177                        comparisons.  */
1178                     pnt = strrchr (is3->the_bfd->filename, '.');
1179                     if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1180                       break;
1181                   }
1183                 if (is3 == NULL)
1184                   is_ms_arch = 0;
1185                 else
1186                   {
1187                     /* OK, found one.  Now look to see if the remaining
1188                        (dynamic import) members use the same name.  */
1189                     for (is2 = is;
1190                          is2 && is2->the_bfd->my_archive == arch;
1191                          is2 = (lang_input_statement_type *) is2->next)
1192                       {
1193                         /* Skip static members, ie anything with a .obj
1194                            extension.  */
1195                         pnt = strrchr (is2->the_bfd->filename, '.');
1196                         if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1197                           continue;
1199                         if (strcmp (is3->the_bfd->filename,
1200                                     is2->the_bfd->filename))
1201                           {
1202                             is_ms_arch = 0;
1203                             break;
1204                           }
1205                       }
1206                   }
1207               }
1209             /* This fragment might have come from an .obj file in a Microsoft
1210                import, and not an actual import record. If this is the case,
1211                then leave the filename alone.  */
1212             pnt = strrchr (is->the_bfd->filename, '.');
1214             if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1215               {
1216                 int idata2 = 0, reloc_count=0;
1217                 asection *sec;
1218                 char *new_name, seq;
1220                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1221                   {
1222                     if (strcmp (sec->name, ".idata\$2") == 0)
1223                       idata2 = 1;
1224                     reloc_count += sec->reloc_count;
1225                   }
1227                 if (idata2) /* .idata2 is the TOC */
1228                   seq = 'a';
1229                 else if (reloc_count > 0) /* thunks */
1230                   seq = 'b';
1231                 else /* sentinel */
1232                   seq = 'c';
1234                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1235                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1236                 is->the_bfd->filename = new_name;
1238                 new_name = xmalloc (strlen (is->filename) + 3);
1239                 sprintf (new_name, "%s.%c", is->filename, seq);
1240                 is->filename = new_name;
1241               }
1242           }
1243       }
1244   }
1247 static void
1248 gld_${EMULATION_NAME}_before_allocation (void)
1250 #ifdef TARGET_IS_ppcpe
1251   /* Here we rummage through the found bfds to collect toc information.  */
1252   {
1253     LANG_FOR_EACH_INPUT_STATEMENT (is)
1254       {
1255         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1256           {
1257             /* xgettext:c-format */
1258             einfo (_("Errors encountered processing file %s\n"), is->filename);
1259           }
1260       }
1261   }
1263   /* We have seen it all. Allocate it, and carry on.  */
1264   ppc_allocate_toc_section (&link_info);
1265 #endif /* TARGET_IS_ppcpe */
1267 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1268   /* FIXME: we should be able to set the size of the interworking stub
1269      section.
1271      Here we rummage through the found bfds to collect glue
1272      information.  FIXME: should this be based on a command line
1273      option?  krk@cygnus.com.  */
1274   {
1275     LANG_FOR_EACH_INPUT_STATEMENT (is)
1276       {
1277         if (! bfd_arm_pe_process_before_allocation
1278             (is->the_bfd, & link_info, support_old_code))
1279           {
1280             /* xgettext:c-format */
1281             einfo (_("Errors encountered processing file %s for interworking"),
1282                    is->filename);
1283           }
1284       }
1285   }
1287   /* We have seen it all. Allocate it, and carry on.  */
1288   bfd_arm_pe_allocate_interworking_sections (& link_info);
1289 #endif /* TARGET_IS_armpe */
1291   before_allocation_default ();
1294 #ifdef DLL_SUPPORT
1295 /* This is called when an input file isn't recognized as a BFD.  We
1296    check here for .DEF files and pull them in automatically.  */
1298 static int
1299 saw_option (char *option)
1301   int i;
1303   for (i = 0; init[i].ptr; i++)
1304     if (strcmp (init[i].symbol, option) == 0)
1305       return init[i].inited;
1306   return 0;
1308 #endif /* DLL_SUPPORT */
1310 static bfd_boolean
1311 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1313 #ifdef DLL_SUPPORT
1314   const char *ext = entry->filename + strlen (entry->filename) - 4;
1316   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1317     {
1318       pe_def_file = def_file_parse (entry->filename, pe_def_file);
1320       if (pe_def_file)
1321         {
1322           int i, buflen=0, len;
1323           char *buf;
1325           for (i = 0; i < pe_def_file->num_exports; i++)
1326             {
1327               len = strlen (pe_def_file->exports[i].internal_name);
1328               if (buflen < len + 2)
1329                 buflen = len + 2;
1330             }
1332           buf = (char *) xmalloc (buflen);
1334           for (i = 0; i < pe_def_file->num_exports; i++)
1335             {
1336               struct bfd_link_hash_entry *h;
1338               sprintf (buf, "_%s", pe_def_file->exports[i].internal_name);
1340               h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1341               if (h == (struct bfd_link_hash_entry *) NULL)
1342                 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1343               if (h->type == bfd_link_hash_new)
1344                 {
1345                   h->type = bfd_link_hash_undefined;
1346                   h->u.undef.abfd = NULL;
1347                   bfd_link_add_undef (link_info.hash, h);
1348                 }
1349             }
1350           free (buf);
1352           /* def_file_print (stdout, pe_def_file); */
1353           if (pe_def_file->is_dll == 1)
1354             link_info.shared = 1;
1356           if (pe_def_file->base_address != (bfd_vma)(-1))
1357             {
1358               pe.ImageBase =
1359                 pe_data (output_bfd)->pe_opthdr.ImageBase =
1360                 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1361               init[IMAGEBASEOFF].inited = 1;
1362               if (image_base_statement)
1363                 image_base_statement->exp =
1364                   exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1365             }
1367           if (pe_def_file->stack_reserve != -1
1368               && ! saw_option ("__size_of_stack_reserve__"))
1369             {
1370               pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1371               if (pe_def_file->stack_commit != -1)
1372                 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1373             }
1374           if (pe_def_file->heap_reserve != -1
1375               && ! saw_option ("__size_of_heap_reserve__"))
1376             {
1377               pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1378               if (pe_def_file->heap_commit != -1)
1379                 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1380             }
1381           return TRUE;
1382         }
1383     }
1384 #endif
1385   return FALSE;
1388 static bfd_boolean
1389 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1391 #ifdef DLL_SUPPORT
1392 #ifdef TARGET_IS_i386pe
1393   pe_dll_id_target ("pei-i386");
1394 #endif
1395 #ifdef TARGET_IS_shpe
1396   pe_dll_id_target ("pei-shl");
1397 #endif
1398 #ifdef TARGET_IS_mipspe
1399   pe_dll_id_target ("pei-mips");
1400 #endif
1401 #ifdef TARGET_IS_armpe
1402   pe_dll_id_target ("pei-arm-little");
1403 #endif
1404   if (bfd_get_format (entry->the_bfd) == bfd_object)
1405     {
1406       char fbuf[LD_PATHMAX + 1];
1407       const char *ext;
1409       if (REALPATH (entry->filename, fbuf) == NULL)
1410         strncpy (fbuf, entry->filename, sizeof (fbuf));
1412       ext = fbuf + strlen (fbuf) - 4;
1414       if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1415         return pe_implied_import_dll (fbuf);
1416     }
1417 #endif
1418   return FALSE;
1421 static void
1422 gld_${EMULATION_NAME}_finish (void)
1424 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1425   struct bfd_link_hash_entry * h;
1427   if (thumb_entry_symbol != NULL)
1428     {
1429       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1430                                 FALSE, FALSE, TRUE);
1432       if (h != (struct bfd_link_hash_entry *) NULL
1433           && (h->type == bfd_link_hash_defined
1434               || h->type == bfd_link_hash_defweak)
1435           && h->u.def.section->output_section != NULL)
1436         {
1437           static char buffer[32];
1438           bfd_vma val;
1440           /* Special procesing is required for a Thumb entry symbol.  The
1441              bottom bit of its address must be set.  */
1442           val = (h->u.def.value
1443                  + bfd_get_section_vma (output_bfd,
1444                                         h->u.def.section->output_section)
1445                  + h->u.def.section->output_offset);
1447           val |= 1;
1449           /* Now convert this value into a string and store it in entry_symbol
1450              where the lang_finish() function will pick it up.  */
1451           buffer[0] = '0';
1452           buffer[1] = 'x';
1454           sprintf_vma (buffer + 2, val);
1456           if (entry_symbol.name != NULL && entry_from_cmdline)
1457             einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1458                    thumb_entry_symbol, entry_symbol.name);
1459           entry_symbol.name = buffer;
1460         }
1461       else
1462         einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1463     }
1464 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1466   finish_default ();
1468 #ifdef DLL_SUPPORT
1469   if (link_info.shared
1470 #if !defined(TARGET_IS_shpe) && !defined(TARGET_IS_mipspe)
1471     || (!link_info.relocatable && pe_def_file->num_exports != 0)
1472 #endif
1473     )
1474     {
1475       pe_dll_fill_sections (output_bfd, &link_info);
1476       if (pe_implib_filename)
1477         pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1478     }
1479 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1480   /* ARM doesn't need relocs.  */
1481   else
1482     {
1483       pe_exe_fill_sections (output_bfd, &link_info);
1484     }
1485 #endif
1487   if (pe_out_def_filename)
1488     pe_dll_generate_def_file (pe_out_def_filename);
1489 #endif /* DLL_SUPPORT */
1491   /* I don't know where .idata gets set as code, but it shouldn't be.  */
1492   {
1493     asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1495     if (asec)
1496       {
1497         asec->flags &= ~SEC_CODE;
1498         asec->flags |= SEC_DATA;
1499       }
1500   }
1504 /* Place an orphan section.
1506    We use this to put sections in a reasonable place in the file, and
1507    to ensure that they are aligned as required.
1509    We handle grouped sections here as well.  A section named .foo$nn
1510    goes into the output section .foo.  All grouped sections are sorted
1511    by name.
1513    Grouped sections for the default sections are handled by the
1514    default linker script using wildcards, and are sorted by
1515    sort_sections.  */
1517 static bfd_boolean
1518 gld_${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1520   const char *secname;
1521   const char *orig_secname;
1522   char *dollar = NULL;
1523   lang_output_section_statement_type *os;
1524   lang_statement_list_type add_child;
1526   secname = bfd_get_section_name (s->owner, s);
1528   /* Look through the script to see where to place this section.  */
1529   orig_secname = secname;
1530   if (!link_info.relocatable
1531       && (dollar = strchr (secname, '$')) != NULL)
1532     {
1533       size_t len = dollar - orig_secname;
1534       char *newname = xmalloc (len + 1);
1535       memcpy (newname, orig_secname, len);
1536       newname[len] = '\0';
1537       secname = newname;
1538     }
1540   os = lang_output_section_find (secname);
1542   lang_list_init (&add_child);
1544   if (os != NULL
1545       && (os->bfd_section == NULL
1546           || os->bfd_section->flags == 0
1547           || ((s->flags ^ os->bfd_section->flags)
1548               & (SEC_LOAD | SEC_ALLOC)) == 0))
1549     {
1550       /* We already have an output section statement with this
1551          name, and its bfd section, if any, has compatible flags.
1552          If the section already exists but does not have any flags set,
1553          then it has been created by the linker, probably as a result of
1554          a --section-start command line switch.  */
1555       lang_add_section (&add_child, s, os, file);
1556     }
1557   else
1558     {
1559       static struct orphan_save hold[] =
1560         {
1561           { ".text",
1562             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1563             0, 0, 0, 0 },
1564           { ".rdata",
1565             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1566             0, 0, 0, 0 },
1567           { ".data",
1568             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1569             0, 0, 0, 0 },
1570           { ".bss",
1571             SEC_ALLOC,
1572             0, 0, 0, 0 }
1573         };
1574       enum orphan_save_index
1575         {
1576           orphan_text = 0,
1577           orphan_rodata,
1578           orphan_data,
1579           orphan_bss
1580         };
1581       static int orphan_init_done = 0;
1582       struct orphan_save *place;
1583       lang_output_section_statement_type *after;
1584       etree_type *address;
1586       if (!orphan_init_done)
1587         {
1588           struct orphan_save *ho;
1589           for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1590             if (ho->name != NULL)
1591               {
1592                 ho->os = lang_output_section_find (ho->name);
1593                 if (ho->os != NULL && ho->os->flags == 0)
1594                   ho->os->flags = ho->flags;
1595               }
1596           orphan_init_done = 1;
1597         }
1599       /* Try to put the new output section in a reasonable place based
1600          on the section name and section flags.  */
1602       place = NULL;
1603       if ((s->flags & SEC_ALLOC) == 0)
1604         ;
1605       else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1606         place = &hold[orphan_bss];
1607       else if ((s->flags & SEC_READONLY) == 0)
1608         place = &hold[orphan_data];
1609       else if ((s->flags & SEC_CODE) == 0)
1610         place = &hold[orphan_rodata];
1611       else
1612         place = &hold[orphan_text];
1614       after = NULL;
1615       if (place != NULL)
1616         {
1617           if (place->os == NULL)
1618             place->os = lang_output_section_find (place->name);
1619           after = place->os;
1620           if (after == NULL)
1621             after = lang_output_section_find_by_flags (s, &place->os);
1622           if (after == NULL)
1623             /* *ABS* is always the first output section statement.  */
1624             after = (&lang_output_section_statement.head
1625                      ->output_section_statement);
1626         }
1628       /* Choose a unique name for the section.  This will be needed if the
1629          same section name appears in the input file with different
1630          loadable or allocatable characteristics.  */
1631       if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1632         {
1633           static int count = 1;
1634           secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1635           if (secname == NULL)
1636             einfo ("%F%P: place_orphan failed: %E\n");
1637         }
1639       /* All sections in an executable must be aligned to a page boundary.  */
1640       address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
1641       os = lang_insert_orphan (file, s, secname, after, place, address,
1642                                &add_child);
1643     }
1645   {
1646     lang_statement_union_type **pl = &os->children.head;
1648     if (dollar != NULL)
1649       {
1650         bfd_boolean found_dollar;
1652         /* The section name has a '$'.  Sort it with the other '$'
1653            sections.  */
1654         found_dollar = FALSE;
1655         for ( ; *pl != NULL; pl = &(*pl)->header.next)
1656           {
1657             lang_input_section_type *ls;
1658             const char *lname;
1660             if ((*pl)->header.type != lang_input_section_enum)
1661               continue;
1663             ls = &(*pl)->input_section;
1665             lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1666             if (strchr (lname, '$') == NULL)
1667               {
1668                 if (found_dollar)
1669                   break;
1670               }
1671             else
1672               {
1673                 found_dollar = TRUE;
1674                 if (strcmp (orig_secname, lname) < 0)
1675                   break;
1676               }
1677           }
1678       }
1680     if (add_child.head != NULL)
1681       {
1682         add_child.head->header.next = *pl;
1683         *pl = add_child.head;
1684       }
1685   }
1687   return TRUE;
1690 static bfd_boolean
1691 gld_${EMULATION_NAME}_open_dynamic_archive
1692   (const char *arch ATTRIBUTE_UNUSED, search_dirs_type *search,
1693    lang_input_statement_type *entry)
1695   const char * filename;
1696   char * string;
1698   if (! entry->is_archive)
1699     return FALSE;
1701   filename = entry->filename;
1703   string = (char *) xmalloc (strlen (search->name)
1704                              + strlen (filename)
1705                              + sizeof "/lib.a.dll"
1706 #ifdef DLL_SUPPORT
1707                              + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1708 #endif
1709                              + 1);
1711   /* Try "libfoo.dll.a" first (preferred explicit import library for dll's.  */
1712   sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1714   if (! ldfile_try_open_bfd (string, entry))
1715     {
1716       /* Try "foo.dll.a" next (alternate explicit import library for dll's.  */
1717       sprintf (string, "%s/%s.dll.a", search->name, filename);
1718       if (! ldfile_try_open_bfd (string, entry))
1719         {
1720           /* Try libfoo.a next. Normally, this would be interpreted as a static
1721              library, but it *could* be an import library. For backwards compatibility,
1722              libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1723              or sometimes errors occur when building legacy packages.
1725              Putting libfoo.a here means that in a failure case (i.e. the library
1726              -lfoo is not found) we will search for libfoo.a twice before
1727              giving up -- once here, and once when searching for a "static" lib.
1728              for a "static" lib.  */
1729           /* Try "libfoo.a" (import lib, or static lib, but must
1730              take precedence over dll's).  */
1731           sprintf (string, "%s/lib%s.a", search->name, filename);
1732           if (! ldfile_try_open_bfd (string, entry))
1733             {
1734 #ifdef DLL_SUPPORT
1735               if (pe_dll_search_prefix)
1736                 {
1737                   /* Try "<prefix>foo.dll" (preferred dll name, if specified).  */
1738                   sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
1739                   if (! ldfile_try_open_bfd (string, entry))
1740                     {
1741                       /* Try "libfoo.dll" (default preferred dll name).  */
1742                       sprintf (string, "%s/lib%s.dll", search->name, filename);
1743                       if (! ldfile_try_open_bfd (string, entry))
1744                         {
1745                           /* Finally, try "foo.dll" (alternate dll name).  */
1746                           sprintf (string, "%s/%s.dll", search->name, filename);
1747                           if (! ldfile_try_open_bfd (string, entry))
1748                             {
1749                               free (string);
1750                               return FALSE;
1751                             }
1752                         }
1753                     }
1754                 }
1755               else /* pe_dll_search_prefix not specified.  */
1756 #endif
1757                 {
1758                   /* Try "libfoo.dll" (preferred dll name).  */
1759                   sprintf (string, "%s/lib%s.dll", search->name, filename);
1760                   if (! ldfile_try_open_bfd (string, entry))
1761                     {
1762                       /* Finally, try "foo.dll" (alternate dll name).  */
1763                       sprintf (string, "%s/%s.dll", search->name, filename);
1764                       if (! ldfile_try_open_bfd (string, entry))
1765                         {
1766                           free (string);
1767                           return FALSE;
1768                         }
1769                     }
1770                 }
1771             }
1772         }
1773     }
1775   entry->filename = string;
1777   return TRUE;
1780 static int
1781 gld_${EMULATION_NAME}_find_potential_libraries
1782   (char *name, lang_input_statement_type *entry)
1784   return ldfile_open_file_search (name, entry, "", ".lib");
1787 static char *
1788 gld_${EMULATION_NAME}_get_script (int *isfile)
1790 # Scripts compiled in.
1791 # sed commands to quote an ld script as a C string.
1792 sc="-f stringify.sed"
1794 cat >>e${EMULATION_NAME}.c <<EOF
1796   *isfile = 0;
1798   if (link_info.relocatable && config.build_constructors)
1799     return
1801 sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
1802 echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
1803 sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
1804 echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
1805 sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
1806 echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
1807 sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
1808 echo '  ; else return'                                  >> e${EMULATION_NAME}.c
1809 sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
1810 echo '; }'                                              >> e${EMULATION_NAME}.c
1812 cat >>e${EMULATION_NAME}.c <<EOF
1815 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1817   gld_${EMULATION_NAME}_before_parse,
1818   syslib_default,
1819   hll_default,
1820   gld_${EMULATION_NAME}_after_parse,
1821   gld_${EMULATION_NAME}_after_open,
1822   after_allocation_default,
1823   set_output_arch_default,
1824   ldemul_default_target,
1825   gld_${EMULATION_NAME}_before_allocation,
1826   gld_${EMULATION_NAME}_get_script,
1827   "${EMULATION_NAME}",
1828   "${OUTPUT_FORMAT}",
1829   gld_${EMULATION_NAME}_finish,
1830   NULL, /* Create output section statements.  */
1831   gld_${EMULATION_NAME}_open_dynamic_archive,
1832   gld_${EMULATION_NAME}_place_orphan,
1833   gld_${EMULATION_NAME}_set_symbols,
1834   NULL, /* parse_args */
1835   gld${EMULATION_NAME}_add_options,
1836   gld${EMULATION_NAME}_handle_option,
1837   gld_${EMULATION_NAME}_unrecognized_file,
1838   gld_${EMULATION_NAME}_list_options,
1839   gld_${EMULATION_NAME}_recognized_file,
1840   gld_${EMULATION_NAME}_find_potential_libraries,
1841   NULL  /* new_vers_pattern.  */