ld/emultempl/pe.em

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