ld/emultempl/pe.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 rm -f e${EMULATION_NAME}.c
   4 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
   5 cat >>e${EMULATION_NAME}.c <<EOF
   6 /* This file is part of GLD, the Gnu Linker.
   7    Copyright 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 /* For WINDOWS_NT */
  24 /* The original file generated returned different default scripts depending
  25    on whether certain switches were set, but these switches pertain to the
  26    Linux system and that particular version of coff.  In the NT case, we
  27    only determine if the subsystem is console or windows in order to select
  28    the correct entry point by default. */
  29
  30 #include "bfd.h"
  31 #include "sysdep.h"
  32 #include "bfdlink.h"
  33 #include "getopt.h"
  34 #include "libiberty.h"
  35 #include "ld.h"
  36 #include "ldmain.h"
  37 #include "ldgram.h"
  38 #include "ldexp.h"
  39 #include "ldlang.h"
  40 #include "ldfile.h"
  41 #include "ldemul.h"
  42 #include "ldlex.h"
  43 #include "ldmisc.h"
  44 #include "ldctor.h"
  45 #include "coff/internal.h"
  46
  47 /* FIXME: This is a BFD internal header file, and we should not be
  48    using it here.  */
  49 #include "../bfd/libcoff.h"
  50
  51 #include "deffile.h"
  52 #include "pe-dll.h"
  53
  54 #define TARGET_IS_${EMULATION_NAME}
  55
  56 /* Permit the emulation parameters to override the default section
  57    alignment by setting OVERRIDE_SECTION_ALIGNMENT.  FIXME: This makes
  58    it seem that include/coff/internal.h should not define
  59    PE_DEF_SECTION_ALIGNMENT.  */
  60 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
  61 #undef PE_DEF_SECTION_ALIGNMENT
  62 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
  63 #endif
  64
  65 #if defined(TARGET_IS_i386pe)
  66 #define DLL_SUPPORT
  67 #endif
  68 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe) || defined(TARGET_IS_armpe)
  69 #define DLL_SUPPORT
  70 #endif
  71
  72 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
  73 #define PE_DEF_SUBSYSTEM                3
  74 #else
  75 #undef NT_EXE_IMAGE_BASE
  76 #undef PE_DEF_SECTION_ALIGNMENT
  77 #undef PE_DEF_FILE_ALIGNMENT
  78 #define NT_EXE_IMAGE_BASE               0x00010000
  79 #ifdef TARGET_IS_armpe
  80 #define PE_DEF_SECTION_ALIGNMENT        0x00001000
  81 #define PE_DEF_SUBSYSTEM                9
  82 #else
  83 #define PE_DEF_SECTION_ALIGNMENT        0x00000400
  84 #define PE_DEF_SUBSYSTEM                2
  85 #endif
  86 #define PE_DEF_FILE_ALIGNMENT           0x00000200
  87 #endif
  88
  89 #ifdef TARGET_IS_arm_epoc_pe
  90 #define bfd_arm_pe_allocate_interworking_sections \
  91         bfd_arm_epoc_pe_allocate_interworking_sections
  92 #define bfd_arm_pe_get_bfd_for_interworking \
  93         bfd_arm_epoc_pe_get_bfd_for_interworking
  94 #define bfd_arm_pe_process_before_allocation \
  95         bfd_arm_epoc_pe_process_before_allocation
  96 #endif
  97
  98 static void gld_${EMULATION_NAME}_set_symbols PARAMS ((void));
  99 static void gld_${EMULATION_NAME}_after_open PARAMS ((void));
 100 static void gld_${EMULATION_NAME}_before_parse PARAMS ((void));
 101 static void gld_${EMULATION_NAME}_after_parse PARAMS ((void));
 102 static void gld_${EMULATION_NAME}_before_allocation PARAMS ((void));
 103 static boolean gld_${EMULATION_NAME}_place_orphan
 104   PARAMS ((lang_input_statement_type *, asection *));
 105 static char *gld_${EMULATION_NAME}_get_script PARAMS ((int *));
 106 static int gld_${EMULATION_NAME}_parse_args PARAMS ((int, char **));
 107 static void gld_${EMULATION_NAME}_finish PARAMS ((void));
 108 static boolean gld_${EMULATION_NAME}_open_dynamic_archive
 109   PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
 110
 111 static struct internal_extra_pe_aouthdr pe;
 112 static int dll;
 113 static int support_old_code = 0;
 114 static char * thumb_entry_symbol = NULL;
 115 static lang_assignment_statement_type *image_base_statement = 0;
 116
 117 #ifdef DLL_SUPPORT
 118 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable */
 119 static char *pe_out_def_filename = NULL;
 120 static char *pe_implib_filename = NULL;
 121 static int pe_enable_auto_image_base = 0;
 122 static char *pe_dll_search_prefix = NULL;
 123 #endif
 124
 125 extern const char *output_filename;
 126
 127 static void
 128 gld_${EMULATION_NAME}_before_parse()
 129 {
 130   output_filename = "${EXECUTABLE_NAME:-a.exe}";
 131   ldfile_output_architecture = bfd_arch_${ARCH};
 132 #ifdef DLL_SUPPORT
 133   config.has_shared = 1;
 134
 135 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
 136 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
 137   lang_add_entry ("WinMainCRTStartup", 1);
 138 #else
 139   lang_add_entry ("_WinMainCRTStartup", 1);
 140 #endif
 141 #endif
 142 #endif
 143 }
 144 \f
 145 /* PE format extra command line options.  */
 146
 147 /* Used for setting flags in the PE header. */
 148 #define OPTION_BASE_FILE                (300  + 1)
 149 #define OPTION_DLL                      (OPTION_BASE_FILE + 1)
 150 #define OPTION_FILE_ALIGNMENT           (OPTION_DLL + 1)
 151 #define OPTION_IMAGE_BASE               (OPTION_FILE_ALIGNMENT + 1)
 152 #define OPTION_MAJOR_IMAGE_VERSION      (OPTION_IMAGE_BASE + 1)
 153 #define OPTION_MAJOR_OS_VERSION         (OPTION_MAJOR_IMAGE_VERSION + 1)
 154 #define OPTION_MAJOR_SUBSYSTEM_VERSION  (OPTION_MAJOR_OS_VERSION + 1)
 155 #define OPTION_MINOR_IMAGE_VERSION      (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
 156 #define OPTION_MINOR_OS_VERSION         (OPTION_MINOR_IMAGE_VERSION + 1)
 157 #define OPTION_MINOR_SUBSYSTEM_VERSION  (OPTION_MINOR_OS_VERSION + 1)
 158 #define OPTION_SECTION_ALIGNMENT        (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
 159 #define OPTION_STACK                    (OPTION_SECTION_ALIGNMENT + 1)
 160 #define OPTION_SUBSYSTEM                (OPTION_STACK + 1)
 161 #define OPTION_HEAP                     (OPTION_SUBSYSTEM + 1)
 162 #define OPTION_SUPPORT_OLD_CODE         (OPTION_HEAP + 1)
 163 #define OPTION_OUT_DEF                  (OPTION_SUPPORT_OLD_CODE + 1)
 164 #define OPTION_EXPORT_ALL               (OPTION_OUT_DEF + 1)
 165 #define OPTION_EXCLUDE_SYMBOLS          (OPTION_EXPORT_ALL + 1)
 166 #define OPTION_KILL_ATS                 (OPTION_EXCLUDE_SYMBOLS + 1)
 167 #define OPTION_STDCALL_ALIASES          (OPTION_KILL_ATS + 1)
 168 #define OPTION_ENABLE_STDCALL_FIXUP     (OPTION_STDCALL_ALIASES + 1)
 169 #define OPTION_DISABLE_STDCALL_FIXUP    (OPTION_ENABLE_STDCALL_FIXUP + 1)
 170 #define OPTION_IMPLIB_FILENAME          (OPTION_DISABLE_STDCALL_FIXUP + 1)
 171 #define OPTION_THUMB_ENTRY              (OPTION_IMPLIB_FILENAME + 1)
 172 #define OPTION_WARN_DUPLICATE_EXPORTS   (OPTION_THUMB_ENTRY + 1)
 173 #define OPTION_IMP_COMPAT               (OPTION_WARN_DUPLICATE_EXPORTS + 1)
 174 #define OPTION_ENABLE_AUTO_IMAGE_BASE   (OPTION_IMP_COMPAT + 1)
 175 #define OPTION_DISABLE_AUTO_IMAGE_BASE  (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
 176 #define OPTION_DLL_SEARCH_PREFIX                (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
 177
 178 static struct option longopts[] =
 179 {
 180   /* PE options */
 181   {"base-file", required_argument, NULL, OPTION_BASE_FILE},
 182   {"dll", no_argument, NULL, OPTION_DLL},
 183   {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
 184   {"heap", required_argument, NULL, OPTION_HEAP},
 185   {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
 186   {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
 187   {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
 188   {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
 189   {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
 190   {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
 191   {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
 192   {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
 193   {"stack", required_argument, NULL, OPTION_STACK},
 194   {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
 195   {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
 196   {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
 197 #ifdef DLL_SUPPORT
 198   /* getopt allows abbreviations, so we do this to stop it from treating -o
 199      as an abbreviation for this option */
 200   {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 201   {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 202   {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
 203   {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
 204   {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
 205   {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
 206   {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
 207   {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
 208   {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
 209   {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
 210   {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 211   {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
 212   {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
 213   {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
 214 #endif
 215   {NULL, no_argument, NULL, 0}
 216 };
 217
 218
 219 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
 220    parameters which may be input from the command line */
 221
 222 typedef struct
 223 {
 224   void *ptr;
 225   int size;
 226   int value;
 227   char *symbol;
 228   int inited;
 229 } definfo;
 230
 231 #define D(field,symbol,def)  {&pe.field,sizeof(pe.field), def, symbol,0}
 232
 233 static definfo init[] =
 234 {
 235   /* imagebase must be first */
 236 #define IMAGEBASEOFF 0
 237   D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
 238 #define DLLOFF 1
 239   {&dll, sizeof(dll), 0, "__dll__", 0},
 240   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
 241   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
 242   D(MajorOperatingSystemVersion,"__major_os_version__", 4),
 243   D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
 244   D(MajorImageVersion,"__major_image_version__", 1),
 245   D(MinorImageVersion,"__minor_image_version__", 0),
 246 #ifdef TARGET_IS_armpe
 247   D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
 248 #else
 249   D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
 250 #endif
 251   D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
 252   D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
 253   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x2000000),
 254   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
 255   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
 256   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
 257   D(LoaderFlags,"__loader_flags__", 0x0),
 258   { NULL, 0, 0, NULL, 0 }
 259 };
 260
 261 static void
 262 gld_${EMULATION_NAME}_list_options (file)
 263      FILE * file;
 264 {
 265   fprintf (file, _("  --base_file <basefile>             Generate a base file for relocatable DLLs\n"));
 266   fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));
 267   fprintf (file, _("  --file-alignment <size>            Set file alignment\n"));
 268   fprintf (file, _("  --heap <size>                      Set initial size of the heap\n"));
 269   fprintf (file, _("  --image-base <address>             Set start address of the executable\n"));
 270   fprintf (file, _("  --major-image-version <number>     Set version number of the executable\n"));
 271   fprintf (file, _("  --major-os-version <number>        Set minimum required OS version\n"));
 272   fprintf (file, _("  --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
 273   fprintf (file, _("  --minor-image-version <number>     Set revision number of the executable\n"));
 274   fprintf (file, _("  --minor-os-version <number>        Set minimum required OS revision\n"));
 275   fprintf (file, _("  --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
 276   fprintf (file, _("  --section-alignment <size>         Set section alignment\n"));
 277   fprintf (file, _("  --stack <size>                     Set size of the initial stack\n"));
 278   fprintf (file, _("  --subsystem <name>[:<version>]     Set required OS subsystem [& version]\n"));
 279   fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));
 280   fprintf (file, _("  --thumb-entry=<symbol>             Set the entry point to be Thumb <symbol>\n"));
 281 #ifdef DLL_SUPPORT
 282   fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));
 283   fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));
 284   fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));
 285   fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));
 286   fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));
 287   fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));
 288   fprintf (file, _("  --out-implib <file>                Generate import library\n"));
 289   fprintf (file, _("  --output-def <file>                Generate a .DEF file for the built DLL\n"));
 290   fprintf (file, _("  --warn-duplicate-exports           Warn about duplicate exports.\n"));
 291   fprintf (file, _("  --compat-implib                    Create backward compatible import libs;\n"));
 292   fprintf (file, _("                                       create __imp_<SYMBOL> as well.\n"));
 293   fprintf (file, _("  --enable-auto-image-base           Automatically choose image base for DLLs\n"));
 294   fprintf (file, _("                                       unless user specifies one\n"));
 295   fprintf (file, _("  --disable-auto-image-base          Do not auto-choose image base. (default)\n"));
 296   fprintf (file, _("  --dll-search-prefix=<string>       When linking dynamically to a dll witout an\n"));
 297   fprintf (file, _("                                       importlib, use <string><basename>.dll \n"));
 298   fprintf (file, _("                                       in preference to lib<basename>.dll \n"));
 299 #endif
 300 }
 301
 302 static void
 303 set_pe_name (name, val)
 304      char *name;
 305      long val;
 306 {
 307   int i;
 308   /* Find the name and set it. */
 309   for (i = 0; init[i].ptr; i++)
 310     {
 311       if (strcmp (name, init[i].symbol) == 0)
 312         {
 313           init[i].value = val;
 314           init[i].inited = 1;
 315           return;
 316         }
 317     }
 318   abort();
 319 }
 320
 321
 322 static void
 323 set_pe_subsystem ()
 324 {
 325   const char *sver;
 326   int len;
 327   int i;
 328   static const struct
 329     {
 330       const char *name;
 331       const int value;
 332       const char *entry;
 333     }
 334   v[] =
 335     {
 336       { "native", 1, "NtProcessStartup" },
 337 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
 338       { "windows", 2, "WinMainCRTStartup" },
 339 #else
 340       { "windows", 2, "WinMainCRTStartup" },
 341 #endif
 342       { "console", 3, "mainCRTStartup" },
 343 #if 0
 344       /* The Microsoft linker does not recognize this.  */
 345       { "os2", 5, "" },
 346 #endif
 347       { "posix", 7, "__PosixProcessStartup"},
 348       { "wince", 9, "_WinMainCRTStartup" },
 349       { 0, 0, 0 }
 350     };
 351
 352   sver = strchr (optarg, ':');
 353   if (sver == NULL)
 354     len = strlen (optarg);
 355   else
 356     {
 357       char *end;
 358
 359       len = sver - optarg;
 360       set_pe_name ("__major_subsystem_version__",
 361                    strtoul (sver + 1, &end, 0));
 362       if (*end == '.')
 363         set_pe_name ("__minor_subsystem_version__",
 364                      strtoul (end + 1, &end, 0));
 365       if (*end != '\0')
 366         einfo (_("%P: warning: bad version number in -subsystem option\n"));
 367     }
 368
 369   for (i = 0; v[i].name; i++)
 370     {
 371       if (strncmp (optarg, v[i].name, len) == 0
 372           && v[i].name[len] == '\0')
 373         {
 374           const char *initial_symbol_char;
 375           const char *entry;
 376
 377           set_pe_name ("__subsystem__", v[i].value);
 378
 379           initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
 380           if (*initial_symbol_char == '\0')
 381             entry = v[i].entry;
 382           else
 383             {
 384               char *alc_entry;
 385
 386               /* lang_add_entry expects its argument to be permanently
 387                  allocated, so we don't free this string.  */
 388               alc_entry = xmalloc (strlen (initial_symbol_char)
 389                                    + strlen (v[i].entry)
 390                                    + 1);
 391               strcpy (alc_entry, initial_symbol_char);
 392               strcat (alc_entry, v[i].entry);
 393               entry = alc_entry;
 394             }
 395
 396           lang_add_entry (entry, 1);
 397
 398           return;
 399         }
 400     }
 401
 402   einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
 403 }
 404
 405
 406
 407 static void
 408 set_pe_value (name)
 409      char *name;
 410
 411 {
 412   char *end;
 413
 414   set_pe_name (name,  strtoul (optarg, &end, 0));
 415
 416   if (end == optarg)
 417     einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
 418
 419   optarg = end;
 420 }
 421
 422 static void
 423 set_pe_stack_heap (resname, comname)
 424      char *resname;
 425      char *comname;
 426 {
 427   set_pe_value (resname);
 428
 429   if (*optarg == ',')
 430     {
 431       optarg++;
 432       set_pe_value (comname);
 433     }
 434   else if (*optarg)
 435     einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
 436 }
 437
 438
 439
 440 static int
 441 gld_${EMULATION_NAME}_parse_args(argc, argv)
 442      int argc;
 443      char **argv;
 444 {
 445   int longind;
 446   int optc;
 447   int prevoptind = optind;
 448   int prevopterr = opterr;
 449   int wanterror;
 450   static int lastoptind = -1;
 451
 452   if (lastoptind != optind)
 453     opterr = 0;
 454   wanterror = opterr;
 455
 456   lastoptind = optind;
 457
 458   optc = getopt_long_only (argc, argv, "-", longopts, &longind);
 459   opterr = prevopterr;
 460
 461   switch (optc)
 462     {
 463     default:
 464       if (wanterror)
 465         xexit (1);
 466       optind =  prevoptind;
 467       return 0;
 468
 469     case OPTION_BASE_FILE:
 470       link_info.base_file = (PTR) fopen (optarg, FOPEN_WB);
 471       if (link_info.base_file == NULL)
 472         {
 473           /* xgettext:c-format */
 474           fprintf (stderr, _("%s: Can't open base file %s\n"),
 475                    program_name, optarg);
 476           xexit (1);
 477         }
 478       break;
 479
 480       /* PE options */
 481     case OPTION_HEAP:
 482       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 483       break;
 484     case OPTION_STACK:
 485       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 486       break;
 487     case OPTION_SUBSYSTEM:
 488       set_pe_subsystem ();
 489       break;
 490     case OPTION_MAJOR_OS_VERSION:
 491       set_pe_value ("__major_os_version__");
 492       break;
 493     case OPTION_MINOR_OS_VERSION:
 494       set_pe_value ("__minor_os_version__");
 495       break;
 496     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 497       set_pe_value ("__major_subsystem_version__");
 498       break;
 499     case OPTION_MINOR_SUBSYSTEM_VERSION:
 500       set_pe_value ("__minor_subsystem_version__");
 501       break;
 502     case OPTION_MAJOR_IMAGE_VERSION:
 503       set_pe_value ("__major_image_version__");
 504       break;
 505     case OPTION_MINOR_IMAGE_VERSION:
 506       set_pe_value ("__minor_image_version__");
 507       break;
 508     case OPTION_FILE_ALIGNMENT:
 509       set_pe_value ("__file_alignment__");
 510       break;
 511     case OPTION_SECTION_ALIGNMENT:
 512       set_pe_value ("__section_alignment__");
 513       break;
 514     case OPTION_DLL:
 515       set_pe_name ("__dll__", 1);
 516       break;
 517     case OPTION_IMAGE_BASE:
 518       set_pe_value ("__image_base__");
 519       break;
 520     case OPTION_SUPPORT_OLD_CODE:
 521       support_old_code = 1;
 522       break;
 523     case OPTION_THUMB_ENTRY:
 524       thumb_entry_symbol = optarg;
 525       break;
 526 #ifdef DLL_SUPPORT
 527     case OPTION_OUT_DEF:
 528       pe_out_def_filename = xstrdup (optarg);
 529       break;
 530     case OPTION_EXPORT_ALL:
 531       pe_dll_export_everything = 1;
 532       break;
 533     case OPTION_EXCLUDE_SYMBOLS:
 534       pe_dll_add_excludes (optarg);
 535       break;
 536     case OPTION_KILL_ATS:
 537       pe_dll_kill_ats = 1;
 538       break;
 539     case OPTION_STDCALL_ALIASES:
 540       pe_dll_stdcall_aliases = 1;
 541       break;
 542     case OPTION_ENABLE_STDCALL_FIXUP:
 543       pe_enable_stdcall_fixup = 1;
 544       break;
 545     case OPTION_DISABLE_STDCALL_FIXUP:
 546       pe_enable_stdcall_fixup = 0;
 547       break;
 548     case OPTION_IMPLIB_FILENAME:
 549       pe_implib_filename = xstrdup (optarg);
 550       break;
 551     case OPTION_WARN_DUPLICATE_EXPORTS:
 552       pe_dll_warn_dup_exports = 1;
 553       break;
 554     case OPTION_IMP_COMPAT:
 555       pe_dll_compat_implib = 1;
 556       break;
 557     case OPTION_ENABLE_AUTO_IMAGE_BASE:
 558       pe_enable_auto_image_base = 1;
 559       break;
 560     case OPTION_DISABLE_AUTO_IMAGE_BASE:
 561       pe_enable_auto_image_base = 0;
 562       break;
 563     case OPTION_DLL_SEARCH_PREFIX:
 564       pe_dll_search_prefix = xstrdup( optarg );
 565       break;
 566 #endif
 567     }
 568   return 1;
 569 }
 570 \f
 571
 572 #ifdef DLL_SUPPORT
 573 static unsigned long
 574 strhash (const char *str)
 575 {
 576   const unsigned char *s;
 577   unsigned long hash;
 578   unsigned int c;
 579   unsigned int len;
 580
 581   hash = 0;
 582   len = 0;
 583   s = (const unsigned char *) str;
 584   while ((c = *s++) != '\0')
 585     {
 586       hash += c + (c << 17);
 587       hash ^= hash >> 2;
 588       ++len;
 589     }
 590   hash += len + (len << 17);
 591   hash ^= hash >> 2;
 592
 593   return hash;
 594 }
 595
 596 /* Use the output file to create a image base for relocatable DLLs. */
 597 static unsigned long
 598 compute_dll_image_base (const char *ofile)
 599 {
 600   unsigned long hash = strhash (ofile);
 601   return 0x60000000 | ((hash << 16) & 0x0FFC0000);
 602 }
 603 #endif
 604
 605 /* Assign values to the special symbols before the linker script is
 606    read.  */
 607
 608 static void
 609 gld_${EMULATION_NAME}_set_symbols ()
 610 {
 611   /* Run through and invent symbols for all the
 612      names and insert the defaults. */
 613   int j;
 614   lang_statement_list_type *save;
 615
 616   if (!init[IMAGEBASEOFF].inited)
 617     {
 618       if (link_info.relocateable)
 619         init[IMAGEBASEOFF].value = 0;
 620       else if (init[DLLOFF].value || link_info.shared)
 621 #ifdef DLL_SUPPORT
 622         init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
 623           compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
 624 #else
 625         init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
 626 #endif
 627       else
 628         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
 629     }
 630
 631   /* Don't do any symbol assignments if this is a relocateable link.  */
 632   if (link_info.relocateable)
 633     return;
 634
 635   /* Glue the assignments into the abs section */
 636   save = stat_ptr;
 637
 638   stat_ptr = &(abs_output_section->children);
 639
 640   for (j = 0; init[j].ptr; j++)
 641     {
 642       long val = init[j].value;
 643       lang_assignment_statement_type *rv;
 644       rv = lang_add_assignment (exp_assop ('=' ,init[j].symbol, exp_intop (val)));
 645       if (init[j].size == sizeof(short))
 646         *(short *)init[j].ptr = val;
 647       else if (init[j].size == sizeof(int))
 648         *(int *)init[j].ptr = val;
 649       else if (init[j].size == sizeof(long))
 650         *(long *)init[j].ptr = val;
 651       /* This might be a long long or other special type.  */
 652       else if (init[j].size == sizeof(bfd_vma))
 653         *(bfd_vma *)init[j].ptr = val;
 654       else      abort();
 655       if (j == IMAGEBASEOFF)
 656         image_base_statement = rv;
 657     }
 658   /* Restore the pointer. */
 659   stat_ptr = save;
 660
 661   if (pe.FileAlignment >
 662       pe.SectionAlignment)
 663     {
 664       einfo (_("%P: warning, file alignment > section alignment.\n"));
 665     }
 666 }
 667
 668 /* This is called after the linker script and the command line options
 669    have been read.  */
 670
 671 static void
 672 gld_${EMULATION_NAME}_after_parse ()
 673 {
 674   /* The Windows libraries are designed for the linker to treat the
 675      entry point as an undefined symbol.  Otherwise, the .obj that
 676      defines mainCRTStartup is brought in because it is the first
 677      encountered in libc.lib and it has other symbols in it which will
 678      be pulled in by the link process.  To avoid this, we act as
 679      though the user specified -u with the entry point symbol.
 680
 681      This function is called after the linker script and command line
 682      options have been read, so at this point we know the right entry
 683      point.  This function is called before the input files are
 684      opened, so registering the symbol as undefined will make a
 685      difference.  */
 686
 687   if (! link_info.relocateable && entry_symbol != NULL)
 688     ldlang_add_undef (entry_symbol);
 689 }
 690
 691 #ifdef DLL_SUPPORT
 692 static struct bfd_link_hash_entry *pe_undef_found_sym;
 693
 694 static boolean
 695 pe_undef_cdecl_match (h, string)
 696   struct bfd_link_hash_entry *h;
 697   PTR string;
 698 {
 699   int sl = strlen (string);
 700   if (h->type == bfd_link_hash_defined
 701       && strncmp (h->root.string, string, sl) == 0
 702       && h->root.string[sl] == '@')
 703   {
 704     pe_undef_found_sym = h;
 705     return false;
 706   }
 707   return true;
 708 }
 709
 710 static void
 711 pe_fixup_stdcalls ()
 712 {
 713   static int gave_warning_message = 0;
 714   struct bfd_link_hash_entry *undef, *sym;
 715   char *at;
 716   for (undef = link_info.hash->undefs; undef; undef=undef->next)
 717     if (undef->type == bfd_link_hash_undefined)
 718     {
 719       at = strchr (undef->root.string, '@');
 720       if (at)
 721       {
 722         /* The symbol is a stdcall symbol, so let's look for a cdecl
 723            symbol with the same name and resolve to that */
 724         char *cname = xstrdup (undef->root.string);
 725         at = strchr (cname, '@');
 726         *at = 0;
 727         sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
 728         if (sym && sym->type == bfd_link_hash_defined)
 729         {
 730           undef->type = bfd_link_hash_defined;
 731           undef->u.def.value = sym->u.def.value;
 732           undef->u.def.section = sym->u.def.section;
 733           if (pe_enable_stdcall_fixup == -1)
 734             {
 735               einfo (_("Warning: resolving %s by linking to %s\n"),
 736                      undef->root.string, cname);
 737               if (! gave_warning_message)
 738                 {
 739                   gave_warning_message = 1;
 740                   einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
 741                   einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
 742                 }
 743             }
 744         }
 745       }
 746       else
 747       {
 748         /* The symbol is a cdecl symbol, so we look for stdcall
 749            symbols - which means scanning the whole symbol table */
 750         pe_undef_found_sym = 0;
 751         bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
 752                                 (PTR) undef->root.string);
 753         sym = pe_undef_found_sym;
 754         if (sym)
 755         {
 756           undef->type = bfd_link_hash_defined;
 757           undef->u.def.value = sym->u.def.value;
 758           undef->u.def.section = sym->u.def.section;
 759           if (pe_enable_stdcall_fixup == -1)
 760             {
 761               einfo (_("Warning: resolving %s by linking to %s\n"),
 762                      undef->root.string, sym->root.string);
 763               if (! gave_warning_message)
 764                 {
 765                   gave_warning_message = 1;
 766                   einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
 767                   einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
 768                 }
 769             }
 770         }
 771       }
 772     }
 773 }
 774 #endif /* DLL_SUPPORT */
 775
 776 static void
 777 gld_${EMULATION_NAME}_after_open ()
 778 {
 779   /* Pass the wacky PE command line options into the output bfd.
 780      FIXME: This should be done via a function, rather than by
 781      including an internal BFD header.  */
 782
 783   if (!coff_data (output_bfd)->pe)
 784     einfo (_("%F%P: PE operations on non PE file.\n"));
 785
 786   pe_data (output_bfd)->pe_opthdr = pe;
 787   pe_data (output_bfd)->dll = init[DLLOFF].value;
 788
 789 #ifdef DLL_SUPPORT
 790   if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
 791     pe_fixup_stdcalls ();
 792
 793   pe_process_import_defs(output_bfd, &link_info);
 794   if (link_info.shared)
 795     pe_dll_build_sections (output_bfd, &link_info);
 796
 797 #ifndef TARGET_IS_i386pe
 798 #ifndef TARGET_IS_armpe
 799   else
 800     pe_exe_build_sections (output_bfd, &link_info);
 801 #endif
 802 #endif
 803 #endif
 804
 805 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
 806   if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
 807     {
 808       /* The arm backend needs special fields in the output hash structure.
 809          These will only be created if the output format is an arm format,
 810          hence we do not support linking and changing output formats at the
 811          same time.  Use a link followed by objcopy to change output formats.  */
 812       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
 813       return;
 814     }
 815   {
 816     /* Find a BFD that can hold the interworking stubs.  */
 817     LANG_FOR_EACH_INPUT_STATEMENT (is)
 818       {
 819         if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
 820           break;
 821       }
 822   }
 823 #endif
 824
 825   {
 826     /* This next chunk of code tries to detect the case where you have
 827        two import libraries for the same DLL (specifically,
 828        symbolically linking libm.a and libc.a in cygwin to
 829        libcygwin.a).  In those cases, it's possible for function
 830        thunks from the second implib to be used but without the
 831        head/tail objects, causing an improper import table.  We detect
 832        those cases and rename the "other" import libraries to match
 833        the one the head/tail come from, so that the linker will sort
 834        things nicely and produce a valid import table. */
 835
 836     LANG_FOR_EACH_INPUT_STATEMENT (is)
 837       {
 838         if (is->the_bfd->my_archive)
 839           {
 840             int idata2 = 0, reloc_count=0, is_imp = 0;
 841             asection *sec;
 842
 843             /* See if this is an import library thunk.  */
 844             for (sec = is->the_bfd->sections; sec; sec = sec->next)
 845               {
 846                 if (strcmp (sec->name, ".idata\$2") == 0)
 847                   idata2 = 1;
 848                 if (strncmp (sec->name, ".idata\$", 7) == 0)
 849                   is_imp = 1;
 850                 reloc_count += sec->reloc_count;
 851               }
 852
 853             if (is_imp && !idata2 && reloc_count)
 854               {
 855                 /* It is, look for the reference to head and see if it's
 856                    from our own library.  */
 857                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
 858                   {
 859                     int i;
 860                     long symsize;
 861                     long relsize;
 862                     asymbol **symbols;
 863                     arelent **relocs;
 864                     int nrelocs;
 865
 866                     symsize = bfd_get_symtab_upper_bound (is->the_bfd);
 867                     if (symsize < 1)
 868                       break;
 869                     relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
 870                     if (relsize < 1)
 871                       break;
 872
 873                     symbols = (asymbol **) xmalloc (symsize);
 874                     symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
 875                     if (symsize < 0)
 876                       {
 877                         einfo ("%X%P: unable to process symbols: %E");
 878                         return;
 879                       }
 880
 881                     relocs = (arelent **) xmalloc ((size_t) relsize);
 882                     nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
 883                                                           relocs, symbols);
 884                     if (nrelocs < 0)
 885                       {
 886                         free (relocs);
 887                         einfo ("%X%P: unable to process relocs: %E");
 888                         return;
 889                       }
 890
 891                     for (i = 0; i < nrelocs; i++)
 892                       {
 893                         struct symbol_cache_entry *s;
 894                         struct bfd_link_hash_entry * blhe;
 895                         bfd *other_bfd;
 896                         char *n;
 897
 898                         s = (relocs[i]->sym_ptr_ptr)[0];
 899
 900                         if (s->flags & BSF_LOCAL)
 901                           continue;
 902
 903                         /* Thunk section with reloc to another bfd.  */
 904                         blhe = bfd_link_hash_lookup (link_info.hash,
 905                                                      s->name,
 906                                                      false, false, true);
 907
 908                         if (blhe == NULL
 909                             || blhe->type != bfd_link_hash_defined)
 910                           continue;
 911
 912                         other_bfd = blhe->u.def.section->owner;
 913
 914                         if (strcmp (is->the_bfd->my_archive->filename,
 915                                     other_bfd->my_archive->filename) == 0)
 916                           continue;
 917
 918                         /* Rename this implib to match the other.  */
 919                         n = (char *) xmalloc (strlen (other_bfd->my_archive->filename) + 1);
 920
 921                         strcpy (n, other_bfd->my_archive->filename);
 922
 923                         is->the_bfd->my_archive->filename = n;
 924                       }
 925
 926                     free (relocs);
 927                     /* Note - we do not free the symbols,
 928                        they are now cached in the BFD.  */
 929                   }
 930               }
 931           }
 932       }
 933   }
 934
 935   {
 936     int is_ms_arch = 0;
 937     bfd *cur_arch = 0;
 938     lang_input_statement_type *is2;
 939
 940     /* Careful - this is a shell script.  Watch those dollar signs! */
 941     /* Microsoft import libraries have every member named the same,
 942        and not in the right order for us to link them correctly.  We
 943        must detect these and rename the members so that they'll link
 944        correctly.  There are three types of objects: the head, the
 945        thunks, and the sentinel(s).  The head is easy; it's the one
 946        with idata2.  We assume that the sentinels won't have relocs,
 947        and the thunks will.  It's easier than checking the symbol
 948        table for external references.  */
 949     LANG_FOR_EACH_INPUT_STATEMENT (is)
 950       {
 951         if (is->the_bfd->my_archive)
 952           {
 953             bfd *arch = is->the_bfd->my_archive;
 954             if (cur_arch != arch)
 955               {
 956                 cur_arch = arch;
 957                 is_ms_arch = 1;
 958                 for (is2 = is;
 959                      is2 && is2->the_bfd->my_archive == arch;
 960                      is2 = (lang_input_statement_type *)is2->next)
 961                   {
 962                     if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
 963                       is_ms_arch = 0;
 964                   }
 965               }
 966
 967             if (is_ms_arch)
 968               {
 969                 int idata2 = 0, reloc_count=0;
 970                 asection *sec;
 971                 char *new_name, seq;
 972
 973                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
 974                   {
 975                     if (strcmp (sec->name, ".idata\$2") == 0)
 976                       idata2 = 1;
 977                     reloc_count += sec->reloc_count;
 978                   }
 979
 980                 if (idata2) /* .idata2 is the TOC */
 981                   seq = 'a';
 982                 else if (reloc_count > 0) /* thunks */
 983                   seq = 'b';
 984                 else /* sentinel */
 985                   seq = 'c';
 986
 987                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
 988                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
 989                 is->the_bfd->filename = new_name;
 990
 991                 new_name = xmalloc (strlen (is->filename) + 3);
 992                 sprintf (new_name, "%s.%c", is->filename, seq);
 993                 is->filename = new_name;
 994               }
 995           }
 996       }
 997   }
 998 }
 999 \f
1000 static void
1001 gld_${EMULATION_NAME}_before_allocation()
1002 {
1003 #ifdef TARGET_IS_ppcpe
1004   /* Here we rummage through the found bfds to collect toc information */
1005   {
1006     LANG_FOR_EACH_INPUT_STATEMENT (is)
1007       {
1008         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1009           {
1010             /* xgettext:c-format */
1011             einfo (_("Errors encountered processing file %s\n"), is->filename);
1012           }
1013       }
1014   }
1015
1016   /* We have seen it all. Allocate it, and carry on */
1017   ppc_allocate_toc_section (&link_info);
1018 #endif /* TARGET_IS_ppcpe */
1019
1020 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1021   /* FIXME: we should be able to set the size of the interworking stub
1022      section.
1023
1024      Here we rummage through the found bfds to collect glue
1025      information.  FIXME: should this be based on a command line
1026      option?  krk@cygnus.com */
1027   {
1028     LANG_FOR_EACH_INPUT_STATEMENT (is)
1029       {
1030         if (! bfd_arm_pe_process_before_allocation
1031             (is->the_bfd, & link_info, support_old_code))
1032           {
1033             /* xgettext:c-format */
1034             einfo (_("Errors encountered processing file %s for interworking"),
1035                    is->filename);
1036           }
1037       }
1038   }
1039
1040   /* We have seen it all. Allocate it, and carry on */
1041   bfd_arm_pe_allocate_interworking_sections (& link_info);
1042 #endif /* TARGET_IS_armpe */
1043 }
1044 \f
1045 #ifdef DLL_SUPPORT
1046 /* This is called when an input file isn't recognized as a BFD.  We
1047    check here for .DEF files and pull them in automatically. */
1048
1049 static int
1050 saw_option(char *option)
1051 {
1052   int i;
1053   for (i=0; init[i].ptr; i++)
1054     if (strcmp (init[i].symbol, option) == 0)
1055       return init[i].inited;
1056   return 0;
1057 }
1058 #endif /* DLL_SUPPORT */
1059
1060 static boolean
1061 gld_${EMULATION_NAME}_unrecognized_file(entry)
1062      lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1063 {
1064 #ifdef DLL_SUPPORT
1065   const char *ext = entry->filename + strlen (entry->filename) - 4;
1066
1067   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1068   {
1069     if (pe_def_file == 0)
1070       pe_def_file = def_file_empty ();
1071     def_file_parse (entry->filename, pe_def_file);
1072     if (pe_def_file)
1073     {
1074       int i, buflen=0, len;
1075       char *buf;
1076       for (i=0; i<pe_def_file->num_exports; i++)
1077         {
1078           len = strlen(pe_def_file->exports[i].internal_name);
1079           if (buflen < len+2)
1080             buflen = len+2;
1081         }
1082       buf = (char *) xmalloc (buflen);
1083       for (i=0; i<pe_def_file->num_exports; i++)
1084         {
1085           struct bfd_link_hash_entry *h;
1086           sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
1087
1088           h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true);
1089           if (h == (struct bfd_link_hash_entry *) NULL)
1090             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1091           if (h->type == bfd_link_hash_new)
1092             {
1093               h->type = bfd_link_hash_undefined;
1094               h->u.undef.abfd = NULL;
1095               bfd_link_add_undef (link_info.hash, h);
1096             }
1097         }
1098       free (buf);
1099
1100       /* def_file_print (stdout, pe_def_file); */
1101       if (pe_def_file->is_dll == 1)
1102         link_info.shared = 1;
1103
1104       if (pe_def_file->base_address != (bfd_vma)(-1))
1105       {
1106         pe.ImageBase =
1107         pe_data (output_bfd)->pe_opthdr.ImageBase =
1108         init[IMAGEBASEOFF].value = pe_def_file->base_address;
1109         init[IMAGEBASEOFF].inited = 1;
1110         if (image_base_statement)
1111           image_base_statement->exp =
1112             exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1113       }
1114
1115 #if 0
1116       /* Not sure if these *should* be set */
1117       if (pe_def_file->version_major != -1)
1118       {
1119         pe.MajorImageVersion = pe_def_file->version_major;
1120         pe.MinorImageVersion = pe_def_file->version_minor;
1121       }
1122 #endif
1123       if (pe_def_file->stack_reserve != -1
1124           && ! saw_option ("__size_of_stack_reserve__"))
1125       {
1126         pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1127         if (pe_def_file->stack_commit != -1)
1128           pe.SizeOfStackCommit = pe_def_file->stack_commit;
1129       }
1130       if (pe_def_file->heap_reserve != -1
1131           && ! saw_option ("__size_of_heap_reserve__"))
1132       {
1133         pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1134         if (pe_def_file->heap_commit != -1)
1135           pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1136       }
1137       return true;
1138     }
1139   }
1140 #endif
1141   return false;
1142
1143 }
1144
1145 static boolean
1146 gld_${EMULATION_NAME}_recognized_file(entry)
1147   lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1148 {
1149 #ifdef DLL_SUPPORT
1150 #ifdef TARGET_IS_i386pe
1151   pe_dll_id_target ("pei-i386");
1152 #endif
1153 #ifdef TARGET_IS_shpe
1154   pe_dll_id_target ("pei-shl");
1155 #endif
1156 #ifdef TARGET_IS_mipspe
1157   pe_dll_id_target ("pei-mips");
1158 #endif
1159 #ifdef TARGET_IS_armpe
1160   pe_dll_id_target ("pei-arm-little");
1161 #endif
1162   if (bfd_get_format (entry->the_bfd) == bfd_object)
1163     {
1164       const char *ext = entry->filename + strlen (entry->filename) - 4;
1165       if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1166         return pe_implied_import_dll (entry->filename);
1167     }
1168 #endif
1169   return false;
1170 }
1171
1172 static void
1173 gld_${EMULATION_NAME}_finish ()
1174 {
1175 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1176   struct bfd_link_hash_entry * h;
1177
1178   if (thumb_entry_symbol != NULL)
1179     {
1180       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol, false, false, true);
1181
1182       if (h != (struct bfd_link_hash_entry *) NULL
1183           && (h->type == bfd_link_hash_defined
1184               || h->type == bfd_link_hash_defweak)
1185           && h->u.def.section->output_section != NULL)
1186         {
1187           static char buffer[32];
1188           bfd_vma val;
1189
1190           /* Special procesing is required for a Thumb entry symbol.  The
1191              bottom bit of its address must be set.  */
1192           val = (h->u.def.value
1193                  + bfd_get_section_vma (output_bfd,
1194                                         h->u.def.section->output_section)
1195                  + h->u.def.section->output_offset);
1196
1197           val |= 1;
1198
1199           /* Now convert this value into a string and store it in entry_symbol
1200              where the lang_finish() function will pick it up.  */
1201           buffer[0] = '0';
1202           buffer[1] = 'x';
1203
1204           sprintf_vma (buffer + 2, val);
1205
1206           if (entry_symbol != NULL && entry_from_cmdline)
1207             einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1208                    thumb_entry_symbol, entry_symbol);
1209           entry_symbol = buffer;
1210         }
1211       else
1212         einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1213     }
1214 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1215
1216 #ifdef DLL_SUPPORT
1217   if (link_info.shared)
1218     {
1219       pe_dll_fill_sections (output_bfd, &link_info);
1220       if (pe_implib_filename)
1221         pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1222     }
1223 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1224   /* ARM doesn't need relocs.  */
1225   else
1226     {
1227       pe_exe_fill_sections (output_bfd, &link_info);
1228     }
1229 #endif
1230
1231   if (pe_out_def_filename)
1232     pe_dll_generate_def_file (pe_out_def_filename);
1233 #endif /* DLL_SUPPORT */
1234 }
1235
1236 \f
1237 /* Place an orphan section.
1238
1239    We use this to put sections in a reasonable place in the file, and
1240    to ensure that they are aligned as required.
1241
1242    We handle grouped sections here as well.  A section named .foo$nn
1243    goes into the output section .foo.  All grouped sections are sorted
1244    by name.
1245
1246    Grouped sections for the default sections are handled by the
1247    default linker script using wildcards, and are sorted by
1248    sort_sections.  */
1249
1250 struct orphan_save
1251 {
1252   lang_output_section_statement_type *os;
1253   asection **section;
1254   lang_statement_union_type **stmt;
1255 };
1256
1257 /*ARGSUSED*/
1258 static boolean
1259 gld_${EMULATION_NAME}_place_orphan (file, s)
1260      lang_input_statement_type *file;
1261      asection *s;
1262 {
1263   const char *secname;
1264   char *hold_section_name;
1265   char *dollar = NULL;
1266   lang_output_section_statement_type *os;
1267   lang_statement_list_type add_child;
1268
1269   secname = bfd_get_section_name (s->owner, s);
1270
1271   /* Look through the script to see where to place this section.  */
1272
1273   hold_section_name = xstrdup (secname);
1274   if (!link_info.relocateable)
1275     {
1276       dollar = strchr (hold_section_name, '$');
1277       if (dollar != NULL)
1278         *dollar = '\0';
1279     }
1280
1281   os = lang_output_section_find (hold_section_name);
1282
1283   lang_list_init (&add_child);
1284
1285   if (os != NULL
1286       && os->bfd_section != NULL
1287       && ((s->flags ^ os->bfd_section->flags) & (SEC_LOAD | SEC_ALLOC)) == 0)
1288     {
1289       wild_doit (&add_child, s, os, file);
1290     }
1291   else
1292     {
1293       struct orphan_save *place;
1294       static struct orphan_save hold_text;
1295       static struct orphan_save hold_rdata;
1296       static struct orphan_save hold_data;
1297       static struct orphan_save hold_bss;
1298       char *outsecname;
1299       lang_statement_list_type *old;
1300       lang_statement_list_type add;
1301       etree_type *address;
1302
1303       /* Try to put the new output section in a reasonable place based
1304          on the section name and section flags.  */
1305 #define HAVE_SECTION(hold, name) \
1306 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1307
1308       place = NULL;
1309       if ((s->flags & SEC_ALLOC) == 0)
1310         ;
1311       else if ((s->flags & SEC_HAS_CONTENTS) == 0
1312                && HAVE_SECTION (hold_bss, ".bss"))
1313         place = &hold_bss;
1314       else if ((s->flags & SEC_READONLY) == 0
1315                && HAVE_SECTION (hold_data, ".data"))
1316         place = &hold_data;
1317       else if ((s->flags & SEC_CODE) == 0
1318                && (s->flags & SEC_READONLY) != 0
1319                && HAVE_SECTION (hold_rdata, ".rdata"))
1320         place = &hold_rdata;
1321       else if ((s->flags & SEC_READONLY) != 0
1322                && HAVE_SECTION (hold_text, ".text"))
1323         place = &hold_text;
1324
1325 #undef HAVE_SECTION
1326
1327       /* Choose a unique name for the section.  This will be needed if
1328          the same section name appears in the input file with
1329          different loadable or allocateable characteristics.  */
1330       outsecname = xstrdup (hold_section_name);
1331       if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1332         {
1333           unsigned int len;
1334           char *newname;
1335           unsigned int i;
1336
1337           len = strlen (outsecname);
1338           newname = xmalloc (len + 5);
1339           strcpy (newname, outsecname);
1340           i = 0;
1341           do
1342             {
1343               sprintf (newname + len, "%d", i);
1344               ++i;
1345             }
1346           while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1347
1348           free (outsecname);
1349           outsecname = newname;
1350         }
1351
1352       /* Start building a list of statements for this section.  */
1353       old = stat_ptr;
1354       stat_ptr = &add;
1355       lang_list_init (stat_ptr);
1356
1357       if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1358         address = exp_intop ((bfd_vma) 0);
1359       else
1360         {
1361           /* All sections in an executable must be aligned to a page
1362              boundary.  */
1363           address = exp_unop (ALIGN_K,
1364                               exp_nameop (NAME, "__section_alignment__"));
1365         }
1366
1367       os = lang_enter_output_section_statement (outsecname, address, 0,
1368                                                 (bfd_vma) 0,
1369                                                 (etree_type *) NULL,
1370                                                 (etree_type *) NULL,
1371                                                 (etree_type *) NULL);
1372
1373       wild_doit (&add_child, s, os, file);
1374
1375       lang_leave_output_section_statement
1376         ((bfd_vma) 0, "*default*",
1377          (struct lang_output_section_phdr_list *) NULL, "*default*");
1378
1379       stat_ptr = old;
1380
1381       if (place != NULL)
1382         {
1383           asection *snew, **pps;
1384
1385           snew = os->bfd_section;
1386           if (place->os->bfd_section != NULL || place->section != NULL)
1387             {
1388               /* Shuffle the section to make the output file look neater.  */
1389               if (place->section == NULL)
1390                 {
1391 #if 0
1392                   /* Finding the end of the list is a little tricky.  We
1393                      make a wild stab at it by comparing section flags.  */
1394                   flagword first_flags = place->os->bfd_section->flags;
1395                   for (pps = &place->os->bfd_section->next;
1396                        *pps != NULL && (*pps)->flags == first_flags;
1397                        pps = &(*pps)->next)
1398                     ;
1399                   place->section = pps;
1400 #else
1401                   /* Put orphans after the first section on the list.  */
1402                   place->section = &place->os->bfd_section->next;
1403 #endif
1404                 }
1405
1406               /*  Unlink the section.  */
1407               for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1408                 ;
1409               *pps = snew->next;
1410
1411               /* Now tack it on to the "place->os" section list.  */
1412               snew->next = *place->section;
1413               *place->section = snew;
1414             }
1415           place->section = &snew->next; /* Save the end of this list.  */
1416
1417           if (place->stmt == NULL)
1418             {
1419               /* Put the new statement list right at the head.  */
1420               *add.tail = place->os->header.next;
1421               place->os->header.next = add.head;
1422             }
1423           else
1424             {
1425               /* Put it after the last orphan statement we added.  */
1426               *add.tail = *place->stmt;
1427               *place->stmt = add.head;
1428             }
1429           place->stmt = add.tail;       /* Save the end of this list.  */
1430         }
1431     }
1432
1433   {
1434     lang_statement_union_type **pl = &os->children.head;
1435
1436     if (dollar != NULL)
1437       {
1438         boolean found_dollar;
1439
1440         /* The section name has a '$'.  Sort it with the other '$'
1441            sections.  */
1442
1443         found_dollar = false;
1444         for ( ; *pl != NULL; pl = &(*pl)->next)
1445           {
1446             lang_input_section_type *ls;
1447             const char *lname;
1448
1449             if ((*pl)->header.type != lang_input_section_enum)
1450               continue;
1451
1452             ls = &(*pl)->input_section;
1453
1454             lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1455             if (strchr (lname, '$') == NULL)
1456               {
1457                 if (found_dollar)
1458                   break;
1459               }
1460             else
1461               {
1462                 found_dollar = true;
1463                 if (strcmp (secname, lname) < 0)
1464                   break;
1465               }
1466           }
1467       }
1468
1469     if (add_child.head != NULL)
1470       {
1471         add_child.head->next = *pl;
1472         *pl = add_child.head;
1473       }
1474   }
1475
1476   free (hold_section_name);
1477
1478   return true;
1479 }
1480
1481 static boolean
1482 gld_${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
1483      const char * arch ATTRIBUTE_UNUSED;
1484      search_dirs_type * search;
1485      lang_input_statement_type * entry;
1486 {
1487   const char * filename;
1488   char * string;
1489
1490   if (! entry->is_archive)
1491     return false;
1492
1493   filename = entry->filename;
1494
1495   string = (char *) xmalloc (strlen (search->name)
1496                              + strlen (filename)
1497                              + sizeof "/lib.a.dll"
1498 #ifdef DLL_SUPPORT
1499                              + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1500 #endif
1501                              + 1);
1502
1503   /* Try "libfoo.dll.a" first (preferred explicit import library for dll's */
1504   sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1505
1506   if (! ldfile_try_open_bfd (string, entry))
1507     {
1508       /* Try "foo.dll.a" next (alternate explicit import library for dll's */
1509       sprintf (string, "%s/%s.dll.a", search->name, filename);
1510       if (! ldfile_try_open_bfd (string, entry))
1511         {
1512 /*
1513    Try libfoo.a next. Normally, this would be interpreted as a static
1514    library, but it *could* be an import library. For backwards compatibility,
1515    libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1516    or sometimes errors occur when building legacy packages.
1517
1518    Putting libfoo.a here means that in a failure case (i.e. the library
1519    -lfoo is not found) we will search for libfoo.a twice before
1520    giving up -- once here, and once when searching for a "static" lib.
1521    for a "static" lib.
1522 */
1523           /* Try "libfoo.a" (import lib, or static lib, but must
1524              take precedence over dll's) */
1525           sprintf (string, "%s/lib%s.a", search->name, filename);
1526           if (! ldfile_try_open_bfd (string, entry))
1527             {
1528 #ifdef DLL_SUPPORT
1529               if (pe_dll_search_prefix)
1530                 {
1531                   /* Try "<prefix>foo.dll" (preferred dll name, if specified) */
1532                   sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
1533                   if (! ldfile_try_open_bfd (string, entry))
1534                     {
1535                       /* Try "libfoo.dll" (default preferred dll name) */
1536                       sprintf (string, "%s/lib%s.dll", search->name, filename);
1537                       if (! ldfile_try_open_bfd (string, entry))
1538                         {
1539                           /* Finally, try "foo.dll" (alternate dll name) */
1540                           sprintf (string, "%s/%s.dll", search->name, filename);
1541                           if (! ldfile_try_open_bfd (string, entry))
1542                             {
1543                               free (string);
1544                               return false;
1545                             }
1546                         }
1547                     }
1548                 }
1549               else /* pe_dll_search_prefix not specified */
1550 #endif
1551                 {
1552                   /* Try "libfoo.dll" (preferred dll name) */
1553                   sprintf (string, "%s/lib%s.dll", search->name, filename);
1554                   if (! ldfile_try_open_bfd (string, entry))
1555                     {
1556                       /* Finally, try "foo.dll" (alternate dll name) */
1557                       sprintf (string, "%s/%s.dll", search->name, filename);
1558                       if (! ldfile_try_open_bfd (string, entry))
1559                         {
1560                           free (string);
1561                           return false;
1562                         }
1563                     }
1564                 }
1565             }
1566         }
1567     }
1568
1569   entry->filename = string;
1570
1571   return true;
1572 }
1573
1574 static int
1575 gld_${EMULATION_NAME}_find_potential_libraries (name, entry)
1576      char * name;
1577      lang_input_statement_type * entry;
1578 {
1579   return ldfile_open_file_search (name, entry, "", ".lib");
1580 }
1581 \f
1582 static char *
1583 gld_${EMULATION_NAME}_get_script(isfile)
1584      int *isfile;
1585 EOF
1586 # Scripts compiled in.
1587 # sed commands to quote an ld script as a C string.
1588 sc="-f stringify.sed"
1589
1590 cat >>e${EMULATION_NAME}.c <<EOF
1591 {
1592   *isfile = 0;
1593
1594   if (link_info.relocateable == true && config.build_constructors == true)
1595     return
1596 EOF
1597 sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
1598 echo '  ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1599 sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
1600 echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
1601 sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
1602 echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
1603 sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
1604 echo '  ; else return'                                     >> e${EMULATION_NAME}.c
1605 sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
1606 echo '; }'                                                 >> e${EMULATION_NAME}.c
1607
1608 cat >>e${EMULATION_NAME}.c <<EOF
1609
1610
1611 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1612 {
1613   gld_${EMULATION_NAME}_before_parse,
1614   syslib_default,
1615   hll_default,
1616   gld_${EMULATION_NAME}_after_parse,
1617   gld_${EMULATION_NAME}_after_open,
1618   after_allocation_default,
1619   set_output_arch_default,
1620   ldemul_default_target,
1621   gld_${EMULATION_NAME}_before_allocation,
1622   gld_${EMULATION_NAME}_get_script,
1623   "${EMULATION_NAME}",
1624   "${OUTPUT_FORMAT}",
1625   gld_${EMULATION_NAME}_finish, /* finish */
1626   NULL, /* create output section statements */
1627   gld_${EMULATION_NAME}_open_dynamic_archive,
1628   gld_${EMULATION_NAME}_place_orphan,
1629   gld_${EMULATION_NAME}_set_symbols,
1630   gld_${EMULATION_NAME}_parse_args,
1631   gld_${EMULATION_NAME}_unrecognized_file,
1632   gld_${EMULATION_NAME}_list_options,
1633   gld_${EMULATION_NAME}_recognized_file,
1634   gld_${EMULATION_NAME}_find_potential_libraries
1635 };
1636 EOF