ld/emultempl/pe.em

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