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