ld/emultempl/pe.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 cat >e${EMULATION_NAME}.c <<EOF
   4 /* This file is part of GLD, the Gnu Linker.
   5    Copyright 1995, 96, 97, 1998 Free Software Foundation, Inc.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* For WINDOWS_NT */
  22 /* The original file generated returned different default scripts depending
  23    on whether certain switches were set, but these switches pertain to the
  24    Linux system and that particular version of coff.  In the NT case, we
  25    only determine if the subsystem is console or windows in order to select
  26    the correct entry point by default. */
  27
  28 #include "bfd.h"
  29 #include "sysdep.h"
  30 #include "bfdlink.h"
  31 #include "getopt.h"
  32 #include "libiberty.h"
  33 #include "ld.h"
  34 #include "ldmain.h"
  35 #include "ldgram.h"
  36 #include "ldexp.h"
  37 #include "ldlang.h"
  38 #include "ldemul.h"
  39 #include "ldlex.h"
  40 #include "ldmisc.h"
  41 #include "ldctor.h"
  42 #include "ldfile.h"
  43 #include "coff/internal.h"
  44 #include "../bfd/libcoff.h"
  45 #include "deffile.h"
  46
  47 #define TARGET_IS_${EMULATION_NAME}
  48
  49 static void gld_${EMULATION_NAME}_set_symbols PARAMS ((void));
  50 static void gld_${EMULATION_NAME}_after_open PARAMS ((void));
  51 static void gld_${EMULATION_NAME}_before_parse PARAMS ((void));
  52 static void gld_${EMULATION_NAME}_after_parse PARAMS ((void));
  53 static void gld_${EMULATION_NAME}_before_allocation PARAMS ((void));
  54 static boolean gld_${EMULATION_NAME}_place_orphan
  55   PARAMS ((lang_input_statement_type *, asection *));
  56 static void gld${EMULATION_NAME}_place_section
  57   PARAMS ((lang_statement_union_type *));
  58 static char *gld_${EMULATION_NAME}_get_script PARAMS ((int *));
  59 static int gld_${EMULATION_NAME}_parse_args PARAMS ((int, char **));
  60
  61 static struct internal_extra_pe_aouthdr pe;
  62 static int dll;
  63 static int support_old_code = 0;
  64 def_file *pe_def_file = 0;
  65 static lang_assignment_statement_type *image_base_statement = 0;
  66
  67 static char *pe_out_def_filename = 0;
  68 int pe_dll_export_everything = 0;
  69 int pe_dll_do_default_excludes = 1;
  70 int pe_dll_kill_ats = 0;
  71 int pe_dll_stdcall_aliases = 0;
  72 int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable */
  73 static char *pe_implib_filename = 0;
  74
  75 extern const char *output_filename;
  76
  77 static void
  78 gld_${EMULATION_NAME}_before_parse()
  79 {
  80   output_filename = "a.exe";
  81   ldfile_output_architecture = bfd_arch_${ARCH};
  82 #ifdef TARGET_IS_i386pe
  83   config.has_shared = 1;
  84 #endif
  85 }
  86 \f
  87 /* PE format extra command line options.  */
  88
  89 /* Used for setting flags in the PE header. */
  90 #define OPTION_BASE_FILE                (300  + 1)
  91 #define OPTION_DLL                      (OPTION_BASE_FILE + 1)
  92 #define OPTION_FILE_ALIGNMENT           (OPTION_DLL + 1)
  93 #define OPTION_IMAGE_BASE               (OPTION_FILE_ALIGNMENT + 1)
  94 #define OPTION_MAJOR_IMAGE_VERSION      (OPTION_IMAGE_BASE + 1)
  95 #define OPTION_MAJOR_OS_VERSION         (OPTION_MAJOR_IMAGE_VERSION + 1)
  96 #define OPTION_MAJOR_SUBSYSTEM_VERSION  (OPTION_MAJOR_OS_VERSION + 1)
  97 #define OPTION_MINOR_IMAGE_VERSION      (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
  98 #define OPTION_MINOR_OS_VERSION         (OPTION_MINOR_IMAGE_VERSION + 1)
  99 #define OPTION_MINOR_SUBSYSTEM_VERSION  (OPTION_MINOR_OS_VERSION + 1)
 100 #define OPTION_SECTION_ALIGNMENT        (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
 101 #define OPTION_STACK                    (OPTION_SECTION_ALIGNMENT + 1)
 102 #define OPTION_SUBSYSTEM                (OPTION_STACK + 1)
 103 #define OPTION_HEAP                     (OPTION_SUBSYSTEM + 1)
 104 #define OPTION_SUPPORT_OLD_CODE         (OPTION_HEAP + 1)
 105 #define OPTION_OUT_DEF                  (OPTION_SUPPORT_OLD_CODE + 1)
 106 #define OPTION_EXPORT_ALL               (OPTION_OUT_DEF + 1)
 107 #define OPTION_EXCLUDE_SYMBOLS          (OPTION_EXPORT_ALL + 1)
 108 #define OPTION_KILL_ATS                 (OPTION_EXCLUDE_SYMBOLS + 1)
 109 #define OPTION_STDCALL_ALIASES          (OPTION_KILL_ATS + 1)
 110 #define OPTION_ENABLE_STDCALL_FIXUP     (OPTION_STDCALL_ALIASES + 1)
 111 #define OPTION_DISABLE_STDCALL_FIXUP    (OPTION_ENABLE_STDCALL_FIXUP + 1)
 112 #define OPTION_IMPLIB_FILENAME          (OPTION_DISABLE_STDCALL_FIXUP + 1)
 113
 114 static struct option longopts[] =
 115 {
 116   /* PE options */
 117   {"base-file", required_argument, NULL, OPTION_BASE_FILE},
 118   {"dll", no_argument, NULL, OPTION_DLL},
 119   {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
 120   {"heap", required_argument, NULL, OPTION_HEAP},
 121   {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
 122   {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
 123   {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
 124   {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
 125   {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
 126   {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
 127   {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
 128   {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
 129   {"stack", required_argument, NULL, OPTION_STACK},
 130   {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
 131   {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
 132 #ifdef TARGET_IS_i386pe
 133   /* getopt allows abbreviations, so we do this to stop it from treating -o
 134      as an abbreviation for this option */
 135   {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 136   {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 137   {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
 138   {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
 139   {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
 140   {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
 141   {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
 142   {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
 143   {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
 144 #endif
 145   {NULL, no_argument, NULL, 0}
 146 };
 147
 148
 149 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
 150    parameters which may be input from the command line */
 151
 152 typedef struct
 153 {
 154   void *ptr;
 155   int size;
 156   int value;
 157   char *symbol;
 158   int inited;
 159 } definfo;
 160
 161 #define D(field,symbol,def)  {&pe.field,sizeof(pe.field), def, symbol,0}
 162
 163 static definfo init[] =
 164 {
 165   /* imagebase must be first */
 166 #define IMAGEBASEOFF 0
 167   D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
 168 #define DLLOFF 1
 169   {&dll, sizeof(dll), 0, "__dll__"},
 170   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
 171   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
 172   D(MajorOperatingSystemVersion,"__major_os_version__", 4),
 173   D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
 174   D(MajorImageVersion,"__major_image_version__", 1),
 175   D(MinorImageVersion,"__minor_image_version__", 0),
 176   D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
 177   D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
 178   D(Subsystem,"__subsystem__", 3),
 179   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x2000000),
 180   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
 181   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
 182   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
 183   D(LoaderFlags,"__loader_flags__", 0x0),
 184   { NULL, 0, 0, NULL, 0 }
 185 };
 186
 187 static void
 188 gld_${EMULATION_NAME}_list_options (file)
 189      FILE * file;
 190 {
 191   fprintf (file, _("  --base_file <basefile>             Generate a base file for relocatable DLLs\n"));
 192   fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));
 193   fprintf (file, _("  --file-alignment <size>            Set file alignment\n"));
 194   fprintf (file, _("  --heap <size>                      Set initial size of the heap\n"));
 195   fprintf (file, _("  --image-base <address>             Set start address of the executable\n"));
 196   fprintf (file, _("  --major-image-version <number>     Set version number of the executable\n"));
 197   fprintf (file, _("  --major-os-version <number>        Set minimum required OS version\n"));
 198   fprintf (file, _("  --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
 199   fprintf (file, _("  --minor-image-version <number>     Set revision number of the executable\n"));
 200   fprintf (file, _("  --minor-os-version <number>        Set minimum required OS revision\n"));
 201   fprintf (file, _("  --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
 202   fprintf (file, _("  --section-alignment <size>         Set section alignment\n"));
 203   fprintf (file, _("  --stack <size>                     Set size of the initial stack\n"));
 204   fprintf (file, _("  --subsystem <name>[:<version>]     Set required OS subsystem [& version]\n"));
 205   fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));
 206 #ifdef TARGET_IS_i386pe
 207   fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));
 208   fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));
 209   fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));
 210   fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));
 211   fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));
 212   fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));
 213   fprintf (file, _("  --out-implib <file>                Generate import library\n"));
 214   fprintf (file, _("  --output-def <file>                Generate a .DEF file for the built DLL\n"));
 215 #endif
 216 }
 217
 218 static void
 219 set_pe_name (name, val)
 220      char *name;
 221      long val;
 222 {
 223   int i;
 224   /* Find the name and set it. */
 225   for (i = 0; init[i].ptr; i++)
 226     {
 227       if (strcmp (name, init[i].symbol) == 0)
 228         {
 229           init[i].value = val;
 230           init[i].inited = 1;
 231           return;
 232         }
 233     }
 234   abort();
 235 }
 236
 237
 238 static void
 239 set_pe_subsystem ()
 240 {
 241   const char *sver;
 242   int len;
 243   int i;
 244   static const struct
 245     {
 246       const char *name;
 247       const int value;
 248       const char *entry;
 249     }
 250   v[] =
 251     {
 252       { "native", 1, "_NtProcessStartup" },
 253       { "windows", 2, "_WinMainCRTStartup" },
 254       { "console", 3, "_mainCRTStartup" },
 255 #if 0
 256       /* The Microsoft linker does not recognize this.  */
 257       { "os2", 5, "" },
 258 #endif
 259       { "posix", 7, "___PosixProcessStartup"},
 260       { 0, 0, 0 }
 261     };
 262
 263   sver = strchr (optarg, ':');
 264   if (sver == NULL)
 265     len = strlen (optarg);
 266   else
 267     {
 268       char *end;
 269
 270       len = sver - optarg;
 271       set_pe_name ("__major_subsystem_version__",
 272                    strtoul (sver + 1, &end, 0));
 273       if (*end == '.')
 274         set_pe_name ("__minor_subsystem_version__",
 275                      strtoul (end + 1, &end, 0));
 276       if (*end != '\0')
 277         einfo (_("%P: warning: bad version number in -subsystem option\n"));
 278     }
 279
 280   for (i = 0; v[i].name; i++)
 281     {
 282       if (strncmp (optarg, v[i].name, len) == 0
 283           && v[i].name[len] == '\0')
 284         {
 285           set_pe_name ("__subsystem__", v[i].value);
 286
 287           lang_add_entry (v[i].entry, 1);
 288
 289           return;
 290         }
 291     }
 292
 293   einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
 294 }
 295
 296
 297
 298 static void
 299 set_pe_value (name)
 300      char *name;
 301
 302 {
 303   char *end;
 304
 305   set_pe_name (name,  strtoul (optarg, &end, 0));
 306
 307   if (end == optarg)
 308     einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
 309
 310   optarg = end;
 311 }
 312
 313 static void
 314 set_pe_stack_heap (resname, comname)
 315      char *resname;
 316      char *comname;
 317 {
 318   set_pe_value (resname);
 319
 320   if (*optarg == ',')
 321     {
 322       optarg++;
 323       set_pe_value (comname);
 324     }
 325   else if (*optarg)
 326     einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
 327 }
 328
 329
 330
 331 static int
 332 gld_${EMULATION_NAME}_parse_args(argc, argv)
 333      int argc;
 334      char **argv;
 335 {
 336   int longind;
 337   int optc;
 338   int prevoptind = optind;
 339   int prevopterr = opterr;
 340   int wanterror;
 341   static int lastoptind = -1;
 342
 343   if (lastoptind != optind)
 344     opterr = 0;
 345   wanterror = opterr;
 346
 347   lastoptind = optind;
 348
 349   optc = getopt_long_only (argc, argv, "-", longopts, &longind);
 350   opterr = prevopterr;
 351
 352   switch (optc)
 353     {
 354     default:
 355       if (wanterror)
 356         xexit (1);
 357       optind =  prevoptind;
 358       return 0;
 359
 360     case OPTION_BASE_FILE:
 361       link_info.base_file = (PTR) fopen (optarg, FOPEN_WB);
 362       if (link_info.base_file == NULL)
 363         {
 364           /* xgettext:c-format */
 365           fprintf (stderr, _("%s: Can't open base file %s\n"),
 366                    program_name, optarg);
 367           xexit (1);
 368         }
 369       break;
 370
 371       /* PE options */
 372     case OPTION_HEAP:
 373       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 374       break;
 375     case OPTION_STACK:
 376       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 377       break;
 378     case OPTION_SUBSYSTEM:
 379       set_pe_subsystem ();
 380       break;
 381     case OPTION_MAJOR_OS_VERSION:
 382       set_pe_value ("__major_os_version__");
 383       break;
 384     case OPTION_MINOR_OS_VERSION:
 385       set_pe_value ("__minor_os_version__");
 386       break;
 387     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 388       set_pe_value ("__major_subsystem_version__");
 389       break;
 390     case OPTION_MINOR_SUBSYSTEM_VERSION:
 391       set_pe_value ("__minor_subsystem_version__");
 392       break;
 393     case OPTION_MAJOR_IMAGE_VERSION:
 394       set_pe_value ("__major_image_version__");
 395       break;
 396     case OPTION_MINOR_IMAGE_VERSION:
 397       set_pe_value ("__minor_image_version__");
 398       break;
 399     case OPTION_FILE_ALIGNMENT:
 400       set_pe_value ("__file_alignment__");
 401       break;
 402     case OPTION_SECTION_ALIGNMENT:
 403       set_pe_value ("__section_alignment__");
 404       break;
 405     case OPTION_DLL:
 406       set_pe_name ("__dll__", 1);
 407       break;
 408     case OPTION_IMAGE_BASE:
 409       set_pe_value ("__image_base__");
 410       break;
 411     case OPTION_SUPPORT_OLD_CODE:
 412       support_old_code = 1;
 413       break;
 414     case OPTION_OUT_DEF:
 415       pe_out_def_filename = xstrdup (optarg);
 416       break;
 417     case OPTION_EXPORT_ALL:
 418       pe_dll_export_everything = 1;
 419       break;
 420     case OPTION_EXCLUDE_SYMBOLS:
 421       pe_dll_add_excludes (optarg);
 422       break;
 423     case OPTION_KILL_ATS:
 424       pe_dll_kill_ats = 1;
 425       break;
 426     case OPTION_STDCALL_ALIASES:
 427       pe_dll_stdcall_aliases = 1;
 428       break;
 429     case OPTION_ENABLE_STDCALL_FIXUP:
 430       pe_enable_stdcall_fixup = 1;
 431       break;
 432     case OPTION_DISABLE_STDCALL_FIXUP:
 433       pe_enable_stdcall_fixup = 0;
 434       break;
 435     case OPTION_IMPLIB_FILENAME:
 436       pe_implib_filename = xstrdup (optarg);
 437       break;
 438     }
 439   return 1;
 440 }
 441 \f
 442 /* Assign values to the special symbols before the linker script is
 443    read.  */
 444
 445 static void
 446 gld_${EMULATION_NAME}_set_symbols ()
 447 {
 448   /* Run through and invent symbols for all the
 449      names and insert the defaults. */
 450   int j;
 451   lang_statement_list_type *save;
 452
 453   if (!init[IMAGEBASEOFF].inited)
 454     {
 455       if (link_info.relocateable)
 456         init[IMAGEBASEOFF].value = 0;
 457       else if (init[DLLOFF].value || link_info.shared)
 458         init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
 459       else
 460         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
 461     }
 462
 463   /* Don't do any symbol assignments if this is a relocateable link.  */
 464   if (link_info.relocateable)
 465     return;
 466
 467   /* Glue the assignments into the abs section */
 468   save = stat_ptr;
 469
 470   stat_ptr = &(abs_output_section->children);
 471
 472   for (j = 0; init[j].ptr; j++)
 473     {
 474       long val = init[j].value;
 475       lang_assignment_statement_type *rv;
 476       rv = lang_add_assignment (exp_assop ('=' ,init[j].symbol, exp_intop (val)));
 477       if (init[j].size == sizeof(short))
 478         *(short *)init[j].ptr = val;
 479       else if (init[j].size == sizeof(int))
 480         *(int *)init[j].ptr = val;
 481       else if (init[j].size == sizeof(long))
 482         *(long *)init[j].ptr = val;
 483       /* This might be a long long or other special type.  */
 484       else if (init[j].size == sizeof(bfd_vma))
 485         *(bfd_vma *)init[j].ptr = val;
 486       else      abort();
 487       if (j == IMAGEBASEOFF)
 488         image_base_statement = rv;
 489     }
 490   /* Restore the pointer. */
 491   stat_ptr = save;
 492
 493   if (pe.FileAlignment >
 494       pe.SectionAlignment)
 495     {
 496       einfo (_("%P: warning, file alignment > section alignment.\n"));
 497     }
 498 }
 499
 500 /* This is called after the linker script and the command line options
 501    have been read.  */
 502
 503 static void
 504 gld_${EMULATION_NAME}_after_parse ()
 505 {
 506   /* The Windows libraries are designed for the linker to treat the
 507      entry point as an undefined symbol.  Otherwise, the .obj that
 508      defines mainCRTStartup is brought in because it is the first
 509      encountered in libc.lib and it has other symbols in it which will
 510      be pulled in by the link process.  To avoid this, we act as
 511      though the user specified -u with the entry point symbol.
 512
 513      This function is called after the linker script and command line
 514      options have been read, so at this point we know the right entry
 515      point.  This function is called before the input files are
 516      opened, so registering the symbol as undefined will make a
 517      difference.  */
 518
 519   if (entry_symbol)
 520     ldlang_add_undef (entry_symbol);
 521 }
 522
 523 static struct bfd_link_hash_entry *pe_undef_found_sym;
 524
 525 static boolean
 526 pe_undef_cdecl_match (h, string)
 527   struct bfd_link_hash_entry *h;
 528   PTR string;
 529 {
 530   int sl = strlen (string);
 531   if (h->type == bfd_link_hash_defined
 532       && strncmp (h->root.string, string, sl) == 0
 533       && h->root.string[sl] == '@')
 534   {
 535     pe_undef_found_sym = h;
 536     return false;
 537   }
 538   return true;
 539 }
 540
 541 static void
 542 pe_fixup_stdcalls ()
 543 {
 544   static int gave_warning_message = 0;
 545   struct bfd_link_hash_entry *undef, *sym;
 546   char *at;
 547   for (undef = link_info.hash->undefs; undef; undef=undef->next)
 548     if (undef->type == bfd_link_hash_undefined)
 549     {
 550       at = strchr (undef->root.string, '@');
 551       if (at)
 552       {
 553         /* The symbol is a stdcall symbol, so let's look for a cdecl
 554            symbol with the same name and resolve to that */
 555         char *cname = xstrdup (undef->root.string);
 556         at = strchr (cname, '@');
 557         *at = 0;
 558         sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
 559         if (sym && sym->type == bfd_link_hash_defined)
 560         {
 561           undef->type = bfd_link_hash_defined;
 562           undef->u.def.value = sym->u.def.value;
 563           undef->u.def.section = sym->u.def.section;
 564           if (pe_enable_stdcall_fixup == -1)
 565             {
 566               einfo (_("Warning: resolving %s by linking to %s\n"),
 567                      undef->root.string, cname);
 568               if (! gave_warning_message)
 569                 {
 570                   gave_warning_message = 1;
 571                   einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
 572                   einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
 573                 }
 574             }
 575         }
 576       }
 577       else
 578       {
 579         /* The symbol is a cdecl symbol, so we look for stdcall
 580            symbols - which means scanning the whole symbol table */
 581         pe_undef_found_sym = 0;
 582         bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
 583                                 (PTR) undef->root.string);
 584         sym = pe_undef_found_sym;
 585         if (sym)
 586         {
 587           undef->type = bfd_link_hash_defined;
 588           undef->u.def.value = sym->u.def.value;
 589           undef->u.def.section = sym->u.def.section;
 590           if (pe_enable_stdcall_fixup == -1)
 591             {
 592               einfo (_("Warning: resolving %s by linking to %s\n"),
 593                      undef->root.string, sym->root.string);
 594               if (! gave_warning_message)
 595                 {
 596                   gave_warning_message = 1;
 597                   einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
 598                   einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
 599                 }
 600             }
 601         }
 602       }
 603     }
 604 }
 605
 606 static void
 607 gld_${EMULATION_NAME}_after_open ()
 608 {
 609   /* Pass the wacky PE command line options into the output bfd.
 610      FIXME: This should be done via a function, rather than by
 611      including an internal BFD header.  */
 612
 613   if (!coff_data (output_bfd)->pe)
 614     einfo (_("%F%P: PE operations on non PE file.\n"));
 615
 616   pe_data (output_bfd)->pe_opthdr = pe;
 617   pe_data (output_bfd)->dll = init[DLLOFF].value;
 618
 619   if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
 620     pe_fixup_stdcalls ();
 621
 622 #ifdef TARGET_IS_i386pe
 623   pe_process_import_defs(output_bfd, &link_info);
 624   if (link_info.shared)
 625     pe_dll_build_sections (output_bfd, &link_info);
 626 #endif
 627
 628 #ifdef TARGET_IS_armpe
 629   {
 630     /* Find a BFD that can hold the interworking stubs.  */
 631     LANG_FOR_EACH_INPUT_STATEMENT (is)
 632       {
 633         if (bfd_arm_get_bfd_for_interworking (is->the_bfd, & link_info))
 634           break;
 635       }
 636   }
 637 #endif
 638 }
 639 \f
 640 static void
 641 gld_${EMULATION_NAME}_before_allocation()
 642 {
 643 #ifdef TARGET_IS_ppcpe
 644   /* Here we rummage through the found bfds to collect toc information */
 645   {
 646     LANG_FOR_EACH_INPUT_STATEMENT (is)
 647       {
 648         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
 649           {
 650             /* xgettext:c-format */
 651             einfo (_("Errors encountered processing file %s\n"), is->filename);
 652           }
 653       }
 654   }
 655
 656   /* We have seen it all. Allocate it, and carry on */
 657   ppc_allocate_toc_section (&link_info);
 658 #endif /* TARGET_IS_ppcpe */
 659
 660 #ifdef TARGET_IS_armpe
 661   /* FIXME: we should be able to set the size of the interworking stub
 662      section.
 663
 664      Here we rummage through the found bfds to collect glue
 665      information.  FIXME: should this be based on a command line
 666      option?  krk@cygnus.com */
 667   {
 668     LANG_FOR_EACH_INPUT_STATEMENT (is)
 669       {
 670         if (! bfd_arm_process_before_allocation
 671             (is->the_bfd, & link_info, support_old_code))
 672           {
 673             /* xgettext:c-format */
 674             einfo (_("Errors encountered processing file %s for interworking"),
 675                    is->filename);
 676           }
 677       }
 678   }
 679
 680   /* We have seen it all. Allocate it, and carry on */
 681   bfd_arm_allocate_interworking_sections (& link_info);
 682 #endif /* TARGET_IS_armpe */
 683 }
 684 \f
 685
 686 /* This is called when an input file isn't recognized as a BFD.  We
 687    check here for .DEF files and pull them in automatically. */
 688
 689 static int
 690 saw_option(char *option)
 691 {
 692   int i;
 693   for (i=0; init[i].ptr; i++)
 694     if (strcmp (init[i].symbol, option) == 0)
 695       return init[i].inited;
 696   return 0;
 697 }
 698
 699 static boolean
 700 gld_${EMULATION_NAME}_unrecognized_file(entry)
 701   lang_input_statement_type *entry;
 702 {
 703 #ifdef TARGET_IS_i386pe
 704   const char *ext = entry->filename + strlen (entry->filename) - 4;
 705
 706   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
 707   {
 708     if (pe_def_file == 0)
 709       pe_def_file = def_file_empty ();
 710     def_file_parse (entry->filename, pe_def_file);
 711     if (pe_def_file)
 712     {
 713       int i, buflen=0, len;
 714       char *buf;
 715       for (i=0; i<pe_def_file->num_exports; i++)
 716         {
 717           len = strlen(pe_def_file->exports[i].internal_name);
 718           if (buflen < len+2)
 719             buflen = len+2;
 720         }
 721       buf = (char *) xmalloc (buflen);
 722       for (i=0; i<pe_def_file->num_exports; i++)
 723         {
 724           struct bfd_link_hash_entry *h;
 725           sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
 726
 727           h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true);
 728           if (h == (struct bfd_link_hash_entry *) NULL)
 729             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
 730           if (h->type == bfd_link_hash_new)
 731             {
 732               h->type = bfd_link_hash_undefined;
 733               h->u.undef.abfd = NULL;
 734               bfd_link_add_undef (link_info.hash, h);
 735             }
 736         }
 737       free (buf);
 738
 739       /* def_file_print (stdout, pe_def_file); */
 740       if (pe_def_file->is_dll == 1)
 741         link_info.shared = 1;
 742
 743       if (pe_def_file->base_address != (bfd_vma)(-1))
 744       {
 745         pe.ImageBase =
 746         pe_data (output_bfd)->pe_opthdr.ImageBase =
 747         init[IMAGEBASEOFF].value = pe_def_file->base_address;
 748         init[IMAGEBASEOFF].inited = 1;
 749         if (image_base_statement)
 750           image_base_statement->exp =
 751             exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
 752       }
 753
 754 #if 0
 755       /* Not sure if these *should* be set */
 756       if (pe_def_file->version_major != -1)
 757       {
 758         pe.MajorImageVersion = pe_def_file->version_major;
 759         pe.MinorImageVersion = pe_def_file->version_minor;
 760       }
 761 #endif
 762       if (pe_def_file->stack_reserve != -1
 763           && ! saw_option ("__size_of_stack_reserve__"))
 764       {
 765         pe.SizeOfStackReserve = pe_def_file->stack_reserve;
 766         if (pe_def_file->stack_commit != -1)
 767           pe.SizeOfStackCommit = pe_def_file->stack_commit;
 768       }
 769       if (pe_def_file->heap_reserve != -1
 770           && ! saw_option ("__size_of_heap_reserve__"))
 771       {
 772         pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
 773         if (pe_def_file->heap_commit != -1)
 774           pe.SizeOfHeapCommit = pe_def_file->heap_commit;
 775       }
 776       return true;
 777     }
 778   }
 779 #endif
 780   return false;
 781
 782 }
 783
 784 static void
 785 gld_${EMULATION_NAME}_finish ()
 786 {
 787 #ifdef TARGET_IS_i386pe
 788   if (link_info.shared)
 789     {
 790       pe_dll_fill_sections (output_bfd, &link_info);
 791       if (pe_implib_filename)
 792         pe_dll_generate_implib (pe_def_file, pe_implib_filename);
 793     }
 794   if (pe_out_def_filename)
 795     pe_dll_generate_def_file (pe_out_def_filename);
 796 #endif
 797 }
 798
 799 \f
 800 /* Place an orphan section.
 801
 802    We use this to put sections in a reasonable place in the file, and
 803    to ensure that they are aligned as required.
 804
 805    We handle grouped sections here as well.  A section named .foo$nn
 806    goes into the output section .foo.  All grouped sections are sorted
 807    by name.
 808
 809    Grouped sections for the default sections are handled by the
 810    default linker script using wildcards, and are sorted by
 811    sort_sections.  */
 812
 813 static asection *hold_section;
 814 static char *hold_section_name;
 815 static lang_output_section_statement_type *hold_use;
 816 static lang_output_section_statement_type *hold_text;
 817 static lang_output_section_statement_type *hold_rdata;
 818 static lang_output_section_statement_type *hold_data;
 819 static lang_output_section_statement_type *hold_bss;
 820
 821 /* Place an orphan section.  We use this to put random SHF_ALLOC
 822    sections in the right segment.  */
 823
 824 /*ARGSUSED*/
 825 static boolean
 826 gld_${EMULATION_NAME}_place_orphan (file, s)
 827      lang_input_statement_type *file;
 828      asection *s;
 829 {
 830   const char *secname;
 831   char *dollar;
 832
 833   if ((s->flags & SEC_ALLOC) == 0)
 834     return false;
 835
 836   secname = bfd_get_section_name (s->owner, s);
 837
 838   /* Look through the script to see where to place this section.  */
 839
 840   hold_section = s;
 841
 842   hold_section_name = xstrdup (secname);
 843   dollar = strchr (hold_section_name, '$');
 844   if (dollar != NULL)
 845     *dollar = '\0';
 846
 847   hold_use = NULL;
 848   lang_for_each_statement (gld${EMULATION_NAME}_place_section);
 849
 850   if (hold_use == NULL)
 851     {
 852       lang_output_section_statement_type *place;
 853       char *outsecname;
 854       asection *snew, **pps;
 855       lang_statement_list_type *old;
 856       lang_statement_list_type add;
 857       etree_type *address;
 858
 859       /* Try to put the new output section in a reasonable place based
 860          on the section name and section flags.  */
 861       place = NULL;
 862       if ((s->flags & SEC_HAS_CONTENTS) == 0
 863           && hold_bss != NULL)
 864         place = hold_bss;
 865       else if ((s->flags & SEC_READONLY) == 0
 866                && hold_data != NULL)
 867         place = hold_data;
 868       else if ((s->flags & SEC_CODE) == 0
 869                && (s->flags & SEC_READONLY) != 0
 870                && hold_rdata != NULL)
 871         place = hold_rdata;
 872       else if ((s->flags & SEC_READONLY) != 0
 873                && hold_text != NULL)
 874         place = hold_text;
 875
 876       /* Choose a unique name for the section.  This will be needed if
 877          the same section name appears in the input file with
 878          different loadable or allocateable characteristics.  */
 879       outsecname = xstrdup (hold_section_name);
 880       if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
 881         {
 882           unsigned int len;
 883           char *newname;
 884           unsigned int i;
 885
 886           len = strlen (outsecname);
 887           newname = xmalloc (len + 5);
 888           strcpy (newname, outsecname);
 889           i = 0;
 890           do
 891             {
 892               sprintf (newname + len, "%d", i);
 893               ++i;
 894             }
 895           while (bfd_get_section_by_name (output_bfd, newname) != NULL);
 896
 897           free (outsecname);
 898           outsecname = newname;
 899         }
 900
 901       /* We don't want to free OUTSECNAME, as it may get attached to
 902          the output section statement.  */
 903
 904       /* Create the section in the output file, and put it in the
 905          right place.  This shuffling is to make the output file look
 906          neater.  */
 907       snew = bfd_make_section (output_bfd, outsecname);
 908       if (snew == NULL)
 909         einfo ("%P%F: output format %s cannot represent section called %s\n",
 910                output_bfd->xvec->name, outsecname);
 911       if (place != NULL && place->bfd_section != NULL)
 912         {
 913           for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
 914             ;
 915           *pps = snew->next;
 916           snew->next = place->bfd_section->next;
 917           place->bfd_section->next = snew;
 918         }
 919
 920       /* Start building a list of statements for this section.  */
 921       old = stat_ptr;
 922       stat_ptr = &add;
 923       lang_list_init (stat_ptr);
 924
 925       if (link_info.relocateable)
 926         address = NULL;
 927       else
 928         {
 929           /* All sections in an executable must be aligned to a page
 930              boundary.  */
 931           address = exp_unop (ALIGN_K,
 932                               exp_nameop (NAME, "__section_alignment__"));
 933         }
 934
 935       lang_enter_output_section_statement (outsecname, address, 0,
 936                                            (bfd_vma) 0,
 937                                            (etree_type *) NULL,
 938                                            (etree_type *) NULL,
 939                                            (etree_type *) NULL);
 940
 941       hold_use = lang_output_section_statement_lookup (outsecname);
 942
 943       lang_leave_output_section_statement
 944         ((bfd_vma) 0, "*default*",
 945          (struct lang_output_section_phdr_list *) NULL);
 946
 947       /* Now stick the new statement list right after PLACE.  */
 948       if (place != NULL)
 949         {
 950           *add.tail = place->header.next;
 951           place->header.next = add.head;
 952         }
 953
 954       stat_ptr = old;
 955     }
 956
 957   if (dollar == NULL)
 958     wild_doit (&hold_use->children, s, hold_use, file);
 959   else
 960     {
 961       lang_statement_union_type **pl;
 962       boolean found_dollar;
 963       lang_statement_list_type list;
 964
 965       /* The section name has a '$'.  Sort it with the other '$'
 966          sections.  */
 967
 968       found_dollar = false;
 969       for (pl = &hold_use->children.head; *pl != NULL; pl = &(*pl)->next)
 970         {
 971           lang_input_section_type *ls;
 972           const char *lname;
 973
 974           if ((*pl)->header.type != lang_input_section_enum)
 975             continue;
 976
 977           ls = &(*pl)->input_section;
 978
 979           lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
 980           if (strchr (lname, '$') == NULL)
 981             {
 982               if (found_dollar)
 983                 break;
 984             }
 985           else
 986             {
 987               found_dollar = true;
 988               if (strcmp (secname, lname) < 0)
 989                 break;
 990             }
 991         }
 992
 993       lang_list_init (&list);
 994       wild_doit (&list, s, hold_use, file);
 995       if (list.head != NULL)
 996         {
 997           ASSERT (list.head->next == NULL);
 998           list.head->next = *pl;
 999           *pl = list.head;
1000         }
1001     }
1002
1003   free (hold_section_name);
1004
1005   return true;
1006 }
1007
1008 static void
1009 gld${EMULATION_NAME}_place_section (s)
1010      lang_statement_union_type *s;
1011 {
1012   lang_output_section_statement_type *os;
1013
1014   if (s->header.type != lang_output_section_statement_enum)
1015     return;
1016
1017   os = &s->output_section_statement;
1018
1019   if (strcmp (os->name, hold_section_name) == 0
1020       && os->bfd_section != NULL
1021       && ((hold_section->flags & (SEC_LOAD | SEC_ALLOC))
1022           == (os->bfd_section->flags & (SEC_LOAD | SEC_ALLOC))))
1023     hold_use = os;
1024
1025   if (strcmp (os->name, ".text") == 0)
1026     hold_text = os;
1027   else if (strcmp (os->name, ".rdata") == 0)
1028     hold_rdata = os;
1029   else if (strcmp (os->name, ".data") == 0)
1030     hold_data = os;
1031   else if (strcmp (os->name, ".bss") == 0)
1032     hold_bss = os;
1033 }
1034 \f
1035 static char *
1036 gld_${EMULATION_NAME}_get_script(isfile)
1037      int *isfile;
1038 EOF
1039 # Scripts compiled in.
1040 # sed commands to quote an ld script as a C string.
1041 sc="-f ${srcdir}/emultempl/stringify.sed"
1042
1043 cat >>e${EMULATION_NAME}.c <<EOF
1044 {
1045   *isfile = 0;
1046
1047   if (link_info.relocateable == true && config.build_constructors == true)
1048     return
1049 EOF
1050 sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
1051 echo '  ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1052 sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
1053 echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
1054 sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
1055 echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
1056 sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
1057 echo '  ; else return'                                     >> e${EMULATION_NAME}.c
1058 sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
1059 echo '; }'                                                 >> e${EMULATION_NAME}.c
1060
1061 cat >>e${EMULATION_NAME}.c <<EOF
1062
1063
1064 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1065 {
1066   gld_${EMULATION_NAME}_before_parse,
1067   syslib_default,
1068   hll_default,
1069   gld_${EMULATION_NAME}_after_parse,
1070   gld_${EMULATION_NAME}_after_open,
1071   after_allocation_default,
1072   set_output_arch_default,
1073   ldemul_default_target,
1074   gld_${EMULATION_NAME}_before_allocation,
1075   gld_${EMULATION_NAME}_get_script,
1076   "${EMULATION_NAME}",
1077   "${OUTPUT_FORMAT}",
1078   gld_${EMULATION_NAME}_finish, /* finish */
1079   NULL, /* create output section statements */
1080   NULL, /* open dynamic archive */
1081   gld_${EMULATION_NAME}_place_orphan,
1082   gld_${EMULATION_NAME}_set_symbols,
1083   gld_${EMULATION_NAME}_parse_args,
1084   gld_${EMULATION_NAME}_unrecognized_file,
1085   gld_${EMULATION_NAME}_list_options
1086 };
1087 EOF