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