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