contrib/binutils/ld/emultempl/pep.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 test -z "${ENTRY}" && ENTRY="_mainCRTStartup"
   4 if [ -z "$MACHINE" ]; then
   5   OUTPUT_ARCH=${ARCH}
   6 else
   7   OUTPUT_ARCH=${ARCH}:${MACHINE}
   8 fi
   9 rm -f e${EMULATION_NAME}.c
  10 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
  11 cat >>e${EMULATION_NAME}.c <<EOF
  12 /* This file is part of GLD, the Gnu Linker.
  13    Copyright 2006, 2007 Free Software Foundation, Inc.
  14
  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.
  19
  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.
  24
  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.
  28
  29    Written by Kai Tietz, OneVision Software GmbH&CoKg.  */
  30
  31 /* For WINDOWS_XP64 and higher */
  32 /* Based on pe.em, but modified for 64 bit support.  */
  33
  34 #define TARGET_IS_${EMULATION_NAME}
  35
  36 #define COFF_IMAGE_WITH_PE
  37 #define COFF_WITH_PE
  38 #define COFF_WITH_pex64
  39
  40 #include "sysdep.h"
  41 #include "bfd.h"
  42 #include "bfdlink.h"
  43 #include "getopt.h"
  44 #include "libiberty.h"
  45 #include "ld.h"
  46 #include "ldmain.h"
  47 #include "ldexp.h"
  48 #include "ldlang.h"
  49 #include "ldfile.h"
  50 #include "ldemul.h"
  51 #include <ldgram.h>
  52 #include "ldlex.h"
  53 #include "ldmisc.h"
  54 #include "ldctor.h"
  55 #include "coff/internal.h"
  56
  57 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
  58    header in generic PE code.  */
  59 #include "coff/x86_64.h"
  60 #include "coff/pe.h"
  61
  62 /* FIXME: This is a BFD internal header file, and we should not be
  63    using it here.  */
  64 #include "../bfd/libcoff.h"
  65
  66 #undef  AOUTSZ
  67 #define AOUTSZ          PEPAOUTSZ
  68 #define PEAOUTHDR       PEPAOUTHDR
  69
  70 #include "deffile.h"
  71 #include "pep-dll.h"
  72 #include "safe-ctype.h"
  73
  74 /* Permit the emulation parameters to override the default section
  75    alignment by setting OVERRIDE_SECTION_ALIGNMENT.  FIXME: This makes
  76    it seem that include/coff/internal.h should not define
  77    PE_DEF_SECTION_ALIGNMENT.  */
  78 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
  79 #undef  PE_DEF_SECTION_ALIGNMENT
  80 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
  81 #endif
  82
  83 #ifdef TARGET_IS_i386pep
  84 #define DLL_SUPPORT
  85 #endif
  86
  87 #if defined(TARGET_IS_i386pep) || ! defined(DLL_SUPPORT)
  88 #define PE_DEF_SUBSYSTEM                3
  89 #else
  90 #undef  NT_EXE_IMAGE_BASE
  91 #define NT_EXE_IMAGE_BASE               0x00010000
  92 #undef  PE_DEF_SECTION_ALIGNMENT
  93 #define PE_DEF_SUBSYSTEM                2
  94 #undef  PE_DEF_FILE_ALIGNMENT
  95 #define PE_DEF_FILE_ALIGNMENT           0x00000200
  96 #define PE_DEF_SECTION_ALIGNMENT        0x00000400
  97 #endif
  98
  99
 100 static struct internal_extra_pe_aouthdr pep;
 101 static int dll;
 102 static flagword real_flags = IMAGE_FILE_LARGE_ADDRESS_AWARE;
 103 static int support_old_code = 0;
 104 static lang_assignment_statement_type *image_base_statement = 0;
 105
 106 #ifdef DLL_SUPPORT
 107 static int    pep_enable_stdcall_fixup = -1; /* 0=disable 1=enable.  */
 108 static char * pep_out_def_filename = NULL;
 109 static char * pep_implib_filename = NULL;
 110 static int    pep_enable_auto_image_base = 0;
 111 static char * pep_dll_search_prefix = NULL;
 112 #endif
 113
 114 extern const char *output_filename;
 115
 116 static void
 117 gld_${EMULATION_NAME}_before_parse (void)
 118 {
 119   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
 120   output_filename = "${EXECUTABLE_NAME:-a.exe}";
 121 #ifdef DLL_SUPPORT
 122   config.dynamic_link = TRUE;
 123   config.has_shared = 1;
 124   link_info.pei386_auto_import = -1;
 125   link_info.pei386_runtime_pseudo_reloc = -1;
 126
 127 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
 128   lang_default_entry ("_WinMainCRTStartup");
 129 #else
 130   lang_default_entry ("${ENTRY}");
 131 #endif
 132 #endif
 133 }
 134 \f
 135 /* PE format extra command line options.  */
 136
 137 /* Used for setting flags in the PE header.  */
 138 enum options
 139 {
 140   OPTION_BASE_FILE = 300 + 1,
 141   OPTION_DLL,
 142   OPTION_FILE_ALIGNMENT,
 143   OPTION_IMAGE_BASE,
 144   OPTION_MAJOR_IMAGE_VERSION,
 145   OPTION_MAJOR_OS_VERSION,
 146   OPTION_MAJOR_SUBSYSTEM_VERSION,
 147   OPTION_MINOR_IMAGE_VERSION,
 148   OPTION_MINOR_OS_VERSION,
 149   OPTION_MINOR_SUBSYSTEM_VERSION,
 150   OPTION_SECTION_ALIGNMENT,
 151   OPTION_STACK,
 152   OPTION_SUBSYSTEM,
 153   OPTION_HEAP,
 154   OPTION_SUPPORT_OLD_CODE,
 155   OPTION_OUT_DEF,
 156   OPTION_EXPORT_ALL,
 157   OPTION_EXCLUDE_SYMBOLS,
 158   OPTION_KILL_ATS,
 159   OPTION_STDCALL_ALIASES,
 160   OPTION_ENABLE_STDCALL_FIXUP,
 161   OPTION_DISABLE_STDCALL_FIXUP,
 162   OPTION_IMPLIB_FILENAME,
 163   OPTION_WARN_DUPLICATE_EXPORTS,
 164   OPTION_IMP_COMPAT,
 165   OPTION_ENABLE_AUTO_IMAGE_BASE,
 166   OPTION_DISABLE_AUTO_IMAGE_BASE,
 167   OPTION_DLL_SEARCH_PREFIX,
 168   OPTION_NO_DEFAULT_EXCLUDES,
 169   OPTION_DLL_ENABLE_AUTO_IMPORT,
 170   OPTION_DLL_DISABLE_AUTO_IMPORT,
 171   OPTION_ENABLE_EXTRA_PE_DEBUG,
 172   OPTION_EXCLUDE_LIBS,
 173   OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC,
 174   OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC
 175 };
 176
 177 static void
 178 gld${EMULATION_NAME}_add_options
 179   (int ns ATTRIBUTE_UNUSED,
 180    char **shortopts ATTRIBUTE_UNUSED,
 181    int nl,
 182    struct option **longopts,
 183    int nrl ATTRIBUTE_UNUSED,
 184    struct option **really_longopts ATTRIBUTE_UNUSED)
 185 {
 186   static const struct option xtra_long[] =
 187   {
 188     /* PE options */
 189     {"base-file", required_argument, NULL, OPTION_BASE_FILE},
 190     {"dll", no_argument, NULL, OPTION_DLL},
 191     {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
 192     {"heap", required_argument, NULL, OPTION_HEAP},
 193     {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
 194     {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
 195     {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
 196     {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
 197     {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
 198     {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
 199     {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
 200     {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
 201     {"stack", required_argument, NULL, OPTION_STACK},
 202     {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
 203     {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
 204 #ifdef DLL_SUPPORT
 205     /* getopt allows abbreviations, so we do this to stop it
 206        from treating -o as an abbreviation for this option.  */
 207     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 208     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 209     {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
 210     {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
 211     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
 212     {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
 213     {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
 214     {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
 215     {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
 216     {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
 217     {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
 218     /* getopt() allows abbreviations, so we do this to stop it from
 219        treating -c as an abbreviation for these --compat-implib.  */
 220     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 221     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 222     {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
 223     {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
 224     {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
 225     {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
 226     {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
 227     {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
 228     {"enable-extra-pep-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
 229     {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
 230     {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
 231 #endif
 232     {NULL, no_argument, NULL, 0}
 233   };
 234
 235   *longopts = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
 236   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
 237 }
 238
 239 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
 240    parameters which may be input from the command line.  */
 241
 242 typedef struct
 243 {
 244   void *ptr;
 245   int size;
 246   int value;
 247   char *symbol;
 248   int inited;
 249 } definfo;
 250
 251 #define D(field,symbol,def)  {&pep.field,sizeof(pep.field), def, symbol,0}
 252
 253 static definfo init[] =
 254 {
 255   /* imagebase must be first */
 256 #define IMAGEBASEOFF 0
 257   D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
 258 #define DLLOFF 1
 259   {&dll, sizeof(dll), 0, "__dll__", 0},
 260 #define MSIMAGEBASEOFF  2
 261   D(ImageBase,"__ImageBase", NT_EXE_IMAGE_BASE),
 262   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
 263   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
 264   D(MajorOperatingSystemVersion,"__major_os_version__", 4),
 265   D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
 266   D(MajorImageVersion,"__major_image_version__", 0),
 267   D(MinorImageVersion,"__minor_image_version__", 0),
 268   D(MajorSubsystemVersion,"__major_subsystem_version__", 5),
 269   D(MinorSubsystemVersion,"__minor_subsystem_version__", 2),
 270   D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
 271   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
 272   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
 273   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
 274   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
 275   D(LoaderFlags,"__loader_flags__", 0x0),
 276   { NULL, 0, 0, NULL, 0 }
 277 };
 278
 279
 280 static void
 281 gld_${EMULATION_NAME}_list_options (FILE *file)
 282 {
 283   fprintf (file, _("  --base_file <basefile>             Generate a base file for relocatable DLLs\n"));
 284   fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));
 285   fprintf (file, _("  --file-alignment <size>            Set file alignment\n"));
 286   fprintf (file, _("  --heap <size>                      Set initial size of the heap\n"));
 287   fprintf (file, _("  --image-base <address>             Set start address of the executable\n"));
 288   fprintf (file, _("  --major-image-version <number>     Set version number of the executable\n"));
 289   fprintf (file, _("  --major-os-version <number>        Set minimum required OS version\n"));
 290   fprintf (file, _("  --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
 291   fprintf (file, _("  --minor-image-version <number>     Set revision number of the executable\n"));
 292   fprintf (file, _("  --minor-os-version <number>        Set minimum required OS revision\n"));
 293   fprintf (file, _("  --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
 294   fprintf (file, _("  --section-alignment <size>         Set section alignment\n"));
 295   fprintf (file, _("  --stack <size>                     Set size of the initial stack\n"));
 296   fprintf (file, _("  --subsystem <name>[:<version>]     Set required OS subsystem [& version]\n"));
 297   fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));
 298 #ifdef DLL_SUPPORT
 299   fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));
 300   fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));
 301   fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));
 302   fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));
 303   fprintf (file, _("  --exclude-libs lib,lib,...         Exclude libraries from automatic export\n"));
 304   fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));
 305   fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));
 306   fprintf (file, _("  --out-implib <file>                Generate import library\n"));
 307   fprintf (file, _("  --output-def <file>                Generate a .DEF file for the built DLL\n"));
 308   fprintf (file, _("  --warn-duplicate-exports           Warn about duplicate exports.\n"));
 309   fprintf (file, _("  --compat-implib                    Create backward compatible import libs;\n\
 310                                        create __imp_<SYMBOL> as well.\n"));
 311   fprintf (file, _("  --enable-auto-image-base           Automatically choose image base for DLLs\n\
 312                                        unless user specifies one\n"));
 313   fprintf (file, _("  --disable-auto-image-base          Do not auto-choose image base. (default)\n"));
 314   fprintf (file, _("  --dll-search-prefix=<string>       When linking dynamically to a dll without\n\
 315                                        an importlib, use <string><basename>.dll\n\
 316                                        in preference to lib<basename>.dll \n"));
 317   fprintf (file, _("  --enable-auto-import               Do sophistcated linking of _sym to\n\
 318                                        __imp_sym for DATA references\n"));
 319   fprintf (file, _("  --disable-auto-import              Do not auto-import DATA items from DLLs\n"));
 320   fprintf (file, _("  --enable-runtime-pseudo-reloc      Work around auto-import limitations by\n\
 321                                        adding pseudo-relocations resolved at\n\
 322                                        runtime.\n"));
 323   fprintf (file, _("  --disable-runtime-pseudo-reloc     Do not add runtime pseudo-relocations for\n\
 324                                        auto-imported DATA.\n"));
 325   fprintf (file, _("  --enable-extra-pep-debug            Enable verbose debug output when building\n\
 326                                        or linking to DLLs (esp. auto-import)\n"));
 327 #endif
 328 }
 329
 330
 331 static void
 332 set_pep_name (char *name, long val)
 333 {
 334   int i;
 335
 336   /* Find the name and set it.  */
 337   for (i = 0; init[i].ptr; i++)
 338     {
 339       if (strcmp (name, init[i].symbol) == 0)
 340         {
 341           init[i].value = val;
 342           init[i].inited = 1;
 343           if (strcmp (name,"__image_base__") == 0)
 344             set_pep_name ("__ImageBase", val);
 345           return;
 346         }
 347     }
 348   abort ();
 349 }
 350
 351
 352 static void
 353 set_pep_subsystem (void)
 354 {
 355   const char *sver;
 356   const char *entry;
 357   const char *initial_symbol_char;
 358   char *end;
 359   int len;
 360   int i;
 361   int subsystem;
 362   unsigned long temp_subsystem;
 363   static const struct
 364     {
 365       const char *name;
 366       const int value;
 367       const char *entry;
 368     }
 369   v[] =
 370     {
 371       { "native",  1, "NtProcessStartup" },
 372       { "windows", 2, "WinMainCRTStartup" },
 373       { "console", 3, "mainCRTStartup" },
 374       { "posix",   7, "__PosixProcessStartup"},
 375       { "wince",   9, "_WinMainCRTStartup" },
 376       { "xbox",   14, "mainCRTStartup" },
 377       { NULL, 0, NULL }
 378     };
 379   /* Entry point name for arbitrary subsystem numbers.  */
 380   static const char default_entry[] = "mainCRTStartup";
 381
 382   /* Check for the presence of a version number.  */
 383   sver = strchr (optarg, ':');
 384   if (sver == NULL)
 385     len = strlen (optarg);
 386   else
 387     {
 388       len = sver - optarg;
 389       set_pep_name ("__major_subsystem_version__",
 390                     strtoul (sver + 1, &end, 0));
 391       if (*end == '.')
 392         set_pep_name ("__minor_subsystem_version__",
 393                       strtoul (end + 1, &end, 0));
 394       if (*end != '\0')
 395         einfo (_("%P: warning: bad version number in -subsystem option\n"));
 396     }
 397
 398   /* Check for numeric subsystem.  */
 399   temp_subsystem = strtoul (optarg, & end, 0);
 400   if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
 401     {
 402       /* Search list for a numeric match to use its entry point.  */
 403       for (i = 0; v[i].name; i++)
 404         if (v[i].value == (int) temp_subsystem)
 405           break;
 406
 407       /* If no match, use the default.  */
 408       if (v[i].name != NULL)
 409         entry = v[i].entry;
 410       else
 411         entry = default_entry;
 412
 413       /* Use this subsystem.  */
 414       subsystem = (int) temp_subsystem;
 415     }
 416   else
 417     {
 418       /* Search for subsystem by name.  */
 419       for (i = 0; v[i].name; i++)
 420         if (strncmp (optarg, v[i].name, len) == 0
 421             && v[i].name[len] == '\0')
 422           break;
 423
 424       if (v[i].name == NULL)
 425         {
 426           einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
 427           return;
 428         }
 429
 430       entry = v[i].entry;
 431       subsystem = v[i].value;
 432     }
 433
 434   set_pep_name ("__subsystem__", subsystem);
 435
 436   initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
 437   if (*initial_symbol_char != '\0')
 438     {
 439       char *alc_entry;
 440
 441       /* lang_default_entry expects its argument to be permanently
 442          allocated, so we don't free this string.  */
 443       alc_entry = xmalloc (strlen (initial_symbol_char)
 444                            + strlen (entry)
 445                            + 1);
 446       strcpy (alc_entry, initial_symbol_char);
 447       strcat (alc_entry, entry);
 448       entry = alc_entry;
 449     }
 450
 451   lang_default_entry (entry);
 452
 453   return;
 454 }
 455
 456
 457 static void
 458 set_pep_value (char *name)
 459 {
 460   char *end;
 461
 462   set_pep_name (name,  strtoul (optarg, &end, 0));
 463
 464   if (end == optarg)
 465     einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
 466
 467   optarg = end;
 468 }
 469
 470
 471 static void
 472 set_pep_stack_heap (char *resname, char *comname)
 473 {
 474   set_pep_value (resname);
 475
 476   if (*optarg == ',')
 477     {
 478       optarg++;
 479       set_pep_value (comname);
 480     }
 481   else if (*optarg)
 482     einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
 483 }
 484
 485
 486 static bfd_boolean
 487 gld${EMULATION_NAME}_handle_option (int optc)
 488 {
 489   switch (optc)
 490     {
 491     default:
 492       return FALSE;
 493
 494     case OPTION_BASE_FILE:
 495       link_info.base_file = fopen (optarg, FOPEN_WB);
 496       if (link_info.base_file == NULL)
 497         {
 498           /* xgettext:c-format */
 499           fprintf (stderr, _("%s: Can't open base file %s\n"),
 500                    program_name, optarg);
 501           xexit (1);
 502         }
 503       break;
 504
 505       /* PE options.  */
 506     case OPTION_HEAP:
 507       set_pep_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 508       break;
 509     case OPTION_STACK:
 510       set_pep_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 511       break;
 512     case OPTION_SUBSYSTEM:
 513       set_pep_subsystem ();
 514       break;
 515     case OPTION_MAJOR_OS_VERSION:
 516       set_pep_value ("__major_os_version__");
 517       break;
 518     case OPTION_MINOR_OS_VERSION:
 519       set_pep_value ("__minor_os_version__");
 520       break;
 521     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 522       set_pep_value ("__major_subsystem_version__");
 523       break;
 524     case OPTION_MINOR_SUBSYSTEM_VERSION:
 525       set_pep_value ("__minor_subsystem_version__");
 526       break;
 527     case OPTION_MAJOR_IMAGE_VERSION:
 528       set_pep_value ("__major_image_version__");
 529       break;
 530     case OPTION_MINOR_IMAGE_VERSION:
 531       set_pep_value ("__minor_image_version__");
 532       break;
 533     case OPTION_FILE_ALIGNMENT:
 534       set_pep_value ("__file_alignment__");
 535       break;
 536     case OPTION_SECTION_ALIGNMENT:
 537       set_pep_value ("__section_alignment__");
 538       break;
 539     case OPTION_DLL:
 540       set_pep_name ("__dll__", 1);
 541       break;
 542     case OPTION_IMAGE_BASE:
 543       set_pep_value ("__image_base__");
 544       break;
 545     case OPTION_SUPPORT_OLD_CODE:
 546       support_old_code = 1;
 547       break;
 548 #ifdef DLL_SUPPORT
 549     case OPTION_OUT_DEF:
 550       pep_out_def_filename = xstrdup (optarg);
 551       break;
 552     case OPTION_EXPORT_ALL:
 553       pep_dll_export_everything = 1;
 554       break;
 555     case OPTION_EXCLUDE_SYMBOLS:
 556       pep_dll_add_excludes (optarg, 0);
 557       break;
 558     case OPTION_EXCLUDE_LIBS:
 559       pep_dll_add_excludes (optarg, 1);
 560       break;
 561     case OPTION_KILL_ATS:
 562       pep_dll_kill_ats = 1;
 563       break;
 564     case OPTION_STDCALL_ALIASES:
 565       pep_dll_stdcall_aliases = 1;
 566       break;
 567     case OPTION_ENABLE_STDCALL_FIXUP:
 568       pep_enable_stdcall_fixup = 1;
 569       break;
 570     case OPTION_DISABLE_STDCALL_FIXUP:
 571       pep_enable_stdcall_fixup = 0;
 572       break;
 573     case OPTION_IMPLIB_FILENAME:
 574       pep_implib_filename = xstrdup (optarg);
 575       break;
 576     case OPTION_WARN_DUPLICATE_EXPORTS:
 577       pep_dll_warn_dup_exports = 1;
 578       break;
 579     case OPTION_IMP_COMPAT:
 580       pep_dll_compat_implib = 1;
 581       break;
 582     case OPTION_ENABLE_AUTO_IMAGE_BASE:
 583       pep_enable_auto_image_base = 1;
 584       break;
 585     case OPTION_DISABLE_AUTO_IMAGE_BASE:
 586       pep_enable_auto_image_base = 0;
 587       break;
 588     case OPTION_DLL_SEARCH_PREFIX:
 589       pep_dll_search_prefix = xstrdup (optarg);
 590       break;
 591     case OPTION_NO_DEFAULT_EXCLUDES:
 592       pep_dll_do_default_excludes = 0;
 593       break;
 594     case OPTION_DLL_ENABLE_AUTO_IMPORT:
 595       link_info.pei386_auto_import = 1;
 596       break;
 597     case OPTION_DLL_DISABLE_AUTO_IMPORT:
 598       link_info.pei386_auto_import = 0;
 599       break;
 600     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
 601       link_info.pei386_runtime_pseudo_reloc = 1;
 602       break;
 603     case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
 604       link_info.pei386_runtime_pseudo_reloc = 0;
 605       break;
 606     case OPTION_ENABLE_EXTRA_PE_DEBUG:
 607       pep_dll_extra_pe_debug = 1;
 608       break;
 609 #endif
 610     }
 611   return TRUE;
 612 }
 613 \f
 614
 615 #ifdef DLL_SUPPORT
 616 static unsigned long
 617 strhash (const char *str)
 618 {
 619   const unsigned char *s;
 620   unsigned long hash;
 621   unsigned int c;
 622   unsigned int len;
 623
 624   hash = 0;
 625   len = 0;
 626   s = (const unsigned char *) str;
 627   while ((c = *s++) != '\0')
 628     {
 629       hash += c + (c << 17);
 630       hash ^= hash >> 2;
 631       ++len;
 632     }
 633   hash += len + (len << 17);
 634   hash ^= hash >> 2;
 635
 636   return hash;
 637 }
 638
 639 /* Use the output file to create a image base for relocatable DLLs.  */
 640
 641 static unsigned long
 642 compute_dll_image_base (const char *ofile)
 643 {
 644   unsigned long hash = strhash (ofile);
 645   return 0x61300000 + ((hash << 16) & 0x0FFC0000);
 646 }
 647 #endif
 648
 649 /* Assign values to the special symbols before the linker script is
 650    read.  */
 651
 652 static void
 653 gld_${EMULATION_NAME}_set_symbols (void)
 654 {
 655   /* Run through and invent symbols for all the
 656      names and insert the defaults.  */
 657   int j;
 658   lang_statement_list_type *save;
 659
 660   if (!init[IMAGEBASEOFF].inited)
 661     {
 662       if (link_info.relocatable)
 663         init[IMAGEBASEOFF].value = 0;
 664       else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
 665 #ifdef DLL_SUPPORT
 666         init[IMAGEBASEOFF].value = (pep_enable_auto_image_base) ?
 667           compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
 668 #else
 669         init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
 670 #endif
 671       else
 672         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
 673         init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;
 674     }
 675
 676   /* Don't do any symbol assignments if this is a relocatable link.  */
 677   if (link_info.relocatable)
 678     return;
 679
 680   /* Glue the assignments into the abs section.  */
 681   save = stat_ptr;
 682
 683   stat_ptr = &(abs_output_section->children);
 684
 685   for (j = 0; init[j].ptr; j++)
 686     {
 687       long val = init[j].value;
 688       lang_assignment_statement_type *rv;
 689       rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
 690                                            exp_intop (val)));
 691       if (init[j].size == sizeof (short))
 692         *(short *) init[j].ptr = val;
 693       else if (init[j].size == sizeof (int))
 694         *(int *) init[j].ptr = val;
 695       else if (init[j].size == sizeof (long))
 696         *(long *) init[j].ptr = val;
 697       /* This might be a long long or other special type.  */
 698       else if (init[j].size == sizeof (bfd_vma))
 699         *(bfd_vma *) init[j].ptr = val;
 700       else      abort ();
 701       if (j == IMAGEBASEOFF)
 702         image_base_statement = rv;
 703     }
 704   /* Restore the pointer.  */
 705   stat_ptr = save;
 706
 707   if (pep.FileAlignment > pep.SectionAlignment)
 708     {
 709       einfo (_("%P: warning, file alignment > section alignment.\n"));
 710     }
 711 }
 712
 713 /* This is called after the linker script and the command line options
 714    have been read.  */
 715
 716 static void
 717 gld_${EMULATION_NAME}_after_parse (void)
 718 {
 719   /* The Windows libraries are designed for the linker to treat the
 720      entry point as an undefined symbol.  Otherwise, the .obj that
 721      defines mainCRTStartup is brought in because it is the first
 722      encountered in libc.lib and it has other symbols in it which will
 723      be pulled in by the link process.  To avoid this, we act as
 724      though the user specified -u with the entry point symbol.
 725
 726      This function is called after the linker script and command line
 727      options have been read, so at this point we know the right entry
 728      point.  This function is called before the input files are
 729      opened, so registering the symbol as undefined will make a
 730      difference.  */
 731
 732   if (! link_info.relocatable && entry_symbol.name != NULL)
 733     ldlang_add_undef (entry_symbol.name);
 734 }
 735
 736 /* pep-dll.c directly accesses pep_data_import_dll,
 737    so it must be defined outside of #ifdef DLL_SUPPORT.
 738    Note - this variable is deliberately not initialised.
 739    This allows it to be treated as a common varaible, and only
 740    exist in one incarnation in a multiple target enabled linker.  */
 741 char * pep_data_import_dll;
 742
 743 #ifdef DLL_SUPPORT
 744 static struct bfd_link_hash_entry *pep_undef_found_sym;
 745
 746 static bfd_boolean
 747 pep_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
 748 {
 749   int sl;
 750   char *string = inf;
 751
 752   sl = strlen (string);
 753   if (h->type == bfd_link_hash_defined
 754       && strncmp (h->root.string, string, sl) == 0
 755       && h->root.string[sl] == '@')
 756     {
 757       pep_undef_found_sym = h;
 758       return FALSE;
 759     }
 760   return TRUE;
 761 }
 762
 763 static void
 764 pep_fixup_stdcalls (void)
 765 {
 766   static int gave_warning_message = 0;
 767   struct bfd_link_hash_entry *undef, *sym;
 768
 769   if (pep_dll_extra_pe_debug)
 770     printf ("%s\n", __FUNCTION__);
 771
 772   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
 773     if (undef->type == bfd_link_hash_undefined)
 774       {
 775         char* at = strchr (undef->root.string, '@');
 776         int lead_at = (*undef->root.string == '@');
 777         /* For now, don't try to fixup fastcall symbols.  */
 778
 779         if (at && !lead_at)
 780           {
 781             /* The symbol is a stdcall symbol, so let's look for a
 782                cdecl symbol with the same name and resolve to that.  */
 783             char *cname = xstrdup (undef->root.string /* + lead_at */);
 784             at = strchr (cname, '@');
 785             *at = 0;
 786             sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
 787
 788             if (sym && sym->type == bfd_link_hash_defined)
 789               {
 790                 undef->type = bfd_link_hash_defined;
 791                 undef->u.def.value = sym->u.def.value;
 792                 undef->u.def.section = sym->u.def.section;
 793
 794                 if (pep_enable_stdcall_fixup == -1)
 795                   {
 796                     einfo (_("Warning: resolving %s by linking to %s\n"),
 797                            undef->root.string, cname);
 798                     if (! gave_warning_message)
 799                       {
 800                         gave_warning_message = 1;
 801                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
 802                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
 803                       }
 804                   }
 805               }
 806           }
 807         else
 808           {
 809             /* The symbol is a cdecl symbol, so we look for stdcall
 810                symbols - which means scanning the whole symbol table.  */
 811             pep_undef_found_sym = 0;
 812             bfd_link_hash_traverse (link_info.hash, pep_undef_cdecl_match,
 813                                     (char *) undef->root.string);
 814             sym = pep_undef_found_sym;
 815             if (sym)
 816               {
 817                 undef->type = bfd_link_hash_defined;
 818                 undef->u.def.value = sym->u.def.value;
 819                 undef->u.def.section = sym->u.def.section;
 820
 821                 if (pep_enable_stdcall_fixup == -1)
 822                   {
 823                     einfo (_("Warning: resolving %s by linking to %s\n"),
 824                            undef->root.string, sym->root.string);
 825                     if (! gave_warning_message)
 826                       {
 827                         gave_warning_message = 1;
 828                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
 829                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
 830                       }
 831                   }
 832               }
 833           }
 834       }
 835 }
 836
 837 static int
 838 make_import_fixup (arelent *rel, asection *s)
 839 {
 840   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
 841   char addend[4];
 842
 843   if (pep_dll_extra_pe_debug)
 844     printf ("arelent: %s@%#lx: add=%li\n", sym->name,
 845             (long) rel->address, (long) rel->addend);
 846
 847   if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
 848     einfo (_("%C: Cannot get section contents - auto-import exception\n"),
 849            s->owner, s, rel->address);
 850
 851   pep_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));
 852
 853   return 1;
 854 }
 855
 856 static void
 857 pep_find_data_imports (void)
 858 {
 859   struct bfd_link_hash_entry *undef, *sym;
 860
 861   if (link_info.pei386_auto_import == 0)
 862     return;
 863
 864   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
 865     {
 866       if (undef->type == bfd_link_hash_undefined)
 867         {
 868           /* C++ symbols are *long*.  */
 869           char buf[4096];
 870
 871           if (pep_dll_extra_pe_debug)
 872             printf ("%s:%s\n", __FUNCTION__, undef->root.string);
 873
 874           sprintf (buf, "__imp_%s", undef->root.string);
 875
 876           sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
 877
 878           if (sym && sym->type == bfd_link_hash_defined)
 879             {
 880               bfd *b = sym->u.def.section->owner;
 881               asymbol **symbols;
 882               int nsyms, symsize, i;
 883
 884               if (link_info.pei386_auto_import == -1)
 885                 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
 886                           undef->root.string, buf);
 887
 888               symsize = bfd_get_symtab_upper_bound (b);
 889               symbols = xmalloc (symsize);
 890               nsyms = bfd_canonicalize_symtab (b, symbols);
 891
 892               for (i = 0; i < nsyms; i++)
 893                 {
 894                   if (! CONST_STRNEQ (symbols[i]->name, "__head_"))
 895                     continue;
 896
 897                   if (pep_dll_extra_pe_debug)
 898                     printf ("->%s\n", symbols[i]->name);
 899
 900                   pep_data_import_dll = (char*) (symbols[i]->name +
 901                                                 sizeof ("__head_") - 1);
 902                   break;
 903                 }
 904
 905               pep_walk_relocs_of_symbol (&link_info, undef->root.string,
 906                                         make_import_fixup);
 907
 908               /* Let's differentiate it somehow from defined.  */
 909               undef->type = bfd_link_hash_defweak;
 910               /* We replace original name with __imp_ prefixed, this
 911                  1) may trash memory 2) leads to duplicate symbol generation.
 912                  Still, IMHO it's better than having name poluted.  */
 913               undef->root.string = sym->root.string;
 914               undef->u.def.value = sym->u.def.value;
 915               undef->u.def.section = sym->u.def.section;
 916             }
 917         }
 918     }
 919 }
 920
 921 static bfd_boolean
 922 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
 923 {
 924   if (pep_dll_extra_pe_debug)
 925     printf ("+%s\n", h->string);
 926
 927   return TRUE;
 928 }
 929 #endif /* DLL_SUPPORT */
 930
 931
 932 static void
 933 gld_${EMULATION_NAME}_after_open (void)
 934 {
 935 #ifdef DLL_SUPPORT
 936   if (pep_dll_extra_pe_debug)
 937     {
 938       bfd *a;
 939       struct bfd_link_hash_entry *sym;
 940
 941       printf ("%s()\n", __FUNCTION__);
 942
 943       for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
 944         printf ("-%s\n", sym->root.string);
 945       bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
 946
 947       for (a = link_info.input_bfds; a; a = a->link_next)
 948         printf ("*%s\n",a->filename);
 949     }
 950 #endif
 951
 952   /* Pass the wacky PE command line options into the output bfd.
 953      FIXME: This should be done via a function, rather than by
 954      including an internal BFD header.  */
 955
 956   if (coff_data (output_bfd) == NULL || coff_data (output_bfd)->pe == 0)
 957     einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"), output_bfd);
 958
 959   pe_data (output_bfd)->pe_opthdr = pep;
 960   pe_data (output_bfd)->dll = init[DLLOFF].value;
 961   pe_data (output_bfd)->real_flags |= real_flags;
 962
 963 #ifdef DLL_SUPPORT
 964   if (pep_enable_stdcall_fixup) /* -1=warn or 1=disable */
 965     pep_fixup_stdcalls ();
 966
 967   pep_process_import_defs (output_bfd, & link_info);
 968
 969   pep_find_data_imports ();
 970
 971 #ifndef TARGET_IS_i386pep
 972   if (link_info.shared)
 973 #else
 974   if (!link_info.relocatable)
 975 #endif
 976     pep_dll_build_sections (output_bfd, &link_info);
 977
 978 #ifndef TARGET_IS_i386pep
 979   else
 980     pep_exe_build_sections (output_bfd, &link_info);
 981 #endif
 982 #endif /* DLL_SUPPORT */
 983
 984   {
 985     /* This next chunk of code tries to detect the case where you have
 986        two import libraries for the same DLL (specifically,
 987        symbolically linking libm.a and libc.a in cygwin to
 988        libcygwin.a).  In those cases, it's possible for function
 989        thunks from the second implib to be used but without the
 990        head/tail objects, causing an improper import table.  We detect
 991        those cases and rename the "other" import libraries to match
 992        the one the head/tail come from, so that the linker will sort
 993        things nicely and produce a valid import table.  */
 994
 995     LANG_FOR_EACH_INPUT_STATEMENT (is)
 996       {
 997         if (is->the_bfd->my_archive)
 998           {
 999             int idata2 = 0, reloc_count=0, is_imp = 0;
1000             asection *sec;
1001
1002             /* See if this is an import library thunk.  */
1003             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1004               {
1005                 if (strcmp (sec->name, ".idata\$2") == 0)
1006                   idata2 = 1;
1007                 if (CONST_STRNEQ (sec->name, ".idata\$"))
1008                   is_imp = 1;
1009                 reloc_count += sec->reloc_count;
1010               }
1011
1012             if (is_imp && !idata2 && reloc_count)
1013               {
1014                 /* It is, look for the reference to head and see if it's
1015                    from our own library.  */
1016                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1017                   {
1018                     int i;
1019                     long symsize;
1020                     long relsize;
1021                     asymbol **symbols;
1022                     arelent **relocs;
1023                     int nrelocs;
1024
1025                     symsize = bfd_get_symtab_upper_bound (is->the_bfd);
1026                     if (symsize < 1)
1027                       break;
1028                     relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1029                     if (relsize < 1)
1030                       break;
1031
1032                     symbols = xmalloc (symsize);
1033                     symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
1034                     if (symsize < 0)
1035                       {
1036                         einfo ("%X%P: unable to process symbols: %E");
1037                         return;
1038                       }
1039
1040                     relocs = xmalloc ((size_t) relsize);
1041                     nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1042                                                       relocs, symbols);
1043                     if (nrelocs < 0)
1044                       {
1045                         free (relocs);
1046                         einfo ("%X%P: unable to process relocs: %E");
1047                         return;
1048                       }
1049
1050                     for (i = 0; i < nrelocs; i++)
1051                       {
1052                         struct bfd_symbol *s;
1053                         struct bfd_link_hash_entry * blhe;
1054                         char *other_bfd_filename;
1055                         char *n;
1056
1057                         s = (relocs[i]->sym_ptr_ptr)[0];
1058
1059                         if (s->flags & BSF_LOCAL)
1060                           continue;
1061
1062                         /* Thunk section with reloc to another bfd.  */
1063                         blhe = bfd_link_hash_lookup (link_info.hash,
1064                                                      s->name,
1065                                                      FALSE, FALSE, TRUE);
1066
1067                         if (blhe == NULL
1068                             || blhe->type != bfd_link_hash_defined)
1069                           continue;
1070
1071                         other_bfd_filename
1072                           = blhe->u.def.section->owner->my_archive
1073                             ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1074                             : bfd_get_filename (blhe->u.def.section->owner);
1075
1076                         if (strcmp (bfd_get_filename (is->the_bfd->my_archive),
1077                                     other_bfd_filename) == 0)
1078                           continue;
1079
1080                         /* Rename this implib to match the other one.  */
1081                         n = xmalloc (strlen (other_bfd_filename) + 1);
1082                         strcpy (n, other_bfd_filename);
1083                         is->the_bfd->my_archive->filename = n;
1084                       }
1085
1086                     free (relocs);
1087                     /* Note - we do not free the symbols,
1088                        they are now cached in the BFD.  */
1089                   }
1090               }
1091           }
1092       }
1093   }
1094
1095   {
1096     int is_ms_arch = 0;
1097     bfd *cur_arch = 0;
1098     lang_input_statement_type *is2;
1099     lang_input_statement_type *is3;
1100
1101     /* Careful - this is a shell script.  Watch those dollar signs! */
1102     /* Microsoft import libraries have every member named the same,
1103        and not in the right order for us to link them correctly.  We
1104        must detect these and rename the members so that they'll link
1105        correctly.  There are three types of objects: the head, the
1106        thunks, and the sentinel(s).  The head is easy; it's the one
1107        with idata2.  We assume that the sentinels won't have relocs,
1108        and the thunks will.  It's easier than checking the symbol
1109        table for external references.  */
1110     LANG_FOR_EACH_INPUT_STATEMENT (is)
1111       {
1112         if (is->the_bfd->my_archive)
1113           {
1114             char *pnt;
1115             bfd *arch = is->the_bfd->my_archive;
1116
1117             if (cur_arch != arch)
1118               {
1119                 cur_arch = arch;
1120                 is_ms_arch = 1;
1121
1122                 for (is3 = is;
1123                      is3 && is3->the_bfd->my_archive == arch;
1124                      is3 = (lang_input_statement_type *) is3->next)
1125                   {
1126                     /* A MS dynamic import library can also contain static
1127                        members, so look for the first element with a .dll
1128                        extension, and use that for the remainder of the
1129                        comparisons.  */
1130                     pnt = strrchr (is3->the_bfd->filename, '.');
1131                     if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1132                       break;
1133                   }
1134
1135                 if (is3 == NULL)
1136                   is_ms_arch = 0;
1137                 else
1138                   {
1139                     /* OK, found one.  Now look to see if the remaining
1140                        (dynamic import) members use the same name.  */
1141                     for (is2 = is;
1142                          is2 && is2->the_bfd->my_archive == arch;
1143                          is2 = (lang_input_statement_type *) is2->next)
1144                       {
1145                         /* Skip static members, ie anything with a .obj
1146                            extension.  */
1147                         pnt = strrchr (is2->the_bfd->filename, '.');
1148                         if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1149                           continue;
1150
1151                         if (strcmp (is3->the_bfd->filename,
1152                                     is2->the_bfd->filename))
1153                           {
1154                             is_ms_arch = 0;
1155                             break;
1156                           }
1157                       }
1158                   }
1159               }
1160
1161             /* This fragment might have come from an .obj file in a Microsoft
1162                import, and not an actual import record. If this is the case,
1163                then leave the filename alone.  */
1164             pnt = strrchr (is->the_bfd->filename, '.');
1165
1166             if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1167               {
1168                 int idata2 = 0, reloc_count=0;
1169                 asection *sec;
1170                 char *new_name, seq;
1171
1172                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1173                   {
1174                     if (strcmp (sec->name, ".idata\$2") == 0)
1175                       idata2 = 1;
1176                     reloc_count += sec->reloc_count;
1177                   }
1178
1179                 if (idata2) /* .idata2 is the TOC */
1180                   seq = 'a';
1181                 else if (reloc_count > 0) /* thunks */
1182                   seq = 'b';
1183                 else /* sentinel */
1184                   seq = 'c';
1185
1186                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1187                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1188                 is->the_bfd->filename = new_name;
1189
1190                 new_name = xmalloc (strlen (is->filename) + 3);
1191                 sprintf (new_name, "%s.%c", is->filename, seq);
1192                 is->filename = new_name;
1193               }
1194           }
1195       }
1196   }
1197 }
1198 \f
1199 static void
1200 gld_${EMULATION_NAME}_before_allocation (void)
1201 {
1202   before_allocation_default ();
1203 }
1204 \f
1205 #ifdef DLL_SUPPORT
1206 /* This is called when an input file isn't recognized as a BFD.  We
1207    check here for .DEF files and pull them in automatically.  */
1208
1209 static int
1210 saw_option (char *option)
1211 {
1212   int i;
1213
1214   for (i = 0; init[i].ptr; i++)
1215     if (strcmp (init[i].symbol, option) == 0)
1216       return init[i].inited;
1217   return 0;
1218 }
1219 #endif /* DLL_SUPPORT */
1220
1221 static bfd_boolean
1222 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1223 {
1224 #ifdef DLL_SUPPORT
1225   const char *ext = entry->filename + strlen (entry->filename) - 4;
1226
1227   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1228     {
1229       pep_def_file = def_file_parse (entry->filename, pep_def_file);
1230
1231       if (pep_def_file)
1232         {
1233           int i, buflen=0, len;
1234           char *buf;
1235
1236           for (i = 0; i < pep_def_file->num_exports; i++)
1237             {
1238               len = strlen (pep_def_file->exports[i].internal_name);
1239               if (buflen < len + 2)
1240                 buflen = len + 2;
1241             }
1242
1243           buf = xmalloc (buflen);
1244
1245           for (i = 0; i < pep_def_file->num_exports; i++)
1246             {
1247               struct bfd_link_hash_entry *h;
1248
1249               sprintf (buf, "_%s", pep_def_file->exports[i].internal_name);
1250
1251               h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1252               if (h == (struct bfd_link_hash_entry *) NULL)
1253                 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1254               if (h->type == bfd_link_hash_new)
1255                 {
1256                   h->type = bfd_link_hash_undefined;
1257                   h->u.undef.abfd = NULL;
1258                   bfd_link_add_undef (link_info.hash, h);
1259                 }
1260             }
1261           free (buf);
1262
1263           /* def_file_print (stdout, pep_def_file); */
1264           if (pep_def_file->is_dll == 1)
1265             link_info.shared = 1;
1266
1267           if (pep_def_file->base_address != (bfd_vma)(-1))
1268             {
1269               pep.ImageBase =
1270                 pe_data (output_bfd)->pe_opthdr.ImageBase =
1271                 init[IMAGEBASEOFF].value = pep_def_file->base_address;
1272               init[IMAGEBASEOFF].inited = 1;
1273               if (image_base_statement)
1274                 image_base_statement->exp =
1275                   exp_assop ('=', "__image_base__", exp_intop (pep.ImageBase));
1276             }
1277
1278           if (pep_def_file->stack_reserve != -1
1279               && ! saw_option ("__size_of_stack_reserve__"))
1280             {
1281               pep.SizeOfStackReserve = pep_def_file->stack_reserve;
1282               if (pep_def_file->stack_commit != -1)
1283                 pep.SizeOfStackCommit = pep_def_file->stack_commit;
1284             }
1285           if (pep_def_file->heap_reserve != -1
1286               && ! saw_option ("__size_of_heap_reserve__"))
1287             {
1288               pep.SizeOfHeapReserve = pep_def_file->heap_reserve;
1289               if (pep_def_file->heap_commit != -1)
1290                 pep.SizeOfHeapCommit = pep_def_file->heap_commit;
1291             }
1292           return TRUE;
1293         }
1294     }
1295 #endif
1296   return FALSE;
1297 }
1298
1299 static bfd_boolean
1300 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1301 {
1302 #ifdef DLL_SUPPORT
1303 #ifdef TARGET_IS_i386pep
1304   pep_dll_id_target ("pei-x86-64");
1305 #endif
1306   if (bfd_get_format (entry->the_bfd) == bfd_object)
1307     {
1308       char fbuf[LD_PATHMAX + 1];
1309       const char *ext;
1310
1311       if (REALPATH (entry->filename, fbuf) == NULL)
1312         strncpy (fbuf, entry->filename, sizeof (fbuf));
1313
1314       ext = fbuf + strlen (fbuf) - 4;
1315
1316       if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1317         return pep_implied_import_dll (fbuf);
1318     }
1319 #endif
1320   return FALSE;
1321 }
1322
1323 static void
1324 gld_${EMULATION_NAME}_finish (void)
1325 {
1326   finish_default ();
1327
1328 #ifdef DLL_SUPPORT
1329   if (link_info.shared
1330       || (!link_info.relocatable && pep_def_file->num_exports != 0))
1331     {
1332       pep_dll_fill_sections (output_bfd, &link_info);
1333       if (pep_implib_filename)
1334         pep_dll_generate_implib (pep_def_file, pep_implib_filename);
1335     }
1336
1337   if (pep_out_def_filename)
1338     pep_dll_generate_def_file (pep_out_def_filename);
1339 #endif /* DLL_SUPPORT */
1340
1341   /* I don't know where .idata gets set as code, but it shouldn't be.  */
1342   {
1343     asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1344
1345     if (asec)
1346       {
1347         asec->flags &= ~SEC_CODE;
1348         asec->flags |= SEC_DATA;
1349       }
1350   }
1351 }
1352
1353 \f
1354 /* Place an orphan section.
1355
1356    We use this to put sections in a reasonable place in the file, and
1357    to ensure that they are aligned as required.
1358
1359    We handle grouped sections here as well.  A section named .foo$nn
1360    goes into the output section .foo.  All grouped sections are sorted
1361    by name.
1362
1363    Grouped sections for the default sections are handled by the
1364    default linker script using wildcards, and are sorted by
1365    sort_sections.  */
1366
1367 static bfd_boolean
1368 gld_${EMULATION_NAME}_place_orphan (asection *s)
1369 {
1370   const char *secname;
1371   const char *orig_secname;
1372   char *dollar = NULL;
1373   lang_output_section_statement_type *os;
1374   lang_statement_list_type add_child;
1375
1376   secname = bfd_get_section_name (s->owner, s);
1377
1378   /* Look through the script to see where to place this section.  */
1379   orig_secname = secname;
1380   if (!link_info.relocatable
1381       && (dollar = strchr (secname, '$')) != NULL)
1382     {
1383       size_t len = dollar - orig_secname;
1384       char *newname = xmalloc (len + 1);
1385       memcpy (newname, orig_secname, len);
1386       newname[len] = '\0';
1387       secname = newname;
1388     }
1389
1390   os = lang_output_section_find (secname);
1391
1392   lang_list_init (&add_child);
1393
1394   if (os != NULL
1395       && (os->bfd_section == NULL
1396           || os->bfd_section->flags == 0
1397           || ((s->flags ^ os->bfd_section->flags)
1398               & (SEC_LOAD | SEC_ALLOC)) == 0))
1399     {
1400       /* We already have an output section statement with this
1401          name, and its bfd section, if any, has compatible flags.
1402          If the section already exists but does not have any flags set,
1403          then it has been created by the linker, probably as a result of
1404          a --section-start command line switch.  */
1405       lang_add_section (&add_child, s, os);
1406     }
1407   else
1408     {
1409       static struct orphan_save hold[] =
1410         {
1411           { ".text",
1412             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1413             0, 0, 0, 0 },
1414           { ".rdata",
1415             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1416             0, 0, 0, 0 },
1417           { ".data",
1418             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1419             0, 0, 0, 0 },
1420           { ".bss",
1421             SEC_ALLOC,
1422             0, 0, 0, 0 }
1423         };
1424       enum orphan_save_index
1425         {
1426           orphan_text = 0,
1427           orphan_rodata,
1428           orphan_data,
1429           orphan_bss
1430         };
1431       static int orphan_init_done = 0;
1432       struct orphan_save *place;
1433       lang_output_section_statement_type *after;
1434       etree_type *address;
1435
1436       if (!orphan_init_done)
1437         {
1438           struct orphan_save *ho;
1439           for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1440             if (ho->name != NULL)
1441               {
1442                 ho->os = lang_output_section_find (ho->name);
1443                 if (ho->os != NULL && ho->os->flags == 0)
1444                   ho->os->flags = ho->flags;
1445               }
1446           orphan_init_done = 1;
1447         }
1448
1449       /* Try to put the new output section in a reasonable place based
1450          on the section name and section flags.  */
1451
1452       place = NULL;
1453       if ((s->flags & SEC_ALLOC) == 0)
1454         ;
1455       else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1456         place = &hold[orphan_bss];
1457       else if ((s->flags & SEC_READONLY) == 0)
1458         place = &hold[orphan_data];
1459       else if ((s->flags & SEC_CODE) == 0)
1460         place = &hold[orphan_rodata];
1461       else
1462         place = &hold[orphan_text];
1463
1464       after = NULL;
1465       if (place != NULL)
1466         {
1467           if (place->os == NULL)
1468             place->os = lang_output_section_find (place->name);
1469           after = place->os;
1470           if (after == NULL)
1471             after = lang_output_section_find_by_flags (s, &place->os, NULL);
1472           if (after == NULL)
1473             /* *ABS* is always the first output section statement.  */
1474             after = (&lang_output_section_statement.head
1475                      ->output_section_statement);
1476         }
1477
1478       /* Choose a unique name for the section.  This will be needed if the
1479          same section name appears in the input file with different
1480          loadable or allocatable characteristics.  */
1481       if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1482         {
1483           static int count = 1;
1484           secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1485           if (secname == NULL)
1486             einfo ("%F%P: place_orphan failed: %E\n");
1487         }
1488
1489       /* All sections in an executable must be aligned to a page boundary.  */
1490       address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
1491       os = lang_insert_orphan (s, secname, after, place, address, &add_child);
1492     }
1493
1494   {
1495     lang_statement_union_type **pl = &os->children.head;
1496
1497     if (dollar != NULL)
1498       {
1499         bfd_boolean found_dollar;
1500
1501         /* The section name has a '$'.  Sort it with the other '$'
1502            sections.  */
1503         found_dollar = FALSE;
1504         for ( ; *pl != NULL; pl = &(*pl)->header.next)
1505           {
1506             lang_input_section_type *ls;
1507             const char *lname;
1508
1509             if ((*pl)->header.type != lang_input_section_enum)
1510               continue;
1511
1512             ls = &(*pl)->input_section;
1513
1514             lname = bfd_get_section_name (ls->section->owner, ls->section);
1515             if (strchr (lname, '$') == NULL)
1516               {
1517                 if (found_dollar)
1518                   break;
1519               }
1520             else
1521               {
1522                 found_dollar = TRUE;
1523                 if (strcmp (orig_secname, lname) < 0)
1524                   break;
1525               }
1526           }
1527       }
1528
1529     if (add_child.head != NULL)
1530       {
1531         add_child.head->header.next = *pl;
1532         *pl = add_child.head;
1533       }
1534   }
1535
1536   return TRUE;
1537 }
1538
1539 static bfd_boolean
1540 gld_${EMULATION_NAME}_open_dynamic_archive
1541   (const char *arch ATTRIBUTE_UNUSED,
1542    search_dirs_type *search,
1543    lang_input_statement_type *entry)
1544 {
1545   static const struct
1546     {
1547       const char * format;
1548       bfd_boolean use_prefix;
1549     }
1550   libname_fmt [] =
1551     {
1552       /* Preferred explicit import library for dll's.  */
1553       { "lib%s.dll.a", FALSE },
1554       /* Alternate explicit import library for dll's.  */
1555       { "%s.dll.a", FALSE },
1556       /* "libfoo.a" could be either an import lib or a static lib.
1557           For backwards compatibility, libfoo.a needs to precede
1558           libfoo.dll and foo.dll in the search.  */
1559       { "lib%s.a", FALSE },
1560       /* The 'native' spelling of an import lib name is "foo.lib".  */
1561       { "%s.lib", FALSE },
1562 #ifdef DLL_SUPPORT
1563       /* Try "<prefix>foo.dll" (preferred dll name, if specified).  */
1564       { "%s%s.dll", TRUE },
1565 #endif
1566       /* Try "libfoo.dll" (default preferred dll name).  */
1567       { "lib%s.dll", FALSE },
1568       /* Finally try 'native' dll name "foo.dll".  */
1569       {  "%s.dll", FALSE },
1570       /* Note: If adding more formats to this table, make sure to check to
1571          see if their length is longer than libname_fmt[0].format, and if
1572          so, update the call to xmalloc() below.  */
1573       { NULL, FALSE }
1574     };
1575   static unsigned int format_max_len = 0;
1576   const char * filename;
1577   char * full_string;
1578   char * base_string;
1579   unsigned int i;
1580
1581
1582   if (! entry->is_archive)
1583     return FALSE;
1584
1585   filename = entry->filename;
1586
1587   if (format_max_len == 0)
1588     /* We need to allow space in the memory that we are going to allocate
1589        for the characters in the format string.  Since the format array is
1590        static we only need to calculate this information once.  In theory
1591        this value could also be computed statically, but this introduces
1592        the possibility for a discrepancy and hence a possible memory
1593        corruption.  The lengths we compute here will be too long because
1594        they will include any formating characters (%s) in the strings, but
1595        this will not matter.  */
1596     for (i = 0; libname_fmt[i].format; i++)
1597       if (format_max_len < strlen (libname_fmt[i].format))
1598         format_max_len = strlen (libname_fmt[i].format);
1599
1600   full_string = xmalloc (strlen (search->name)
1601                          + strlen (filename)
1602                          + format_max_len
1603 #ifdef DLL_SUPPORT
1604                          + (pep_dll_search_prefix
1605                             ? strlen (pep_dll_search_prefix) : 0)
1606 #endif
1607                          /* Allow for the terminating NUL and for the path
1608                             separator character that is inserted between
1609                             search->name and the start of the format string.  */
1610                          + 2);
1611
1612   sprintf (full_string, "%s/", search->name);
1613   base_string = full_string + strlen (full_string);
1614
1615   for (i = 0; libname_fmt[i].format; i++)
1616     {
1617 #ifdef DLL_SUPPORT
1618       if (libname_fmt[i].use_prefix)
1619         {
1620           if (!pep_dll_search_prefix)
1621             continue;
1622           sprintf (base_string, libname_fmt[i].format, pep_dll_search_prefix, filename);
1623         }
1624       else
1625 #endif
1626         sprintf (base_string, libname_fmt[i].format, filename);
1627
1628       if (ldfile_try_open_bfd (full_string, entry))
1629         break;
1630     }
1631
1632   if (!libname_fmt[i].format)
1633     {
1634       free (full_string);
1635       return FALSE;
1636     }
1637
1638   entry->filename = full_string;
1639
1640   return TRUE;
1641 }
1642
1643 static int
1644 gld_${EMULATION_NAME}_find_potential_libraries
1645   (char *name, lang_input_statement_type *entry)
1646 {
1647   return ldfile_open_file_search (name, entry, "", ".lib");
1648 }
1649 \f
1650 static char *
1651 gld_${EMULATION_NAME}_get_script (int *isfile)
1652 EOF
1653 # Scripts compiled in.
1654 # sed commands to quote an ld script as a C string.
1655 sc="-f stringify.sed"
1656
1657 cat >>e${EMULATION_NAME}.c <<EOF
1658 {
1659   *isfile = 0;
1660
1661   if (link_info.relocatable && config.build_constructors)
1662     return
1663 EOF
1664 sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
1665 echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
1666 sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
1667 echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
1668 sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
1669 echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
1670 sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
1671 echo '  ; else return'                                  >> e${EMULATION_NAME}.c
1672 sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
1673 echo '; }'                                              >> e${EMULATION_NAME}.c
1674
1675 cat >>e${EMULATION_NAME}.c <<EOF
1676
1677
1678 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1679 {
1680   gld_${EMULATION_NAME}_before_parse,
1681   syslib_default,
1682   hll_default,
1683   gld_${EMULATION_NAME}_after_parse,
1684   gld_${EMULATION_NAME}_after_open,
1685   after_allocation_default,
1686   set_output_arch_default,
1687   ldemul_default_target,
1688   gld_${EMULATION_NAME}_before_allocation,
1689   gld_${EMULATION_NAME}_get_script,
1690   "${EMULATION_NAME}",
1691   "${OUTPUT_FORMAT}",
1692   gld_${EMULATION_NAME}_finish,
1693   NULL, /* Create output section statements.  */
1694   gld_${EMULATION_NAME}_open_dynamic_archive,
1695   gld_${EMULATION_NAME}_place_orphan,
1696   gld_${EMULATION_NAME}_set_symbols,
1697   NULL, /* parse_args */
1698   gld${EMULATION_NAME}_add_options,
1699   gld${EMULATION_NAME}_handle_option,
1700   gld_${EMULATION_NAME}_unrecognized_file,
1701   gld_${EMULATION_NAME}_list_options,
1702   gld_${EMULATION_NAME}_recognized_file,
1703   gld_${EMULATION_NAME}_find_potential_libraries,
1704   NULL  /* new_vers_pattern.  */
1705 };
1706 EOF