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 "ldemul.h"
  41 #include "ldlex.h"
  42 #include "ldmisc.h"
  43 #include "ldctor.h"
  44 #include "ldfile.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 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable */
 118 #ifdef DLL_SUPPORT
 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 static unsigned long
 564 strhash (const char *str)
 565 {
 566   const unsigned char *s;
 567   unsigned long hash;
 568   unsigned int c;
 569   unsigned int len;
 570
 571   hash = 0;
 572   len = 0;
 573   s = (const unsigned char *) str;
 574   while ((c = *s++) != '\0')
 575     {
 576       hash += c + (c << 17);
 577       hash ^= hash >> 2;
 578       ++len;
 579     }
 580   hash += len + (len << 17);
 581   hash ^= hash >> 2;
 582
 583   return hash;
 584 }
 585
 586 /* Use the output file to create a image base for relocatable DLLs. */
 587 static unsigned long
 588 compute_dll_image_base (const char *ofile)
 589 {
 590   unsigned long hash = strhash (ofile);
 591   return 0x60000000 | ((hash << 16) & 0x0FFC0000);
 592 }
 593
 594 /* Assign values to the special symbols before the linker script is
 595    read.  */
 596
 597 static void
 598 gld_${EMULATION_NAME}_set_symbols ()
 599 {
 600   /* Run through and invent symbols for all the
 601      names and insert the defaults. */
 602   int j;
 603   lang_statement_list_type *save;
 604
 605   if (!init[IMAGEBASEOFF].inited)
 606     {
 607       if (link_info.relocateable)
 608         init[IMAGEBASEOFF].value = 0;
 609       else if (init[DLLOFF].value || link_info.shared)
 610         init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
 611           compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
 612       else
 613         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
 614     }
 615
 616   /* Don't do any symbol assignments if this is a relocateable link.  */
 617   if (link_info.relocateable)
 618     return;
 619
 620   /* Glue the assignments into the abs section */
 621   save = stat_ptr;
 622
 623   stat_ptr = &(abs_output_section->children);
 624
 625   for (j = 0; init[j].ptr; j++)
 626     {
 627       long val = init[j].value;
 628       lang_assignment_statement_type *rv;
 629       rv = lang_add_assignment (exp_assop ('=' ,init[j].symbol, exp_intop (val)));
 630       if (init[j].size == sizeof(short))
 631         *(short *)init[j].ptr = val;
 632       else if (init[j].size == sizeof(int))
 633         *(int *)init[j].ptr = val;
 634       else if (init[j].size == sizeof(long))
 635         *(long *)init[j].ptr = val;
 636       /* This might be a long long or other special type.  */
 637       else if (init[j].size == sizeof(bfd_vma))
 638         *(bfd_vma *)init[j].ptr = val;
 639       else      abort();
 640       if (j == IMAGEBASEOFF)
 641         image_base_statement = rv;
 642     }
 643   /* Restore the pointer. */
 644   stat_ptr = save;
 645
 646   if (pe.FileAlignment >
 647       pe.SectionAlignment)
 648     {
 649       einfo (_("%P: warning, file alignment > section alignment.\n"));
 650     }
 651 }
 652
 653 /* This is called after the linker script and the command line options
 654    have been read.  */
 655
 656 static void
 657 gld_${EMULATION_NAME}_after_parse ()
 658 {
 659   /* The Windows libraries are designed for the linker to treat the
 660      entry point as an undefined symbol.  Otherwise, the .obj that
 661      defines mainCRTStartup is brought in because it is the first
 662      encountered in libc.lib and it has other symbols in it which will
 663      be pulled in by the link process.  To avoid this, we act as
 664      though the user specified -u with the entry point symbol.
 665
 666      This function is called after the linker script and command line
 667      options have been read, so at this point we know the right entry
 668      point.  This function is called before the input files are
 669      opened, so registering the symbol as undefined will make a
 670      difference.  */
 671
 672   if (! link_info.relocateable && entry_symbol != NULL)
 673     ldlang_add_undef (entry_symbol);
 674 }
 675
 676 static struct bfd_link_hash_entry *pe_undef_found_sym;
 677
 678 static boolean
 679 pe_undef_cdecl_match (h, string)
 680   struct bfd_link_hash_entry *h;
 681   PTR string;
 682 {
 683   int sl = strlen (string);
 684   if (h->type == bfd_link_hash_defined
 685       && strncmp (h->root.string, string, sl) == 0
 686       && h->root.string[sl] == '@')
 687   {
 688     pe_undef_found_sym = h;
 689     return false;
 690   }
 691   return true;
 692 }
 693
 694 #ifdef DLL_SUPPORT
 695 static void
 696 pe_fixup_stdcalls ()
 697 {
 698   static int gave_warning_message = 0;
 699   struct bfd_link_hash_entry *undef, *sym;
 700   char *at;
 701   for (undef = link_info.hash->undefs; undef; undef=undef->next)
 702     if (undef->type == bfd_link_hash_undefined)
 703     {
 704       at = strchr (undef->root.string, '@');
 705       if (at)
 706       {
 707         /* The symbol is a stdcall symbol, so let's look for a cdecl
 708            symbol with the same name and resolve to that */
 709         char *cname = xstrdup (undef->root.string);
 710         at = strchr (cname, '@');
 711         *at = 0;
 712         sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
 713         if (sym && sym->type == bfd_link_hash_defined)
 714         {
 715           undef->type = bfd_link_hash_defined;
 716           undef->u.def.value = sym->u.def.value;
 717           undef->u.def.section = sym->u.def.section;
 718           if (pe_enable_stdcall_fixup == -1)
 719             {
 720               einfo (_("Warning: resolving %s by linking to %s\n"),
 721                      undef->root.string, cname);
 722               if (! gave_warning_message)
 723                 {
 724                   gave_warning_message = 1;
 725                   einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
 726                   einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
 727                 }
 728             }
 729         }
 730       }
 731       else
 732       {
 733         /* The symbol is a cdecl symbol, so we look for stdcall
 734            symbols - which means scanning the whole symbol table */
 735         pe_undef_found_sym = 0;
 736         bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
 737                                 (PTR) undef->root.string);
 738         sym = pe_undef_found_sym;
 739         if (sym)
 740         {
 741           undef->type = bfd_link_hash_defined;
 742           undef->u.def.value = sym->u.def.value;
 743           undef->u.def.section = sym->u.def.section;
 744           if (pe_enable_stdcall_fixup == -1)
 745             {
 746               einfo (_("Warning: resolving %s by linking to %s\n"),
 747                      undef->root.string, sym->root.string);
 748               if (! gave_warning_message)
 749                 {
 750                   gave_warning_message = 1;
 751                   einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
 752                   einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
 753                 }
 754             }
 755         }
 756       }
 757     }
 758 }
 759 #endif /* DLL_SUPPORT */
 760
 761 static void
 762 gld_${EMULATION_NAME}_after_open ()
 763 {
 764   /* Pass the wacky PE command line options into the output bfd.
 765      FIXME: This should be done via a function, rather than by
 766      including an internal BFD header.  */
 767
 768   if (!coff_data (output_bfd)->pe)
 769     einfo (_("%F%P: PE operations on non PE file.\n"));
 770
 771   pe_data (output_bfd)->pe_opthdr = pe;
 772   pe_data (output_bfd)->dll = init[DLLOFF].value;
 773
 774 #ifdef DLL_SUPPORT
 775   if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
 776     pe_fixup_stdcalls ();
 777
 778   pe_process_import_defs(output_bfd, &link_info);
 779   if (link_info.shared)
 780     pe_dll_build_sections (output_bfd, &link_info);
 781
 782 #ifndef TARGET_IS_i386pe
 783 #ifndef TARGET_IS_armpe
 784   else
 785     pe_exe_build_sections (output_bfd, &link_info);
 786 #endif
 787 #endif
 788 #endif
 789
 790 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
 791   if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
 792     {
 793       /* The arm backend needs special fields in the output hash structure.
 794          These will only be created if the output format is an arm format,
 795          hence we do not support linking and changing output formats at the
 796          same time.  Use a link followed by objcopy to change output formats.  */
 797       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
 798       return;
 799     }
 800   {
 801     /* Find a BFD that can hold the interworking stubs.  */
 802     LANG_FOR_EACH_INPUT_STATEMENT (is)
 803       {
 804         if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
 805           break;
 806       }
 807   }
 808 #endif
 809
 810   {
 811     int is_ms_arch = 0;
 812     bfd *cur_arch = 0;
 813     lang_input_statement_type *is2;
 814
 815     /* Careful - this is a shell script.  Watch those dollar signs! */
 816     /* Microsoft import libraries have every member named the same,
 817        and not in the right order for us to link them correctly.  We
 818        must detect these and rename the members so that they'll link
 819        correctly.  There are three types of objects: the head, the
 820        thunks, and the sentinel(s).  The head is easy; it's the one
 821        with idata2.  We assume that the sentinels won't have relocs,
 822        and the thunks will.  It's easier than checking the symbol
 823        table for external references.  */
 824     LANG_FOR_EACH_INPUT_STATEMENT (is)
 825       {
 826         if (is->the_bfd->my_archive)
 827           {
 828             bfd *arch = is->the_bfd->my_archive;
 829             if (cur_arch != arch)
 830               {
 831                 cur_arch = arch;
 832                 is_ms_arch = 1;
 833                 for (is2 = is;
 834                      is2 && is2->the_bfd->my_archive == arch;
 835                      is2 = (lang_input_statement_type *)is2->next)
 836                   {
 837                     if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
 838                       is_ms_arch = 0;
 839                   }
 840               }
 841
 842             if (is_ms_arch)
 843               {
 844                 int idata2 = 0, reloc_count=0;
 845                 asection *sec;
 846                 char *new_name, seq;
 847
 848                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
 849                   {
 850                     if (strcmp (sec->name, ".idata\$2") == 0)
 851                       idata2 = 1;
 852                     reloc_count += sec->reloc_count;
 853                   }
 854
 855                 if (idata2) /* .idata2 is the TOC */
 856                   seq = 'a';
 857                 else if (reloc_count > 0) /* thunks */
 858                   seq = 'b';
 859                 else /* sentinel */
 860                   seq = 'c';
 861
 862                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
 863                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
 864                 is->the_bfd->filename = new_name;
 865
 866                 new_name = xmalloc (strlen (is->filename) + 3);
 867                 sprintf (new_name, "%s.%c", is->filename, seq);
 868                 is->filename = new_name;
 869               }
 870           }
 871       }
 872   }
 873 }
 874 \f
 875 static void
 876 gld_${EMULATION_NAME}_before_allocation()
 877 {
 878 #ifdef TARGET_IS_ppcpe
 879   /* Here we rummage through the found bfds to collect toc information */
 880   {
 881     LANG_FOR_EACH_INPUT_STATEMENT (is)
 882       {
 883         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
 884           {
 885             /* xgettext:c-format */
 886             einfo (_("Errors encountered processing file %s\n"), is->filename);
 887           }
 888       }
 889   }
 890
 891   /* We have seen it all. Allocate it, and carry on */
 892   ppc_allocate_toc_section (&link_info);
 893 #endif /* TARGET_IS_ppcpe */
 894
 895 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
 896   /* FIXME: we should be able to set the size of the interworking stub
 897      section.
 898
 899      Here we rummage through the found bfds to collect glue
 900      information.  FIXME: should this be based on a command line
 901      option?  krk@cygnus.com */
 902   {
 903     LANG_FOR_EACH_INPUT_STATEMENT (is)
 904       {
 905         if (! bfd_arm_pe_process_before_allocation
 906             (is->the_bfd, & link_info, support_old_code))
 907           {
 908             /* xgettext:c-format */
 909             einfo (_("Errors encountered processing file %s for interworking"),
 910                    is->filename);
 911           }
 912       }
 913   }
 914
 915   /* We have seen it all. Allocate it, and carry on */
 916   bfd_arm_pe_allocate_interworking_sections (& link_info);
 917 #endif /* TARGET_IS_armpe */
 918 }
 919 \f
 920 #ifdef DLL_SUPPORT
 921 /* This is called when an input file isn't recognized as a BFD.  We
 922    check here for .DEF files and pull them in automatically. */
 923
 924 static int
 925 saw_option(char *option)
 926 {
 927   int i;
 928   for (i=0; init[i].ptr; i++)
 929     if (strcmp (init[i].symbol, option) == 0)
 930       return init[i].inited;
 931   return 0;
 932 }
 933 #endif /* DLL_SUPPORT */
 934
 935 static boolean
 936 gld_${EMULATION_NAME}_unrecognized_file(entry)
 937      lang_input_statement_type *entry ATTRIBUTE_UNUSED;
 938 {
 939 #ifdef DLL_SUPPORT
 940   const char *ext = entry->filename + strlen (entry->filename) - 4;
 941
 942   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
 943   {
 944     if (pe_def_file == 0)
 945       pe_def_file = def_file_empty ();
 946     def_file_parse (entry->filename, pe_def_file);
 947     if (pe_def_file)
 948     {
 949       int i, buflen=0, len;
 950       char *buf;
 951       for (i=0; i<pe_def_file->num_exports; i++)
 952         {
 953           len = strlen(pe_def_file->exports[i].internal_name);
 954           if (buflen < len+2)
 955             buflen = len+2;
 956         }
 957       buf = (char *) xmalloc (buflen);
 958       for (i=0; i<pe_def_file->num_exports; i++)
 959         {
 960           struct bfd_link_hash_entry *h;
 961           sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
 962
 963           h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true);
 964           if (h == (struct bfd_link_hash_entry *) NULL)
 965             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
 966           if (h->type == bfd_link_hash_new)
 967             {
 968               h->type = bfd_link_hash_undefined;
 969               h->u.undef.abfd = NULL;
 970               bfd_link_add_undef (link_info.hash, h);
 971             }
 972         }
 973       free (buf);
 974
 975       /* def_file_print (stdout, pe_def_file); */
 976       if (pe_def_file->is_dll == 1)
 977         link_info.shared = 1;
 978
 979       if (pe_def_file->base_address != (bfd_vma)(-1))
 980       {
 981         pe.ImageBase =
 982         pe_data (output_bfd)->pe_opthdr.ImageBase =
 983         init[IMAGEBASEOFF].value = pe_def_file->base_address;
 984         init[IMAGEBASEOFF].inited = 1;
 985         if (image_base_statement)
 986           image_base_statement->exp =
 987             exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
 988       }
 989
 990 #if 0
 991       /* Not sure if these *should* be set */
 992       if (pe_def_file->version_major != -1)
 993       {
 994         pe.MajorImageVersion = pe_def_file->version_major;
 995         pe.MinorImageVersion = pe_def_file->version_minor;
 996       }
 997 #endif
 998       if (pe_def_file->stack_reserve != -1
 999           && ! saw_option ("__size_of_stack_reserve__"))
1000       {
1001         pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1002         if (pe_def_file->stack_commit != -1)
1003           pe.SizeOfStackCommit = pe_def_file->stack_commit;
1004       }
1005       if (pe_def_file->heap_reserve != -1
1006           && ! saw_option ("__size_of_heap_reserve__"))
1007       {
1008         pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1009         if (pe_def_file->heap_commit != -1)
1010           pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1011       }
1012       return true;
1013     }
1014   }
1015 #endif
1016   return false;
1017
1018 }
1019
1020 static boolean
1021 gld_${EMULATION_NAME}_recognized_file(entry)
1022   lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1023 {
1024 #ifdef DLL_SUPPORT
1025 #ifdef TARGET_IS_i386pe
1026   pe_dll_id_target ("pei-i386");
1027 #endif
1028 #ifdef TARGET_IS_shpe
1029   pe_dll_id_target ("pei-shl");
1030 #endif
1031 #ifdef TARGET_IS_mipspe
1032   pe_dll_id_target ("pei-mips");
1033 #endif
1034 #ifdef TARGET_IS_armpe
1035   pe_dll_id_target ("pei-arm-little");
1036 #endif
1037   if (bfd_get_format (entry->the_bfd) == bfd_object)
1038     {
1039       const char *ext = entry->filename + strlen (entry->filename) - 4;
1040       if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1041         return pe_implied_import_dll (entry->filename);
1042     }
1043 #endif
1044   return false;
1045 }
1046
1047 static void
1048 gld_${EMULATION_NAME}_finish ()
1049 {
1050 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1051   struct bfd_link_hash_entry * h;
1052
1053   if (thumb_entry_symbol != NULL)
1054     {
1055       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol, false, false, true);
1056
1057       if (h != (struct bfd_link_hash_entry *) NULL
1058           && (h->type == bfd_link_hash_defined
1059               || h->type == bfd_link_hash_defweak)
1060           && h->u.def.section->output_section != NULL)
1061         {
1062           static char buffer[32];
1063           bfd_vma val;
1064
1065           /* Special procesing is required for a Thumb entry symbol.  The
1066              bottom bit of its address must be set.  */
1067           val = (h->u.def.value
1068                  + bfd_get_section_vma (output_bfd,
1069                                         h->u.def.section->output_section)
1070                  + h->u.def.section->output_offset);
1071
1072           val |= 1;
1073
1074           /* Now convert this value into a string and store it in entry_symbol
1075              where the lang_finish() function will pick it up.  */
1076           buffer[0] = '0';
1077           buffer[1] = 'x';
1078
1079           sprintf_vma (buffer + 2, val);
1080
1081           if (entry_symbol != NULL && entry_from_cmdline)
1082             einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1083                    thumb_entry_symbol, entry_symbol);
1084           entry_symbol = buffer;
1085         }
1086       else
1087         einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1088     }
1089 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1090
1091 #ifdef DLL_SUPPORT
1092   if (link_info.shared)
1093     {
1094       pe_dll_fill_sections (output_bfd, &link_info);
1095       if (pe_implib_filename)
1096         pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1097     }
1098 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1099   /* ARM doesn't need relocs.  */
1100   else
1101     {
1102       pe_exe_fill_sections (output_bfd, &link_info);
1103     }
1104 #endif
1105
1106   if (pe_out_def_filename)
1107     pe_dll_generate_def_file (pe_out_def_filename);
1108 #endif /* DLL_SUPPORT */
1109 }
1110
1111 \f
1112 /* Place an orphan section.
1113
1114    We use this to put sections in a reasonable place in the file, and
1115    to ensure that they are aligned as required.
1116
1117    We handle grouped sections here as well.  A section named .foo$nn
1118    goes into the output section .foo.  All grouped sections are sorted
1119    by name.
1120
1121    Grouped sections for the default sections are handled by the
1122    default linker script using wildcards, and are sorted by
1123    sort_sections.  */
1124
1125 struct orphan_save
1126 {
1127   lang_output_section_statement_type *os;
1128   asection **section;
1129   lang_statement_union_type **stmt;
1130 };
1131
1132 /*ARGSUSED*/
1133 static boolean
1134 gld_${EMULATION_NAME}_place_orphan (file, s)
1135      lang_input_statement_type *file;
1136      asection *s;
1137 {
1138   const char *secname;
1139   char *hold_section_name;
1140   char *dollar = NULL;
1141   lang_output_section_statement_type *os;
1142   lang_statement_list_type add_child;
1143
1144   secname = bfd_get_section_name (s->owner, s);
1145
1146   /* Look through the script to see where to place this section.  */
1147
1148   hold_section_name = xstrdup (secname);
1149   if (!link_info.relocateable)
1150     {
1151       dollar = strchr (hold_section_name, '$');
1152       if (dollar != NULL)
1153         *dollar = '\0';
1154     }
1155
1156   os = lang_output_section_find (hold_section_name);
1157
1158   lang_list_init (&add_child);
1159
1160   if (os != NULL
1161       && os->bfd_section != NULL
1162       && ((s->flags ^ os->bfd_section->flags) & (SEC_LOAD | SEC_ALLOC)) == 0)
1163     {
1164       wild_doit (&add_child, s, os, file);
1165     }
1166   else
1167     {
1168       struct orphan_save *place;
1169       static struct orphan_save hold_text;
1170       static struct orphan_save hold_rdata;
1171       static struct orphan_save hold_data;
1172       static struct orphan_save hold_bss;
1173       char *outsecname;
1174       lang_statement_list_type *old;
1175       lang_statement_list_type add;
1176       etree_type *address;
1177
1178       /* Try to put the new output section in a reasonable place based
1179          on the section name and section flags.  */
1180 #define HAVE_SECTION(hold, name) \
1181 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1182
1183       place = NULL;
1184       if ((s->flags & SEC_ALLOC) == 0)
1185         ;
1186       else if ((s->flags & SEC_HAS_CONTENTS) == 0
1187                && HAVE_SECTION (hold_bss, ".bss"))
1188         place = &hold_bss;
1189       else if ((s->flags & SEC_READONLY) == 0
1190                && HAVE_SECTION (hold_data, ".data"))
1191         place = &hold_data;
1192       else if ((s->flags & SEC_CODE) == 0
1193                && (s->flags & SEC_READONLY) != 0
1194                && HAVE_SECTION (hold_rdata, ".rdata"))
1195         place = &hold_rdata;
1196       else if ((s->flags & SEC_READONLY) != 0
1197                && HAVE_SECTION (hold_text, ".text"))
1198         place = &hold_text;
1199
1200 #undef HAVE_SECTION
1201
1202       /* Choose a unique name for the section.  This will be needed if
1203          the same section name appears in the input file with
1204          different loadable or allocateable characteristics.  */
1205       outsecname = xstrdup (hold_section_name);
1206       if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1207         {
1208           unsigned int len;
1209           char *newname;
1210           unsigned int i;
1211
1212           len = strlen (outsecname);
1213           newname = xmalloc (len + 5);
1214           strcpy (newname, outsecname);
1215           i = 0;
1216           do
1217             {
1218               sprintf (newname + len, "%d", i);
1219               ++i;
1220             }
1221           while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1222
1223           free (outsecname);
1224           outsecname = newname;
1225         }
1226
1227       /* Start building a list of statements for this section.  */
1228       old = stat_ptr;
1229       stat_ptr = &add;
1230       lang_list_init (stat_ptr);
1231
1232       if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1233         address = exp_intop ((bfd_vma) 0);
1234       else
1235         {
1236           /* All sections in an executable must be aligned to a page
1237              boundary.  */
1238           address = exp_unop (ALIGN_K,
1239                               exp_nameop (NAME, "__section_alignment__"));
1240         }
1241
1242       os = lang_enter_output_section_statement (outsecname, address, 0,
1243                                                 (bfd_vma) 0,
1244                                                 (etree_type *) NULL,
1245                                                 (etree_type *) NULL,
1246                                                 (etree_type *) NULL);
1247
1248       wild_doit (&add_child, s, os, file);
1249
1250       lang_leave_output_section_statement
1251         ((bfd_vma) 0, "*default*",
1252          (struct lang_output_section_phdr_list *) NULL, "*default*");
1253
1254       stat_ptr = old;
1255
1256       if (place != NULL)
1257         {
1258           asection *snew, **pps;
1259
1260           snew = os->bfd_section;
1261           if (place->os->bfd_section != NULL || place->section != NULL)
1262             {
1263               /* Shuffle the section to make the output file look neater.  */
1264               if (place->section == NULL)
1265                 {
1266 #if 0
1267                   /* Finding the end of the list is a little tricky.  We
1268                      make a wild stab at it by comparing section flags.  */
1269                   flagword first_flags = place->os->bfd_section->flags;
1270                   for (pps = &place->os->bfd_section->next;
1271                        *pps != NULL && (*pps)->flags == first_flags;
1272                        pps = &(*pps)->next)
1273                     ;
1274                   place->section = pps;
1275 #else
1276                   /* Put orphans after the first section on the list.  */
1277                   place->section = &place->os->bfd_section->next;
1278 #endif
1279                 }
1280
1281               /*  Unlink the section.  */
1282               for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1283                 ;
1284               *pps = snew->next;
1285
1286               /* Now tack it on to the "place->os" section list.  */
1287               snew->next = *place->section;
1288               *place->section = snew;
1289             }
1290           place->section = &snew->next; /* Save the end of this list.  */
1291
1292           if (place->stmt == NULL)
1293             {
1294               /* Put the new statement list right at the head.  */
1295               *add.tail = place->os->header.next;
1296               place->os->header.next = add.head;
1297             }
1298           else
1299             {
1300               /* Put it after the last orphan statement we added.  */
1301               *add.tail = *place->stmt;
1302               *place->stmt = add.head;
1303             }
1304           place->stmt = add.tail;       /* Save the end of this list.  */
1305         }
1306     }
1307
1308   {
1309     lang_statement_union_type **pl = &os->children.head;
1310
1311     if (dollar != NULL)
1312       {
1313         boolean found_dollar;
1314
1315         /* The section name has a '$'.  Sort it with the other '$'
1316            sections.  */
1317
1318         found_dollar = false;
1319         for ( ; *pl != NULL; pl = &(*pl)->next)
1320           {
1321             lang_input_section_type *ls;
1322             const char *lname;
1323
1324             if ((*pl)->header.type != lang_input_section_enum)
1325               continue;
1326
1327             ls = &(*pl)->input_section;
1328
1329             lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1330             if (strchr (lname, '$') == NULL)
1331               {
1332                 if (found_dollar)
1333                   break;
1334               }
1335             else
1336               {
1337                 found_dollar = true;
1338                 if (strcmp (secname, lname) < 0)
1339                   break;
1340               }
1341           }
1342       }
1343
1344     if (add_child.head != NULL)
1345       {
1346         add_child.head->next = *pl;
1347         *pl = add_child.head;
1348       }
1349   }
1350
1351   free (hold_section_name);
1352
1353   return true;
1354 }
1355
1356 static boolean
1357 gld_${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
1358      const char * arch;
1359      search_dirs_type * search;
1360      lang_input_statement_type * entry;
1361 {
1362   const char * filename;
1363   char * string;
1364
1365   if (! entry->is_archive)
1366     return false;
1367
1368   filename = entry->filename;
1369
1370   string = (char *) xmalloc (strlen (search->name)
1371                              + strlen (filename)
1372                              + sizeof "/lib.a.dll"
1373                              + 1);
1374
1375   /* Try "libfoo.dll.a" first (preferred explicit import library for dll's */
1376   sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1377
1378   if (! ldfile_try_open_bfd (string, entry))
1379     {
1380       /* Try "foo.dll.a" next (alternate explicit import library for dll's */
1381       sprintf (string, "%s/%s.dll.a", search->name, filename);
1382       if (! ldfile_try_open_bfd (string, entry))
1383         {
1384           /* Try "libfoo.dll" (preferred dll name) */
1385           sprintf (string, "%s/lib%s.dll", search->name, filename);
1386           if (! ldfile_try_open_bfd (string, entry))
1387             {
1388               /* Finally, try "foo.dll" (alternate dll name) */
1389               sprintf (string, "%s/%s.dll", search->name, filename);
1390               if (! ldfile_try_open_bfd (string, entry))
1391                 {
1392                   free (string);
1393                   return false;
1394                 }
1395             }
1396         }
1397     }
1398
1399   entry->filename = string;
1400
1401   return true;
1402 }
1403
1404 static int
1405 gld_${EMULATION_NAME}_find_potential_libraries (name, entry)
1406      char * name;
1407      lang_input_statement_type * entry;
1408 {
1409   return ldfile_open_file_search (name, entry, "", ".lib");
1410 }
1411 \f
1412 static char *
1413 gld_${EMULATION_NAME}_get_script(isfile)
1414      int *isfile;
1415 EOF
1416 # Scripts compiled in.
1417 # sed commands to quote an ld script as a C string.
1418 sc="-f stringify.sed"
1419
1420 cat >>e${EMULATION_NAME}.c <<EOF
1421 {
1422   *isfile = 0;
1423
1424   if (link_info.relocateable == true && config.build_constructors == true)
1425     return
1426 EOF
1427 sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
1428 echo '  ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1429 sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
1430 echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
1431 sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
1432 echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
1433 sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
1434 echo '  ; else return'                                     >> e${EMULATION_NAME}.c
1435 sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
1436 echo '; }'                                                 >> e${EMULATION_NAME}.c
1437
1438 cat >>e${EMULATION_NAME}.c <<EOF
1439
1440
1441 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1442 {
1443   gld_${EMULATION_NAME}_before_parse,
1444   syslib_default,
1445   hll_default,
1446   gld_${EMULATION_NAME}_after_parse,
1447   gld_${EMULATION_NAME}_after_open,
1448   after_allocation_default,
1449   set_output_arch_default,
1450   ldemul_default_target,
1451   gld_${EMULATION_NAME}_before_allocation,
1452   gld_${EMULATION_NAME}_get_script,
1453   "${EMULATION_NAME}",
1454   "${OUTPUT_FORMAT}",
1455   gld_${EMULATION_NAME}_finish, /* finish */
1456   NULL, /* create output section statements */
1457   gld_${EMULATION_NAME}_open_dynamic_archive,
1458   gld_${EMULATION_NAME}_place_orphan,
1459   gld_${EMULATION_NAME}_set_symbols,
1460   gld_${EMULATION_NAME}_parse_args,
1461   gld_${EMULATION_NAME}_unrecognized_file,
1462   gld_${EMULATION_NAME}_list_options,
1463   gld_${EMULATION_NAME}_recognized_file,
1464   gld_${EMULATION_NAME}_find_potential_libraries
1465 };
1466 EOF