ld/emultempl/pe.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 rm -f e${EMULATION_NAME}.c
   4 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
   5 cat >>e${EMULATION_NAME}.c <<EOF
   6 /* This file is part of GLD, the Gnu Linker.
   7    Copyright 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 /* For WINDOWS_NT */
  24 /* The original file generated returned different default scripts depending
  25    on whether certain switches were set, but these switches pertain to the
  26    Linux system and that particular version of coff.  In the NT case, we
  27    only determine if the subsystem is console or windows in order to select
  28    the correct entry point by default. */
  29
  30 #include "bfd.h"
  31 #include "sysdep.h"
  32 #include "bfdlink.h"
  33 #include "getopt.h"
  34 #include "libiberty.h"
  35 #include "ld.h"
  36 #include "ldmain.h"
  37 #include "ldgram.h"
  38 #include "ldexp.h"
  39 #include "ldlang.h"
  40 #include "ldfile.h"
  41 #include "ldemul.h"
  42 #include "ldlex.h"
  43 #include "ldmisc.h"
  44 #include "ldctor.h"
  45 #include "coff/internal.h"
  46
  47 /* FIXME: This is a BFD internal header file, and we should not be
  48    using it here.  */
  49 #include "../bfd/libcoff.h"
  50
  51 #include "deffile.h"
  52 #include "pe-dll.h"
  53
  54 #define TARGET_IS_${EMULATION_NAME}
  55
  56 /* Permit the emulation parameters to override the default section
  57    alignment by setting OVERRIDE_SECTION_ALIGNMENT.  FIXME: This makes
  58    it seem that include/coff/internal.h should not define
  59    PE_DEF_SECTION_ALIGNMENT.  */
  60 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
  61 #undef PE_DEF_SECTION_ALIGNMENT
  62 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
  63 #endif
  64
  65 #if defined(TARGET_IS_i386pe)
  66 #define DLL_SUPPORT
  67 #endif
  68 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe) || defined(TARGET_IS_armpe)
  69 #define DLL_SUPPORT
  70 #endif
  71
  72 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
  73 #define PE_DEF_SUBSYSTEM                3
  74 #else
  75 #undef NT_EXE_IMAGE_BASE
  76 #undef PE_DEF_SECTION_ALIGNMENT
  77 #undef PE_DEF_FILE_ALIGNMENT
  78 #define NT_EXE_IMAGE_BASE               0x00010000
  79 #ifdef TARGET_IS_armpe
  80 #define PE_DEF_SECTION_ALIGNMENT        0x00001000
  81 #define PE_DEF_SUBSYSTEM                9
  82 #else
  83 #define PE_DEF_SECTION_ALIGNMENT        0x00000400
  84 #define PE_DEF_SUBSYSTEM                2
  85 #endif
  86 #define PE_DEF_FILE_ALIGNMENT           0x00000200
  87 #endif
  88
  89 #ifdef TARGET_IS_arm_epoc_pe
  90 #define bfd_arm_pe_allocate_interworking_sections \
  91         bfd_arm_epoc_pe_allocate_interworking_sections
  92 #define bfd_arm_pe_get_bfd_for_interworking \
  93         bfd_arm_epoc_pe_get_bfd_for_interworking
  94 #define bfd_arm_pe_process_before_allocation \
  95         bfd_arm_epoc_pe_process_before_allocation
  96 #endif
  97
  98 static void gld_${EMULATION_NAME}_set_symbols PARAMS ((void));
  99 static void gld_${EMULATION_NAME}_after_open PARAMS ((void));
 100 static void gld_${EMULATION_NAME}_before_parse PARAMS ((void));
 101 static void gld_${EMULATION_NAME}_after_parse PARAMS ((void));
 102 static void gld_${EMULATION_NAME}_before_allocation PARAMS ((void));
 103 static boolean gld_${EMULATION_NAME}_place_orphan
 104   PARAMS ((lang_input_statement_type *, asection *));
 105 static char *gld_${EMULATION_NAME}_get_script PARAMS ((int *));
 106 static int gld_${EMULATION_NAME}_parse_args PARAMS ((int, char **));
 107 static void gld_${EMULATION_NAME}_finish PARAMS ((void));
 108 static boolean gld_${EMULATION_NAME}_open_dynamic_archive
 109   PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
 110
 111 static struct internal_extra_pe_aouthdr pe;
 112 static int dll;
 113 static int support_old_code = 0;
 114 static char * thumb_entry_symbol = NULL;
 115 static lang_assignment_statement_type *image_base_statement = 0;
 116
 117 #ifdef DLL_SUPPORT
 118 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable */
 119 static char *pe_out_def_filename = NULL;
 120 static char *pe_implib_filename = NULL;
 121 static int pe_enable_auto_image_base = 0;
 122 #endif
 123
 124 extern const char *output_filename;
 125
 126 static void
 127 gld_${EMULATION_NAME}_before_parse()
 128 {
 129   output_filename = "${EXECUTABLE_NAME:-a.exe}";
 130   ldfile_output_architecture = bfd_arch_${ARCH};
 131 #ifdef DLL_SUPPORT
 132   config.has_shared = 1;
 133
 134 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
 135 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
 136   lang_add_entry ("WinMainCRTStartup", 1);
 137 #else
 138   lang_add_entry ("_WinMainCRTStartup", 1);
 139 #endif
 140 #endif
 141 #endif
 142 }
 143 \f
 144 /* PE format extra command line options.  */
 145
 146 /* Used for setting flags in the PE header. */
 147 #define OPTION_BASE_FILE                (300  + 1)
 148 #define OPTION_DLL                      (OPTION_BASE_FILE + 1)
 149 #define OPTION_FILE_ALIGNMENT           (OPTION_DLL + 1)
 150 #define OPTION_IMAGE_BASE               (OPTION_FILE_ALIGNMENT + 1)
 151 #define OPTION_MAJOR_IMAGE_VERSION      (OPTION_IMAGE_BASE + 1)
 152 #define OPTION_MAJOR_OS_VERSION         (OPTION_MAJOR_IMAGE_VERSION + 1)
 153 #define OPTION_MAJOR_SUBSYSTEM_VERSION  (OPTION_MAJOR_OS_VERSION + 1)
 154 #define OPTION_MINOR_IMAGE_VERSION      (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
 155 #define OPTION_MINOR_OS_VERSION         (OPTION_MINOR_IMAGE_VERSION + 1)
 156 #define OPTION_MINOR_SUBSYSTEM_VERSION  (OPTION_MINOR_OS_VERSION + 1)
 157 #define OPTION_SECTION_ALIGNMENT        (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
 158 #define OPTION_STACK                    (OPTION_SECTION_ALIGNMENT + 1)
 159 #define OPTION_SUBSYSTEM                (OPTION_STACK + 1)
 160 #define OPTION_HEAP                     (OPTION_SUBSYSTEM + 1)
 161 #define OPTION_SUPPORT_OLD_CODE         (OPTION_HEAP + 1)
 162 #define OPTION_OUT_DEF                  (OPTION_SUPPORT_OLD_CODE + 1)
 163 #define OPTION_EXPORT_ALL               (OPTION_OUT_DEF + 1)
 164 #define OPTION_EXCLUDE_SYMBOLS          (OPTION_EXPORT_ALL + 1)
 165 #define OPTION_KILL_ATS                 (OPTION_EXCLUDE_SYMBOLS + 1)
 166 #define OPTION_STDCALL_ALIASES          (OPTION_KILL_ATS + 1)
 167 #define OPTION_ENABLE_STDCALL_FIXUP     (OPTION_STDCALL_ALIASES + 1)
 168 #define OPTION_DISABLE_STDCALL_FIXUP    (OPTION_ENABLE_STDCALL_FIXUP + 1)
 169 #define OPTION_IMPLIB_FILENAME          (OPTION_DISABLE_STDCALL_FIXUP + 1)
 170 #define OPTION_THUMB_ENTRY              (OPTION_IMPLIB_FILENAME + 1)
 171 #define OPTION_WARN_DUPLICATE_EXPORTS   (OPTION_THUMB_ENTRY + 1)
 172 #define OPTION_IMP_COMPAT               (OPTION_WARN_DUPLICATE_EXPORTS + 1)
 173 #define OPTION_ENABLE_AUTO_IMAGE_BASE   (OPTION_IMP_COMPAT + 1)
 174 #define OPTION_DISABLE_AUTO_IMAGE_BASE  (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
 175
 176 static struct option longopts[] =
 177 {
 178   /* PE options */
 179   {"base-file", required_argument, NULL, OPTION_BASE_FILE},
 180   {"dll", no_argument, NULL, OPTION_DLL},
 181   {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
 182   {"heap", required_argument, NULL, OPTION_HEAP},
 183   {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
 184   {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
 185   {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
 186   {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
 187   {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
 188   {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
 189   {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
 190   {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
 191   {"stack", required_argument, NULL, OPTION_STACK},
 192   {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
 193   {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
 194   {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
 195 #ifdef DLL_SUPPORT
 196   /* getopt allows abbreviations, so we do this to stop it from treating -o
 197      as an abbreviation for this option */
 198   {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 199   {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 200   {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
 201   {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
 202   {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
 203   {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
 204   {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
 205   {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
 206   {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
 207   {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
 208   {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 209   {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
 210   {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
 211 #endif
 212   {NULL, no_argument, NULL, 0}
 213 };
 214
 215
 216 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
 217    parameters which may be input from the command line */
 218
 219 typedef struct
 220 {
 221   void *ptr;
 222   int size;
 223   int value;
 224   char *symbol;
 225   int inited;
 226 } definfo;
 227
 228 #define D(field,symbol,def)  {&pe.field,sizeof(pe.field), def, symbol,0}
 229
 230 static definfo init[] =
 231 {
 232   /* imagebase must be first */
 233 #define IMAGEBASEOFF 0
 234   D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
 235 #define DLLOFF 1
 236   {&dll, sizeof(dll), 0, "__dll__", 0},
 237   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
 238   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
 239   D(MajorOperatingSystemVersion,"__major_os_version__", 4),
 240   D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
 241   D(MajorImageVersion,"__major_image_version__", 1),
 242   D(MinorImageVersion,"__minor_image_version__", 0),
 243 #ifdef TARGET_IS_armpe
 244   D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
 245 #else
 246   D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
 247 #endif
 248   D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
 249   D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
 250   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x2000000),
 251   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
 252   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
 253   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
 254   D(LoaderFlags,"__loader_flags__", 0x0),
 255   { NULL, 0, 0, NULL, 0 }
 256 };
 257
 258 static void
 259 gld_${EMULATION_NAME}_list_options (file)
 260      FILE * file;
 261 {
 262   fprintf (file, _("  --base_file <basefile>             Generate a base file for relocatable DLLs\n"));
 263   fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));
 264   fprintf (file, _("  --file-alignment <size>            Set file alignment\n"));
 265   fprintf (file, _("  --heap <size>                      Set initial size of the heap\n"));
 266   fprintf (file, _("  --image-base <address>             Set start address of the executable\n"));
 267   fprintf (file, _("  --major-image-version <number>     Set version number of the executable\n"));
 268   fprintf (file, _("  --major-os-version <number>        Set minimum required OS version\n"));
 269   fprintf (file, _("  --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
 270   fprintf (file, _("  --minor-image-version <number>     Set revision number of the executable\n"));
 271   fprintf (file, _("  --minor-os-version <number>        Set minimum required OS revision\n"));
 272   fprintf (file, _("  --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
 273   fprintf (file, _("  --section-alignment <size>         Set section alignment\n"));
 274   fprintf (file, _("  --stack <size>                     Set size of the initial stack\n"));
 275   fprintf (file, _("  --subsystem <name>[:<version>]     Set required OS subsystem [& version]\n"));
 276   fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));
 277   fprintf (file, _("  --thumb-entry=<symbol>             Set the entry point to be Thumb <symbol>\n"));
 278 #ifdef DLL_SUPPORT
 279   fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));
 280   fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));
 281   fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));
 282   fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));
 283   fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));
 284   fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));
 285   fprintf (file, _("  --out-implib <file>                Generate import library\n"));
 286   fprintf (file, _("  --output-def <file>                Generate a .DEF file for the built DLL\n"));
 287   fprintf (file, _("  --warn-duplicate-exports           Warn about duplicate exports.\n"));
 288   fprintf (file, _("  --compat-implib                    Create backward compatible import libs;\n"));
 289   fprintf (file, _("                                       create __imp_<SYMBOL> as well.\n"));
 290   fprintf (file, _("  --enable-auto-image-base           Automatically choose image base for DLLs\n"));
 291   fprintf (file, _("                                       unless user specifies one\n"));
 292   fprintf (file, _("  --disable-auto-image-base          Do not auto-choose image base. (default)\n"));
 293 #endif
 294 }
 295
 296 static void
 297 set_pe_name (name, val)
 298      char *name;
 299      long val;
 300 {
 301   int i;
 302   /* Find the name and set it. */
 303   for (i = 0; init[i].ptr; i++)
 304     {
 305       if (strcmp (name, init[i].symbol) == 0)
 306         {
 307           init[i].value = val;
 308           init[i].inited = 1;
 309           return;
 310         }
 311     }
 312   abort();
 313 }
 314
 315
 316 static void
 317 set_pe_subsystem ()
 318 {
 319   const char *sver;
 320   int len;
 321   int i;
 322   static const struct
 323     {
 324       const char *name;
 325       const int value;
 326       const char *entry;
 327     }
 328   v[] =
 329     {
 330       { "native", 1, "NtProcessStartup" },
 331 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
 332       { "windows", 2, "WinMainCRTStartup" },
 333 #else
 334       { "windows", 2, "WinMainCRTStartup" },
 335 #endif
 336       { "console", 3, "mainCRTStartup" },
 337 #if 0
 338       /* The Microsoft linker does not recognize this.  */
 339       { "os2", 5, "" },
 340 #endif
 341       { "posix", 7, "__PosixProcessStartup"},
 342       { "wince", 9, "_WinMainCRTStartup" },
 343       { 0, 0, 0 }
 344     };
 345
 346   sver = strchr (optarg, ':');
 347   if (sver == NULL)
 348     len = strlen (optarg);
 349   else
 350     {
 351       char *end;
 352
 353       len = sver - optarg;
 354       set_pe_name ("__major_subsystem_version__",
 355                    strtoul (sver + 1, &end, 0));
 356       if (*end == '.')
 357         set_pe_name ("__minor_subsystem_version__",
 358                      strtoul (end + 1, &end, 0));
 359       if (*end != '\0')
 360         einfo (_("%P: warning: bad version number in -subsystem option\n"));
 361     }
 362
 363   for (i = 0; v[i].name; i++)
 364     {
 365       if (strncmp (optarg, v[i].name, len) == 0
 366           && v[i].name[len] == '\0')
 367         {
 368           const char *initial_symbol_char;
 369           const char *entry;
 370
 371           set_pe_name ("__subsystem__", v[i].value);
 372
 373           initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
 374           if (*initial_symbol_char == '\0')
 375             entry = v[i].entry;
 376           else
 377             {
 378               char *alc_entry;
 379
 380               /* lang_add_entry expects its argument to be permanently
 381                  allocated, so we don't free this string.  */
 382               alc_entry = xmalloc (strlen (initial_symbol_char)
 383                                    + strlen (v[i].entry)
 384                                    + 1);
 385               strcpy (alc_entry, initial_symbol_char);
 386               strcat (alc_entry, v[i].entry);
 387               entry = alc_entry;
 388             }
 389
 390           lang_add_entry (entry, 1);
 391
 392           return;
 393         }
 394     }
 395
 396   einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
 397 }
 398
 399
 400
 401 static void
 402 set_pe_value (name)
 403      char *name;
 404
 405 {
 406   char *end;
 407
 408   set_pe_name (name,  strtoul (optarg, &end, 0));
 409
 410   if (end == optarg)
 411     einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
 412
 413   optarg = end;
 414 }
 415
 416 static void
 417 set_pe_stack_heap (resname, comname)
 418      char *resname;
 419      char *comname;
 420 {
 421   set_pe_value (resname);
 422
 423   if (*optarg == ',')
 424     {
 425       optarg++;
 426       set_pe_value (comname);
 427     }
 428   else if (*optarg)
 429     einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
 430 }
 431
 432
 433
 434 static int
 435 gld_${EMULATION_NAME}_parse_args(argc, argv)
 436      int argc;
 437      char **argv;
 438 {
 439   int longind;
 440   int optc;
 441   int prevoptind = optind;
 442   int prevopterr = opterr;
 443   int wanterror;
 444   static int lastoptind = -1;
 445
 446   if (lastoptind != optind)
 447     opterr = 0;
 448   wanterror = opterr;
 449
 450   lastoptind = optind;
 451
 452   optc = getopt_long_only (argc, argv, "-", longopts, &longind);
 453   opterr = prevopterr;
 454
 455   switch (optc)
 456     {
 457     default:
 458       if (wanterror)
 459         xexit (1);
 460       optind =  prevoptind;
 461       return 0;
 462
 463     case OPTION_BASE_FILE:
 464       link_info.base_file = (PTR) fopen (optarg, FOPEN_WB);
 465       if (link_info.base_file == NULL)
 466         {
 467           /* xgettext:c-format */
 468           fprintf (stderr, _("%s: Can't open base file %s\n"),
 469                    program_name, optarg);
 470           xexit (1);
 471         }
 472       break;
 473
 474       /* PE options */
 475     case OPTION_HEAP:
 476       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 477       break;
 478     case OPTION_STACK:
 479       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 480       break;
 481     case OPTION_SUBSYSTEM:
 482       set_pe_subsystem ();
 483       break;
 484     case OPTION_MAJOR_OS_VERSION:
 485       set_pe_value ("__major_os_version__");
 486       break;
 487     case OPTION_MINOR_OS_VERSION:
 488       set_pe_value ("__minor_os_version__");
 489       break;
 490     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 491       set_pe_value ("__major_subsystem_version__");
 492       break;
 493     case OPTION_MINOR_SUBSYSTEM_VERSION:
 494       set_pe_value ("__minor_subsystem_version__");
 495       break;
 496     case OPTION_MAJOR_IMAGE_VERSION:
 497       set_pe_value ("__major_image_version__");
 498       break;
 499     case OPTION_MINOR_IMAGE_VERSION:
 500       set_pe_value ("__minor_image_version__");
 501       break;
 502     case OPTION_FILE_ALIGNMENT:
 503       set_pe_value ("__file_alignment__");
 504       break;
 505     case OPTION_SECTION_ALIGNMENT:
 506       set_pe_value ("__section_alignment__");
 507       break;
 508     case OPTION_DLL:
 509       set_pe_name ("__dll__", 1);
 510       break;
 511     case OPTION_IMAGE_BASE:
 512       set_pe_value ("__image_base__");
 513       break;
 514     case OPTION_SUPPORT_OLD_CODE:
 515       support_old_code = 1;
 516       break;
 517     case OPTION_THUMB_ENTRY:
 518       thumb_entry_symbol = optarg;
 519       break;
 520 #ifdef DLL_SUPPORT
 521     case OPTION_OUT_DEF:
 522       pe_out_def_filename = xstrdup (optarg);
 523       break;
 524     case OPTION_EXPORT_ALL:
 525       pe_dll_export_everything = 1;
 526       break;
 527     case OPTION_EXCLUDE_SYMBOLS:
 528       pe_dll_add_excludes (optarg);
 529       break;
 530     case OPTION_KILL_ATS:
 531       pe_dll_kill_ats = 1;
 532       break;
 533     case OPTION_STDCALL_ALIASES:
 534       pe_dll_stdcall_aliases = 1;
 535       break;
 536     case OPTION_ENABLE_STDCALL_FIXUP:
 537       pe_enable_stdcall_fixup = 1;
 538       break;
 539     case OPTION_DISABLE_STDCALL_FIXUP:
 540       pe_enable_stdcall_fixup = 0;
 541       break;
 542     case OPTION_IMPLIB_FILENAME:
 543       pe_implib_filename = xstrdup (optarg);
 544       break;
 545     case OPTION_WARN_DUPLICATE_EXPORTS:
 546       pe_dll_warn_dup_exports = 1;
 547       break;
 548     case OPTION_IMP_COMPAT:
 549       pe_dll_compat_implib = 1;
 550       break;
 551     case OPTION_ENABLE_AUTO_IMAGE_BASE:
 552       pe_enable_auto_image_base = 1;
 553       break;
 554     case OPTION_DISABLE_AUTO_IMAGE_BASE:
 555       pe_enable_auto_image_base = 0;
 556       break;
 557 #endif
 558     }
 559   return 1;
 560 }
 561 \f
 562
 563 #ifdef DLL_SUPPORT
 564 static unsigned long
 565 strhash (const char *str)
 566 {
 567   const unsigned char *s;
 568   unsigned long hash;
 569   unsigned int c;
 570   unsigned int len;
 571
 572   hash = 0;
 573   len = 0;
 574   s = (const unsigned char *) str;
 575   while ((c = *s++) != '\0')
 576     {
 577       hash += c + (c << 17);
 578       hash ^= hash >> 2;
 579       ++len;
 580     }
 581   hash += len + (len << 17);
 582   hash ^= hash >> 2;
 583
 584   return hash;
 585 }
 586
 587 /* Use the output file to create a image base for relocatable DLLs. */
 588 static unsigned long
 589 compute_dll_image_base (const char *ofile)
 590 {
 591   unsigned long hash = strhash (ofile);
 592   return 0x60000000 | ((hash << 16) & 0x0FFC0000);
 593 }
 594 #endif
 595
 596 /* Assign values to the special symbols before the linker script is
 597    read.  */
 598
 599 static void
 600 gld_${EMULATION_NAME}_set_symbols ()
 601 {
 602   /* Run through and invent symbols for all the
 603      names and insert the defaults. */
 604   int j;
 605   lang_statement_list_type *save;
 606
 607   if (!init[IMAGEBASEOFF].inited)
 608     {
 609       if (link_info.relocateable)
 610         init[IMAGEBASEOFF].value = 0;
 611       else if (init[DLLOFF].value || link_info.shared)
 612 #ifdef DLL_SUPPORT
 613         init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
 614           compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
 615 #else
 616         init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
 617 #endif
 618       else
 619         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
 620     }
 621
 622   /* Don't do any symbol assignments if this is a relocateable link.  */
 623   if (link_info.relocateable)
 624     return;
 625
 626   /* Glue the assignments into the abs section */
 627   save = stat_ptr;
 628
 629   stat_ptr = &(abs_output_section->children);
 630
 631   for (j = 0; init[j].ptr; j++)
 632     {
 633       long val = init[j].value;
 634       lang_assignment_statement_type *rv;
 635       rv = lang_add_assignment (exp_assop ('=' ,init[j].symbol, exp_intop (val)));
 636       if (init[j].size == sizeof(short))
 637         *(short *)init[j].ptr = val;
 638       else if (init[j].size == sizeof(int))
 639         *(int *)init[j].ptr = val;
 640       else if (init[j].size == sizeof(long))
 641         *(long *)init[j].ptr = val;
 642       /* This might be a long long or other special type.  */
 643       else if (init[j].size == sizeof(bfd_vma))
 644         *(bfd_vma *)init[j].ptr = val;
 645       else      abort();
 646       if (j == IMAGEBASEOFF)
 647         image_base_statement = rv;
 648     }
 649   /* Restore the pointer. */
 650   stat_ptr = save;
 651
 652   if (pe.FileAlignment >
 653       pe.SectionAlignment)
 654     {
 655       einfo (_("%P: warning, file alignment > section alignment.\n"));
 656     }
 657 }
 658
 659 /* This is called after the linker script and the command line options
 660    have been read.  */
 661
 662 static void
 663 gld_${EMULATION_NAME}_after_parse ()
 664 {
 665   /* The Windows libraries are designed for the linker to treat the
 666      entry point as an undefined symbol.  Otherwise, the .obj that
 667      defines mainCRTStartup is brought in because it is the first
 668      encountered in libc.lib and it has other symbols in it which will
 669      be pulled in by the link process.  To avoid this, we act as
 670      though the user specified -u with the entry point symbol.
 671
 672      This function is called after the linker script and command line
 673      options have been read, so at this point we know the right entry
 674      point.  This function is called before the input files are
 675      opened, so registering the symbol as undefined will make a
 676      difference.  */
 677
 678   if (! link_info.relocateable && entry_symbol != NULL)
 679     ldlang_add_undef (entry_symbol);
 680 }
 681
 682 #ifdef DLL_SUPPORT
 683 static struct bfd_link_hash_entry *pe_undef_found_sym;
 684
 685 static boolean
 686 pe_undef_cdecl_match (h, string)
 687   struct bfd_link_hash_entry *h;
 688   PTR string;
 689 {
 690   int sl = strlen (string);
 691   if (h->type == bfd_link_hash_defined
 692       && strncmp (h->root.string, string, sl) == 0
 693       && h->root.string[sl] == '@')
 694   {
 695     pe_undef_found_sym = h;
 696     return false;
 697   }
 698   return true;
 699 }
 700
 701 static void
 702 pe_fixup_stdcalls ()
 703 {
 704   static int gave_warning_message = 0;
 705   struct bfd_link_hash_entry *undef, *sym;
 706   char *at;
 707   for (undef = link_info.hash->undefs; undef; undef=undef->next)
 708     if (undef->type == bfd_link_hash_undefined)
 709     {
 710       at = strchr (undef->root.string, '@');
 711       if (at)
 712       {
 713         /* The symbol is a stdcall symbol, so let's look for a cdecl
 714            symbol with the same name and resolve to that */
 715         char *cname = xstrdup (undef->root.string);
 716         at = strchr (cname, '@');
 717         *at = 0;
 718         sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
 719         if (sym && sym->type == bfd_link_hash_defined)
 720         {
 721           undef->type = bfd_link_hash_defined;
 722           undef->u.def.value = sym->u.def.value;
 723           undef->u.def.section = sym->u.def.section;
 724           if (pe_enable_stdcall_fixup == -1)
 725             {
 726               einfo (_("Warning: resolving %s by linking to %s\n"),
 727                      undef->root.string, cname);
 728               if (! gave_warning_message)
 729                 {
 730                   gave_warning_message = 1;
 731                   einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
 732                   einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
 733                 }
 734             }
 735         }
 736       }
 737       else
 738       {
 739         /* The symbol is a cdecl symbol, so we look for stdcall
 740            symbols - which means scanning the whole symbol table */
 741         pe_undef_found_sym = 0;
 742         bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
 743                                 (PTR) undef->root.string);
 744         sym = pe_undef_found_sym;
 745         if (sym)
 746         {
 747           undef->type = bfd_link_hash_defined;
 748           undef->u.def.value = sym->u.def.value;
 749           undef->u.def.section = sym->u.def.section;
 750           if (pe_enable_stdcall_fixup == -1)
 751             {
 752               einfo (_("Warning: resolving %s by linking to %s\n"),
 753                      undef->root.string, sym->root.string);
 754               if (! gave_warning_message)
 755                 {
 756                   gave_warning_message = 1;
 757                   einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
 758                   einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
 759                 }
 760             }
 761         }
 762       }
 763     }
 764 }
 765 #endif /* DLL_SUPPORT */
 766
 767 static void
 768 gld_${EMULATION_NAME}_after_open ()
 769 {
 770   /* Pass the wacky PE command line options into the output bfd.
 771      FIXME: This should be done via a function, rather than by
 772      including an internal BFD header.  */
 773
 774   if (!coff_data (output_bfd)->pe)
 775     einfo (_("%F%P: PE operations on non PE file.\n"));
 776
 777   pe_data (output_bfd)->pe_opthdr = pe;
 778   pe_data (output_bfd)->dll = init[DLLOFF].value;
 779
 780 #ifdef DLL_SUPPORT
 781   if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
 782     pe_fixup_stdcalls ();
 783
 784   pe_process_import_defs(output_bfd, &link_info);
 785   if (link_info.shared)
 786     pe_dll_build_sections (output_bfd, &link_info);
 787
 788 #ifndef TARGET_IS_i386pe
 789 #ifndef TARGET_IS_armpe
 790   else
 791     pe_exe_build_sections (output_bfd, &link_info);
 792 #endif
 793 #endif
 794 #endif
 795
 796 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
 797   if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
 798     {
 799       /* The arm backend needs special fields in the output hash structure.
 800          These will only be created if the output format is an arm format,
 801          hence we do not support linking and changing output formats at the
 802          same time.  Use a link followed by objcopy to change output formats.  */
 803       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
 804       return;
 805     }
 806   {
 807     /* Find a BFD that can hold the interworking stubs.  */
 808     LANG_FOR_EACH_INPUT_STATEMENT (is)
 809       {
 810         if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
 811           break;
 812       }
 813   }
 814 #endif
 815
 816   {
 817     lang_input_statement_type *is2;
 818
 819     /* This next chunk of code tries to detect the case where you have
 820        two import libraries for the same DLL (specifically,
 821        symbolically linking libm.a and libc.a in cygwin to
 822        libcygwin.a).  In those cases, it's possible for function
 823        thunks from the second implib to be used but without the
 824        head/tail objects, causing an improper import table.  We detect
 825        those cases and rename the "other" import libraries to match
 826        the one the head/tail come from, so that the linker will sort
 827        things nicely and produce a valid import table. */
 828
 829     LANG_FOR_EACH_INPUT_STATEMENT (is)
 830       {
 831         if (is->the_bfd->my_archive)
 832           {
 833             int idata2 = 0, reloc_count=0, is_imp = 0;
 834             asection *sec;
 835             /* See if this is an import library thunk */
 836             for (sec = is->the_bfd->sections; sec; sec = sec->next)
 837               {
 838                 if (strcmp (sec->name, ".idata\$2") == 0)
 839                   idata2 = 1;
 840                 if (strncmp (sec->name, ".idata\$", 7) == 0)
 841                   is_imp = 1;
 842                 reloc_count += sec->reloc_count;
 843               }
 844             if (is_imp && !idata2 && reloc_count)
 845               {
 846                 /* it is, look for the reference to head and see if it's
 847                    from our own library */
 848                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
 849                   {
 850                     int i;
 851                     int symsize = bfd_get_symtab_upper_bound (is->the_bfd);
 852                     asymbol **symbols = (asymbol **) xmalloc (symsize);
 853                     int nsyms = bfd_canonicalize_symtab (is->the_bfd, symbols);
 854
 855                     int relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
 856                     arelent **relocs = (arelent **) xmalloc ((size_t) relsize);
 857                     int nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
 858                                                           relocs, symbols);
 859                     for (i=0; i<nrelocs; i++)
 860                       {
 861                         struct symbol_cache_entry *s;
 862                         s = (relocs[i]->sym_ptr_ptr)[0];
 863                         if (!s->flags & BSF_LOCAL)
 864                           {
 865                             /* thunk section with reloc to another bfd... */
 866                             struct bfd_link_hash_entry *blhe;
 867                             blhe = bfd_link_hash_lookup (link_info.hash,
 868                                                          s->name,
 869                                                          false, false, true);
 870                             if (blhe && blhe->type == bfd_link_hash_defined)
 871                               {
 872                                 bfd *other_bfd = blhe->u.def.section->owner;
 873                                 if (strcmp (is->the_bfd->my_archive->filename,
 874                                             other_bfd->my_archive->filename))
 875                                   {
 876                                     /* Rename this implib to match the other */
 877                                     char *n = (char *) xmalloc (strlen (other_bfd->my_archive->filename) + 1);
 878                                     strcpy (n, other_bfd->my_archive->filename);
 879                                     is->the_bfd->my_archive->filename = n;
 880                                   }
 881                               }
 882                           }
 883                       }
 884
 885                     free (relocs);
 886                   }
 887               }
 888           }
 889       }
 890   }
 891
 892   {
 893     int is_ms_arch = 0;
 894     bfd *cur_arch = 0;
 895     lang_input_statement_type *is2;
 896
 897     /* Careful - this is a shell script.  Watch those dollar signs! */
 898     /* Microsoft import libraries have every member named the same,
 899        and not in the right order for us to link them correctly.  We
 900        must detect these and rename the members so that they'll link
 901        correctly.  There are three types of objects: the head, the
 902        thunks, and the sentinel(s).  The head is easy; it's the one
 903        with idata2.  We assume that the sentinels won't have relocs,
 904        and the thunks will.  It's easier than checking the symbol
 905        table for external references.  */
 906     LANG_FOR_EACH_INPUT_STATEMENT (is)
 907       {
 908         if (is->the_bfd->my_archive)
 909           {
 910             bfd *arch = is->the_bfd->my_archive;
 911             if (cur_arch != arch)
 912               {
 913                 cur_arch = arch;
 914                 is_ms_arch = 1;
 915                 for (is2 = is;
 916                      is2 && is2->the_bfd->my_archive == arch;
 917                      is2 = (lang_input_statement_type *)is2->next)
 918                   {
 919                     if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
 920                       is_ms_arch = 0;
 921                   }
 922               }
 923
 924             if (is_ms_arch)
 925               {
 926                 int idata2 = 0, reloc_count=0;
 927                 asection *sec;
 928                 char *new_name, seq;
 929
 930                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
 931                   {
 932                     if (strcmp (sec->name, ".idata\$2") == 0)
 933                       idata2 = 1;
 934                     reloc_count += sec->reloc_count;
 935                   }
 936
 937                 if (idata2) /* .idata2 is the TOC */
 938                   seq = 'a';
 939                 else if (reloc_count > 0) /* thunks */
 940                   seq = 'b';
 941                 else /* sentinel */
 942                   seq = 'c';
 943
 944                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
 945                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
 946                 is->the_bfd->filename = new_name;
 947
 948                 new_name = xmalloc (strlen (is->filename) + 3);
 949                 sprintf (new_name, "%s.%c", is->filename, seq);
 950                 is->filename = new_name;
 951               }
 952           }
 953       }
 954   }
 955 }
 956 \f
 957 static void
 958 gld_${EMULATION_NAME}_before_allocation()
 959 {
 960 #ifdef TARGET_IS_ppcpe
 961   /* Here we rummage through the found bfds to collect toc information */
 962   {
 963     LANG_FOR_EACH_INPUT_STATEMENT (is)
 964       {
 965         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
 966           {
 967             /* xgettext:c-format */
 968             einfo (_("Errors encountered processing file %s\n"), is->filename);
 969           }
 970       }
 971   }
 972
 973   /* We have seen it all. Allocate it, and carry on */
 974   ppc_allocate_toc_section (&link_info);
 975 #endif /* TARGET_IS_ppcpe */
 976
 977 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
 978   /* FIXME: we should be able to set the size of the interworking stub
 979      section.
 980
 981      Here we rummage through the found bfds to collect glue
 982      information.  FIXME: should this be based on a command line
 983      option?  krk@cygnus.com */
 984   {
 985     LANG_FOR_EACH_INPUT_STATEMENT (is)
 986       {
 987         if (! bfd_arm_pe_process_before_allocation
 988             (is->the_bfd, & link_info, support_old_code))
 989           {
 990             /* xgettext:c-format */
 991             einfo (_("Errors encountered processing file %s for interworking"),
 992                    is->filename);
 993           }
 994       }
 995   }
 996
 997   /* We have seen it all. Allocate it, and carry on */
 998   bfd_arm_pe_allocate_interworking_sections (& link_info);
 999 #endif /* TARGET_IS_armpe */
1000 }
1001 \f
1002 #ifdef DLL_SUPPORT
1003 /* This is called when an input file isn't recognized as a BFD.  We
1004    check here for .DEF files and pull them in automatically. */
1005
1006 static int
1007 saw_option(char *option)
1008 {
1009   int i;
1010   for (i=0; init[i].ptr; i++)
1011     if (strcmp (init[i].symbol, option) == 0)
1012       return init[i].inited;
1013   return 0;
1014 }
1015 #endif /* DLL_SUPPORT */
1016
1017 static boolean
1018 gld_${EMULATION_NAME}_unrecognized_file(entry)
1019      lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1020 {
1021 #ifdef DLL_SUPPORT
1022   const char *ext = entry->filename + strlen (entry->filename) - 4;
1023
1024   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1025   {
1026     if (pe_def_file == 0)
1027       pe_def_file = def_file_empty ();
1028     def_file_parse (entry->filename, pe_def_file);
1029     if (pe_def_file)
1030     {
1031       int i, buflen=0, len;
1032       char *buf;
1033       for (i=0; i<pe_def_file->num_exports; i++)
1034         {
1035           len = strlen(pe_def_file->exports[i].internal_name);
1036           if (buflen < len+2)
1037             buflen = len+2;
1038         }
1039       buf = (char *) xmalloc (buflen);
1040       for (i=0; i<pe_def_file->num_exports; i++)
1041         {
1042           struct bfd_link_hash_entry *h;
1043           sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
1044
1045           h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true);
1046           if (h == (struct bfd_link_hash_entry *) NULL)
1047             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1048           if (h->type == bfd_link_hash_new)
1049             {
1050               h->type = bfd_link_hash_undefined;
1051               h->u.undef.abfd = NULL;
1052               bfd_link_add_undef (link_info.hash, h);
1053             }
1054         }
1055       free (buf);
1056
1057       /* def_file_print (stdout, pe_def_file); */
1058       if (pe_def_file->is_dll == 1)
1059         link_info.shared = 1;
1060
1061       if (pe_def_file->base_address != (bfd_vma)(-1))
1062       {
1063         pe.ImageBase =
1064         pe_data (output_bfd)->pe_opthdr.ImageBase =
1065         init[IMAGEBASEOFF].value = pe_def_file->base_address;
1066         init[IMAGEBASEOFF].inited = 1;
1067         if (image_base_statement)
1068           image_base_statement->exp =
1069             exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1070       }
1071
1072 #if 0
1073       /* Not sure if these *should* be set */
1074       if (pe_def_file->version_major != -1)
1075       {
1076         pe.MajorImageVersion = pe_def_file->version_major;
1077         pe.MinorImageVersion = pe_def_file->version_minor;
1078       }
1079 #endif
1080       if (pe_def_file->stack_reserve != -1
1081           && ! saw_option ("__size_of_stack_reserve__"))
1082       {
1083         pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1084         if (pe_def_file->stack_commit != -1)
1085           pe.SizeOfStackCommit = pe_def_file->stack_commit;
1086       }
1087       if (pe_def_file->heap_reserve != -1
1088           && ! saw_option ("__size_of_heap_reserve__"))
1089       {
1090         pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1091         if (pe_def_file->heap_commit != -1)
1092           pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1093       }
1094       return true;
1095     }
1096   }
1097 #endif
1098   return false;
1099
1100 }
1101
1102 static boolean
1103 gld_${EMULATION_NAME}_recognized_file(entry)
1104   lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1105 {
1106 #ifdef DLL_SUPPORT
1107 #ifdef TARGET_IS_i386pe
1108   pe_dll_id_target ("pei-i386");
1109 #endif
1110 #ifdef TARGET_IS_shpe
1111   pe_dll_id_target ("pei-shl");
1112 #endif
1113 #ifdef TARGET_IS_mipspe
1114   pe_dll_id_target ("pei-mips");
1115 #endif
1116 #ifdef TARGET_IS_armpe
1117   pe_dll_id_target ("pei-arm-little");
1118 #endif
1119   if (bfd_get_format (entry->the_bfd) == bfd_object)
1120     {
1121       const char *ext = entry->filename + strlen (entry->filename) - 4;
1122       if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1123         return pe_implied_import_dll (entry->filename);
1124     }
1125 #endif
1126   return false;
1127 }
1128
1129 static void
1130 gld_${EMULATION_NAME}_finish ()
1131 {
1132 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1133   struct bfd_link_hash_entry * h;
1134
1135   if (thumb_entry_symbol != NULL)
1136     {
1137       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol, false, false, true);
1138
1139       if (h != (struct bfd_link_hash_entry *) NULL
1140           && (h->type == bfd_link_hash_defined
1141               || h->type == bfd_link_hash_defweak)
1142           && h->u.def.section->output_section != NULL)
1143         {
1144           static char buffer[32];
1145           bfd_vma val;
1146
1147           /* Special procesing is required for a Thumb entry symbol.  The
1148              bottom bit of its address must be set.  */
1149           val = (h->u.def.value
1150                  + bfd_get_section_vma (output_bfd,
1151                                         h->u.def.section->output_section)
1152                  + h->u.def.section->output_offset);
1153
1154           val |= 1;
1155
1156           /* Now convert this value into a string and store it in entry_symbol
1157              where the lang_finish() function will pick it up.  */
1158           buffer[0] = '0';
1159           buffer[1] = 'x';
1160
1161           sprintf_vma (buffer + 2, val);
1162
1163           if (entry_symbol != NULL && entry_from_cmdline)
1164             einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1165                    thumb_entry_symbol, entry_symbol);
1166           entry_symbol = buffer;
1167         }
1168       else
1169         einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1170     }
1171 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1172
1173 #ifdef DLL_SUPPORT
1174   if (link_info.shared)
1175     {
1176       pe_dll_fill_sections (output_bfd, &link_info);
1177       if (pe_implib_filename)
1178         pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1179     }
1180 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1181   /* ARM doesn't need relocs.  */
1182   else
1183     {
1184       pe_exe_fill_sections (output_bfd, &link_info);
1185     }
1186 #endif
1187
1188   if (pe_out_def_filename)
1189     pe_dll_generate_def_file (pe_out_def_filename);
1190 #endif /* DLL_SUPPORT */
1191 }
1192
1193 \f
1194 /* Place an orphan section.
1195
1196    We use this to put sections in a reasonable place in the file, and
1197    to ensure that they are aligned as required.
1198
1199    We handle grouped sections here as well.  A section named .foo$nn
1200    goes into the output section .foo.  All grouped sections are sorted
1201    by name.
1202
1203    Grouped sections for the default sections are handled by the
1204    default linker script using wildcards, and are sorted by
1205    sort_sections.  */
1206
1207 struct orphan_save
1208 {
1209   lang_output_section_statement_type *os;
1210   asection **section;
1211   lang_statement_union_type **stmt;
1212 };
1213
1214 /*ARGSUSED*/
1215 static boolean
1216 gld_${EMULATION_NAME}_place_orphan (file, s)
1217      lang_input_statement_type *file;
1218      asection *s;
1219 {
1220   const char *secname;
1221   char *hold_section_name;
1222   char *dollar = NULL;
1223   lang_output_section_statement_type *os;
1224   lang_statement_list_type add_child;
1225
1226   secname = bfd_get_section_name (s->owner, s);
1227
1228   /* Look through the script to see where to place this section.  */
1229
1230   hold_section_name = xstrdup (secname);
1231   if (!link_info.relocateable)
1232     {
1233       dollar = strchr (hold_section_name, '$');
1234       if (dollar != NULL)
1235         *dollar = '\0';
1236     }
1237
1238   os = lang_output_section_find (hold_section_name);
1239
1240   lang_list_init (&add_child);
1241
1242   if (os != NULL
1243       && os->bfd_section != NULL
1244       && ((s->flags ^ os->bfd_section->flags) & (SEC_LOAD | SEC_ALLOC)) == 0)
1245     {
1246       wild_doit (&add_child, s, os, file);
1247     }
1248   else
1249     {
1250       struct orphan_save *place;
1251       static struct orphan_save hold_text;
1252       static struct orphan_save hold_rdata;
1253       static struct orphan_save hold_data;
1254       static struct orphan_save hold_bss;
1255       char *outsecname;
1256       lang_statement_list_type *old;
1257       lang_statement_list_type add;
1258       etree_type *address;
1259
1260       /* Try to put the new output section in a reasonable place based
1261          on the section name and section flags.  */
1262 #define HAVE_SECTION(hold, name) \
1263 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1264
1265       place = NULL;
1266       if ((s->flags & SEC_ALLOC) == 0)
1267         ;
1268       else if ((s->flags & SEC_HAS_CONTENTS) == 0
1269                && HAVE_SECTION (hold_bss, ".bss"))
1270         place = &hold_bss;
1271       else if ((s->flags & SEC_READONLY) == 0
1272                && HAVE_SECTION (hold_data, ".data"))
1273         place = &hold_data;
1274       else if ((s->flags & SEC_CODE) == 0
1275                && (s->flags & SEC_READONLY) != 0
1276                && HAVE_SECTION (hold_rdata, ".rdata"))
1277         place = &hold_rdata;
1278       else if ((s->flags & SEC_READONLY) != 0
1279                && HAVE_SECTION (hold_text, ".text"))
1280         place = &hold_text;
1281
1282 #undef HAVE_SECTION
1283
1284       /* Choose a unique name for the section.  This will be needed if
1285          the same section name appears in the input file with
1286          different loadable or allocateable characteristics.  */
1287       outsecname = xstrdup (hold_section_name);
1288       if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1289         {
1290           unsigned int len;
1291           char *newname;
1292           unsigned int i;
1293
1294           len = strlen (outsecname);
1295           newname = xmalloc (len + 5);
1296           strcpy (newname, outsecname);
1297           i = 0;
1298           do
1299             {
1300               sprintf (newname + len, "%d", i);
1301               ++i;
1302             }
1303           while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1304
1305           free (outsecname);
1306           outsecname = newname;
1307         }
1308
1309       /* Start building a list of statements for this section.  */
1310       old = stat_ptr;
1311       stat_ptr = &add;
1312       lang_list_init (stat_ptr);
1313
1314       if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1315         address = exp_intop ((bfd_vma) 0);
1316       else
1317         {
1318           /* All sections in an executable must be aligned to a page
1319              boundary.  */
1320           address = exp_unop (ALIGN_K,
1321                               exp_nameop (NAME, "__section_alignment__"));
1322         }
1323
1324       os = lang_enter_output_section_statement (outsecname, address, 0,
1325                                                 (bfd_vma) 0,
1326                                                 (etree_type *) NULL,
1327                                                 (etree_type *) NULL,
1328                                                 (etree_type *) NULL);
1329
1330       wild_doit (&add_child, s, os, file);
1331
1332       lang_leave_output_section_statement
1333         ((bfd_vma) 0, "*default*",
1334          (struct lang_output_section_phdr_list *) NULL, "*default*");
1335
1336       stat_ptr = old;
1337
1338       if (place != NULL)
1339         {
1340           asection *snew, **pps;
1341
1342           snew = os->bfd_section;
1343           if (place->os->bfd_section != NULL || place->section != NULL)
1344             {
1345               /* Shuffle the section to make the output file look neater.  */
1346               if (place->section == NULL)
1347                 {
1348 #if 0
1349                   /* Finding the end of the list is a little tricky.  We
1350                      make a wild stab at it by comparing section flags.  */
1351                   flagword first_flags = place->os->bfd_section->flags;
1352                   for (pps = &place->os->bfd_section->next;
1353                        *pps != NULL && (*pps)->flags == first_flags;
1354                        pps = &(*pps)->next)
1355                     ;
1356                   place->section = pps;
1357 #else
1358                   /* Put orphans after the first section on the list.  */
1359                   place->section = &place->os->bfd_section->next;
1360 #endif
1361                 }
1362
1363               /*  Unlink the section.  */
1364               for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1365                 ;
1366               *pps = snew->next;
1367
1368               /* Now tack it on to the "place->os" section list.  */
1369               snew->next = *place->section;
1370               *place->section = snew;
1371             }
1372           place->section = &snew->next; /* Save the end of this list.  */
1373
1374           if (place->stmt == NULL)
1375             {
1376               /* Put the new statement list right at the head.  */
1377               *add.tail = place->os->header.next;
1378               place->os->header.next = add.head;
1379             }
1380           else
1381             {
1382               /* Put it after the last orphan statement we added.  */
1383               *add.tail = *place->stmt;
1384               *place->stmt = add.head;
1385             }
1386           place->stmt = add.tail;       /* Save the end of this list.  */
1387         }
1388     }
1389
1390   {
1391     lang_statement_union_type **pl = &os->children.head;
1392
1393     if (dollar != NULL)
1394       {
1395         boolean found_dollar;
1396
1397         /* The section name has a '$'.  Sort it with the other '$'
1398            sections.  */
1399
1400         found_dollar = false;
1401         for ( ; *pl != NULL; pl = &(*pl)->next)
1402           {
1403             lang_input_section_type *ls;
1404             const char *lname;
1405
1406             if ((*pl)->header.type != lang_input_section_enum)
1407               continue;
1408
1409             ls = &(*pl)->input_section;
1410
1411             lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1412             if (strchr (lname, '$') == NULL)
1413               {
1414                 if (found_dollar)
1415                   break;
1416               }
1417             else
1418               {
1419                 found_dollar = true;
1420                 if (strcmp (secname, lname) < 0)
1421                   break;
1422               }
1423           }
1424       }
1425
1426     if (add_child.head != NULL)
1427       {
1428         add_child.head->next = *pl;
1429         *pl = add_child.head;
1430       }
1431   }
1432
1433   free (hold_section_name);
1434
1435   return true;
1436 }
1437
1438 static boolean
1439 gld_${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
1440      const char * arch ATTRIBUTE_UNUSED;
1441      search_dirs_type * search;
1442      lang_input_statement_type * entry;
1443 {
1444   const char * filename;
1445   char * string;
1446
1447   if (! entry->is_archive)
1448     return false;
1449
1450   filename = entry->filename;
1451
1452   string = (char *) xmalloc (strlen (search->name)
1453                              + strlen (filename)
1454                              + sizeof "/lib.a.dll"
1455                              + 1);
1456
1457   /* Try "libfoo.dll.a" first (preferred explicit import library for dll's */
1458   sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1459
1460   if (! ldfile_try_open_bfd (string, entry))
1461     {
1462       /* Try "foo.dll.a" next (alternate explicit import library for dll's */
1463       sprintf (string, "%s/%s.dll.a", search->name, filename);
1464       if (! ldfile_try_open_bfd (string, entry))
1465         {
1466 /*
1467    Try libfoo.a next. Normally, this would be interpreted as a static
1468    library, but it *could* be an import library. For backwards compatibility,
1469    libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1470    or sometimes errors occur when building legacy packages.
1471
1472    Putting libfoo.a here means that in a failure case (i.e. the library
1473    -lfoo is not found) we will search for libfoo.a twice before
1474    giving up -- once here, and once when searching for a "static" lib.
1475    for a "static" lib.
1476 */
1477           /* Try "libfoo.a" (import lib, or static lib, but must
1478              take precedence over dll's) */
1479           sprintf (string, "%s/lib%s.a", search->name, filename);
1480           if (! ldfile_try_open_bfd (string, entry))
1481             {
1482               /* Try "libfoo.dll" (preferred dll name) */
1483               sprintf (string, "%s/lib%s.dll", search->name, filename);
1484               if (! ldfile_try_open_bfd (string, entry))
1485                 {
1486                   /* Finally, try "foo.dll" (alternate dll name) */
1487                   sprintf (string, "%s/%s.dll", search->name, filename);
1488                   if (! ldfile_try_open_bfd (string, entry))
1489                     {
1490                       free (string);
1491                       return false;
1492                     }
1493                 }
1494             }
1495         }
1496     }
1497
1498   entry->filename = string;
1499
1500   return true;
1501 }
1502
1503 static int
1504 gld_${EMULATION_NAME}_find_potential_libraries (name, entry)
1505      char * name;
1506      lang_input_statement_type * entry;
1507 {
1508   return ldfile_open_file_search (name, entry, "", ".lib");
1509 }
1510 \f
1511 static char *
1512 gld_${EMULATION_NAME}_get_script(isfile)
1513      int *isfile;
1514 EOF
1515 # Scripts compiled in.
1516 # sed commands to quote an ld script as a C string.
1517 sc="-f stringify.sed"
1518
1519 cat >>e${EMULATION_NAME}.c <<EOF
1520 {
1521   *isfile = 0;
1522
1523   if (link_info.relocateable == true && config.build_constructors == true)
1524     return
1525 EOF
1526 sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
1527 echo '  ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1528 sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
1529 echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
1530 sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
1531 echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
1532 sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
1533 echo '  ; else return'                                     >> e${EMULATION_NAME}.c
1534 sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
1535 echo '; }'                                                 >> e${EMULATION_NAME}.c
1536
1537 cat >>e${EMULATION_NAME}.c <<EOF
1538
1539
1540 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1541 {
1542   gld_${EMULATION_NAME}_before_parse,
1543   syslib_default,
1544   hll_default,
1545   gld_${EMULATION_NAME}_after_parse,
1546   gld_${EMULATION_NAME}_after_open,
1547   after_allocation_default,
1548   set_output_arch_default,
1549   ldemul_default_target,
1550   gld_${EMULATION_NAME}_before_allocation,
1551   gld_${EMULATION_NAME}_get_script,
1552   "${EMULATION_NAME}",
1553   "${OUTPUT_FORMAT}",
1554   gld_${EMULATION_NAME}_finish, /* finish */
1555   NULL, /* create output section statements */
1556   gld_${EMULATION_NAME}_open_dynamic_archive,
1557   gld_${EMULATION_NAME}_place_orphan,
1558   gld_${EMULATION_NAME}_set_symbols,
1559   gld_${EMULATION_NAME}_parse_args,
1560   gld_${EMULATION_NAME}_unrecognized_file,
1561   gld_${EMULATION_NAME}_list_options,
1562   gld_${EMULATION_NAME}_recognized_file,
1563   gld_${EMULATION_NAME}_find_potential_libraries
1564 };
1565 EOF