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