Subversion Repositories openrisc

# This shell script emits a C file. -*- C -*-

# It does some substitutions.

test -z "${ENTRY}" && ENTRY="_mainCRTStartup"

if [ -z "$MACHINE" ]; then

  OUTPUT_ARCH=${ARCH}

else

  OUTPUT_ARCH=${ARCH}:${MACHINE}

fi

rm -f e${EMULATION_NAME}.c

(echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)

fragment <

/* Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.

   Written by Kai Tietz, OneVision Software GmbH&CoKg.

   This file is part of the GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/* For WINDOWS_XP64 and higher */

/* Based on pe.em, but modified for 64 bit support.  */

#define TARGET_IS_${EMULATION_NAME}

#define COFF_IMAGE_WITH_PE

#define COFF_WITH_PE

#define COFF_WITH_pex64

#include "sysdep.h"

#include "bfd.h"

#include "bfdlink.h"

#include "getopt.h"

#include "libiberty.h"

#include "ld.h"

#include "ldmain.h"

#include "ldexp.h"

#include "ldlang.h"

#include "ldfile.h"

#include "ldemul.h"

#include 

#include "ldlex.h"

#include "ldmisc.h"

#include "ldctor.h"

#include "coff/internal.h"

/* FIXME: See bfd/peXXigen.c for why we include an architecture specific

   header in generic PE code.  */

#include "coff/x86_64.h"

#include "coff/pe.h"

/* FIXME: This is a BFD internal header file, and we should not be

   using it here.  */

#include "../bfd/libcoff.h"

#undef  AOUTSZ

#define AOUTSZ          PEPAOUTSZ

#define PEAOUTHDR       PEPAOUTHDR

#include "deffile.h"

#include "pep-dll.h"

#include "safe-ctype.h"

/* Permit the emulation parameters to override the default section

   alignment by setting OVERRIDE_SECTION_ALIGNMENT.  FIXME: This makes

   it seem that include/coff/internal.h should not define

   PE_DEF_SECTION_ALIGNMENT.  */

#if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}

#undef  PE_DEF_SECTION_ALIGNMENT

#define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}

#endif

#ifdef TARGET_IS_i386pep

#define DLL_SUPPORT

#endif

#if defined(TARGET_IS_i386pep) || ! defined(DLL_SUPPORT)

#define PE_DEF_SUBSYSTEM                3

#else

#undef  NT_EXE_IMAGE_BASE

#define NT_EXE_IMAGE_BASE               0x00010000

#undef  PE_DEF_SECTION_ALIGNMENT

#define PE_DEF_SUBSYSTEM                2

#undef  PE_DEF_FILE_ALIGNMENT

#define PE_DEF_FILE_ALIGNMENT           0x00000200

#define PE_DEF_SECTION_ALIGNMENT        0x00000400

#endif

static struct internal_extra_pe_aouthdr pep;

static int dll;

static flagword real_flags = IMAGE_FILE_LARGE_ADDRESS_AWARE;

static int support_old_code = 0;

static lang_assignment_statement_type *image_base_statement = 0;

static unsigned short pe_dll_characteristics = 0;

#ifdef DLL_SUPPORT

static int    pep_enable_stdcall_fixup = 1; /* 0=disable 1=enable (default).  */

static char * pep_out_def_filename = NULL;

static char * pep_implib_filename = NULL;

static int    pep_enable_auto_image_base = 0;

static char * pep_dll_search_prefix = NULL;

#endif

extern const char *output_filename;

static void

gld_${EMULATION_NAME}_before_parse (void)

{

  ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);

  output_filename = "${EXECUTABLE_NAME:-a.exe}";

#ifdef DLL_SUPPORT

  config.dynamic_link = TRUE;

  config.has_shared = 1;

  link_info.pei386_auto_import = -1;

  link_info.pei386_runtime_pseudo_reloc = 2; /* Use by default version 2.  */

#if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)

  lang_default_entry ("_WinMainCRTStartup");

#else

  lang_default_entry ("${ENTRY}");

#endif

#endif

}

/* PE format extra command line options.  */

/* Used for setting flags in the PE header.  */

enum options

{

  OPTION_BASE_FILE = 300 + 1,

  OPTION_DLL,

  OPTION_FILE_ALIGNMENT,

  OPTION_IMAGE_BASE,

  OPTION_MAJOR_IMAGE_VERSION,

  OPTION_MAJOR_OS_VERSION,

  OPTION_MAJOR_SUBSYSTEM_VERSION,

  OPTION_MINOR_IMAGE_VERSION,

  OPTION_MINOR_OS_VERSION,

  OPTION_MINOR_SUBSYSTEM_VERSION,

  OPTION_SECTION_ALIGNMENT,

  OPTION_STACK,

  OPTION_SUBSYSTEM,

  OPTION_HEAP,

  OPTION_SUPPORT_OLD_CODE,

  OPTION_OUT_DEF,

  OPTION_EXPORT_ALL,

  OPTION_EXCLUDE_SYMBOLS,

  OPTION_KILL_ATS,

  OPTION_STDCALL_ALIASES,

  OPTION_ENABLE_STDCALL_FIXUP,

  OPTION_DISABLE_STDCALL_FIXUP,

  OPTION_IMPLIB_FILENAME,

  OPTION_WARN_DUPLICATE_EXPORTS,

  OPTION_IMP_COMPAT,

  OPTION_ENABLE_AUTO_IMAGE_BASE,

  OPTION_DISABLE_AUTO_IMAGE_BASE,

  OPTION_DLL_SEARCH_PREFIX,

  OPTION_NO_DEFAULT_EXCLUDES,

  OPTION_DLL_ENABLE_AUTO_IMPORT,

  OPTION_DLL_DISABLE_AUTO_IMPORT,

  OPTION_ENABLE_EXTRA_PE_DEBUG,

  OPTION_EXCLUDE_LIBS,

  OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC,

  OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC,

  OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1,

  OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2,

  OPTION_EXCLUDE_MODULES_FOR_IMPLIB,

  OPTION_USE_NUL_PREFIXED_IMPORT_TABLES,

  OPTION_ENABLE_LONG_SECTION_NAMES,

  OPTION_DISABLE_LONG_SECTION_NAMES,

  OPTION_DYNAMIC_BASE,

  OPTION_FORCE_INTEGRITY,

  OPTION_NX_COMPAT,

  OPTION_NO_ISOLATION,

  OPTION_NO_SEH,

  OPTION_NO_BIND,

  OPTION_WDM_DRIVER,

  OPTION_TERMINAL_SERVER_AWARE

};

static void

gld${EMULATION_NAME}_add_options

  (int ns ATTRIBUTE_UNUSED,

   char **shortopts ATTRIBUTE_UNUSED,

   int nl,

   struct option **longopts,

   int nrl ATTRIBUTE_UNUSED,

   struct option **really_longopts ATTRIBUTE_UNUSED)

{

  static const struct option xtra_long[] =

  {

    /* PE options */

    {"base-file", required_argument, NULL, OPTION_BASE_FILE},

    {"dll", no_argument, NULL, OPTION_DLL},

    {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},

    {"heap", required_argument, NULL, OPTION_HEAP},

    {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},

    {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},

    {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},

    {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},

    {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},

    {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},

    {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},

    {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},

    {"stack", required_argument, NULL, OPTION_STACK},

    {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},

    {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},

    {"use-nul-prefixed-import-tables", no_argument, NULL,

     OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},

#ifdef DLL_SUPPORT

    /* getopt allows abbreviations, so we do this to stop it

       from treating -o as an abbreviation for this option.  */

    {"output-def", required_argument, NULL, OPTION_OUT_DEF},

    {"output-def", required_argument, NULL, OPTION_OUT_DEF},

    {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},

    {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},

    {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},

    {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB},

    {"kill-at", no_argument, NULL, OPTION_KILL_ATS},

    {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},

    {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},

    {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},

    {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},

    {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},

    /* getopt() allows abbreviations, so we do this to stop it from

       treating -c as an abbreviation for these --compat-implib.  */

    {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},

    {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},

    {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},

    {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},

    {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},

    {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},

    {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},

    {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},

    {"enable-extra-pep-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},

    {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},

    {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},

    {"enable-runtime-pseudo-reloc-v1", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1},

    {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2},

#endif

    {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},

    {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},

    {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},

    {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},

    {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},

    {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},

    {"no-seh", no_argument, NULL, OPTION_NO_SEH},

    {"no-bind", no_argument, NULL, OPTION_NO_BIND},

    {"wdmdriver", no_argument, NULL, OPTION_WDM_DRIVER},

    {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE},

    {NULL, no_argument, NULL, 0}

  };

  *longopts

    = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));

  memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));

}

/* PE/WIN32; added routines to get the subsystem type, heap and/or stack

   parameters which may be input from the command line.  */

typedef struct

{

  void *ptr;

  int size;

  bfd_vma value;

  char *symbol;

  int inited;

} definfo;

#define D(field,symbol,def)  {&pep.field,sizeof(pep.field), def, symbol,0}

static definfo init[] =

{

  /* imagebase must be first */

#define IMAGEBASEOFF 0

  D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),

#define DLLOFF 1

  {&dll, sizeof(dll), 0, "__dll__", 0},

#define MSIMAGEBASEOFF  2

  D(ImageBase,"___ImageBase", NT_EXE_IMAGE_BASE),

  D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),

  D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),

  D(MajorOperatingSystemVersion,"__major_os_version__", 4),

  D(MinorOperatingSystemVersion,"__minor_os_version__", 0),

  D(MajorImageVersion,"__major_image_version__", 0),

  D(MinorImageVersion,"__minor_image_version__", 0),

  D(MajorSubsystemVersion,"__major_subsystem_version__", 5),

  D(MinorSubsystemVersion,"__minor_subsystem_version__", 2),

  D(Subsystem,"__subsystem__", ${SUBSYSTEM}),

  D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),

  D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),

  D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),

  D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),

  D(LoaderFlags,"__loader_flags__", 0x0),

  D(DllCharacteristics, "__dll_characteristics__", 0x0),

  { NULL, 0, 0, NULL, 0 }

};

static void

gld_${EMULATION_NAME}_list_options (FILE *file)

{

  fprintf (file, _("  --base_file              Generate a base file for relocatable DLLs\n"));

  fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));

  fprintf (file, _("  --file-alignment             Set file alignment\n"));

  fprintf (file, _("  --heap                       Set initial size of the heap\n"));

  fprintf (file, _("  --image-base 
             Set start address of the executable\n"));

  fprintf (file, _("  --major-image-version      Set version number of the executable\n"));

  fprintf (file, _("  --major-os-version         Set minimum required OS version\n"));

  fprintf (file, _("  --major-subsystem-version  Set minimum required OS subsystem version\n"));

  fprintf (file, _("  --minor-image-version      Set revision number of the executable\n"));

  fprintf (file, _("  --minor-os-version         Set minimum required OS revision\n"));

  fprintf (file, _("  --minor-subsystem-version  Set minimum required OS subsystem revision\n"));

  fprintf (file, _("  --section-alignment          Set section alignment\n"));

  fprintf (file, _("  --stack                      Set size of the initial stack\n"));

  fprintf (file, _("  --subsystem [:]     Set required OS subsystem [& version]\n"));

  fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));

#ifdef DLL_SUPPORT

  fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));

  fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));

  fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));

  fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));

  fprintf (file, _("  --exclude-libs lib,lib,...         Exclude libraries from automatic export\n"));

  fprintf (file, _("  --exclude-modules-for-implib mod,mod,...\n"));

  fprintf (file, _("                                     Exclude objects, archive members from auto\n"));

  fprintf (file, _("                                     export, place into import library instead.\n"));

  fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));

  fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));

  fprintf (file, _("  --out-implib                 Generate import library\n"));

  fprintf (file, _("  --output-def                 Generate a .DEF file for the built DLL\n"));

  fprintf (file, _("  --warn-duplicate-exports           Warn about duplicate exports.\n"));

  fprintf (file, _("  --compat-implib                    Create backward compatible import libs;\n\

                                       create __imp_ as well.\n"));

  fprintf (file, _("  --enable-auto-image-base           Automatically choose image base for DLLs\n\

                                       unless user specifies one\n"));

  fprintf (file, _("  --disable-auto-image-base          Do not auto-choose image base. (default)\n"));

  fprintf (file, _("  --dll-search-prefix=       When linking dynamically to a dll without\n\

                                       an importlib, use .dll\n\

                                       in preference to lib.dll \n"));

  fprintf (file, _("  --enable-auto-import               Do sophistcated linking of _sym to\n\

                                       __imp_sym for DATA references\n"));

  fprintf (file, _("  --disable-auto-import              Do not auto-import DATA items from DLLs\n"));

  fprintf (file, _("  --enable-runtime-pseudo-reloc      Work around auto-import limitations by\n\

                                       adding pseudo-relocations resolved at\n\

                                       runtime.\n"));

  fprintf (file, _("  --disable-runtime-pseudo-reloc     Do not add runtime pseudo-relocations for\n\

                                       auto-imported DATA.\n"));

  fprintf (file, _("  --enable-extra-pep-debug            Enable verbose debug output when building\n\

                                       or linking to DLLs (esp. auto-import)\n"));

  fprintf (file, _("  --enable-long-section-names        Use long COFF section names even in\n\

                                       executable image files\n"));

  fprintf (file, _("  --disable-long-section-names       Never use long COFF section names, even\n\

                                       in object files\n"));

  fprintf (file, _("  --dynamicbase                      Image base address may be relocated using\n\

                                       address space layout randomization (ASLR)\n"));

  fprintf (file, _("  --forceinteg               Code integrity checks are enforced\n"));

  fprintf (file, _("  --nxcompat                 Image is compatible with data execution prevention\n"));

  fprintf (file, _("  --no-isolation             Image understands isolation but do not isolate the image\n"));

  fprintf (file, _("  --no-seh                   Image does not use SEH. No SE handler may\n\

                                       be called in this image\n"));

  fprintf (file, _("  --no-bind                  Do not bind this image\n"));

  fprintf (file, _("  --wdmdriver                Driver uses the WDM model\n"));

  fprintf (file, _("  --tsaware                  Image is Terminal Server aware\n"));

#endif

}

static void

set_pep_name (char *name, bfd_vma val)

{

  int i;

  /* Find the name and set it.  */

  for (i = 0; init[i].ptr; i++)

    {

      if (strcmp (name, init[i].symbol) == 0)

        {

          init[i].value = val;

          init[i].inited = 1;

          if (strcmp (name,"__image_base__") == 0)

            set_pep_name ("___ImageBase", val);

          return;

        }

    }

  abort ();

}

static void

set_pep_subsystem (void)

{

  const char *sver;

  const char *entry;

  const char *initial_symbol_char;

  char *end;

  int len;

  int i;

  int subsystem;

  unsigned long temp_subsystem;

  static const struct

    {

      const char *name;

      const int value;

      const char *entry;

    }

  v[] =

    {

      { "native",  1, "NtProcessStartup" },

      { "windows", 2, "WinMainCRTStartup" },

      { "console", 3, "mainCRTStartup" },

      { "posix",   7, "__PosixProcessStartup"},

      { "wince",   9, "_WinMainCRTStartup" },

      { "xbox",   14, "mainCRTStartup" },

      { NULL, 0, NULL }

    };

  /* Entry point name for arbitrary subsystem numbers.  */

  static const char default_entry[] = "mainCRTStartup";

  /* Check for the presence of a version number.  */

  sver = strchr (optarg, ':');

  if (sver == NULL)

    len = strlen (optarg);

  else

    {

      len = sver - optarg;

      set_pep_name ("__major_subsystem_version__",

                    strtoul (sver + 1, &end, 0));

      if (*end == '.')

        set_pep_name ("__minor_subsystem_version__",

                      strtoul (end + 1, &end, 0));

      if (*end != '\0')

        einfo (_("%P: warning: bad version number in -subsystem option\n"));

    }

  /* Check for numeric subsystem.  */

  temp_subsystem = strtoul (optarg, & end, 0);

  if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))

    {

      /* Search list for a numeric match to use its entry point.  */

      for (i = 0; v[i].name; i++)

        if (v[i].value == (int) temp_subsystem)

          break;

      /* If no match, use the default.  */

      if (v[i].name != NULL)

        entry = v[i].entry;

      else

        entry = default_entry;

      /* Use this subsystem.  */

      subsystem = (int) temp_subsystem;

    }

  else

    {

      /* Search for subsystem by name.  */

      for (i = 0; v[i].name; i++)

        if (strncmp (optarg, v[i].name, len) == 0

            && v[i].name[len] == '\0')

          break;

      if (v[i].name == NULL)

        {

          einfo (_("%P%F: invalid subsystem type %s\n"), optarg);

          return;

        }

      entry = v[i].entry;

      subsystem = v[i].value;

    }

  set_pep_name ("__subsystem__", subsystem);

  initial_symbol_char = ${INITIAL_SYMBOL_CHAR};

  if (*initial_symbol_char != '\0')

    {

      char *alc_entry;

      /* lang_default_entry expects its argument to be permanently

         allocated, so we don't free this string.  */

      alc_entry = xmalloc (strlen (initial_symbol_char)

                           + strlen (entry)

                           + 1);

      strcpy (alc_entry, initial_symbol_char);

      strcat (alc_entry, entry);

      entry = alc_entry;

    }

  lang_default_entry (entry);

  return;

}

static void

set_pep_value (char *name)

{

  char *end;

  set_pep_name (name,  (bfd_vma) strtoull (optarg, &end, 0));

  if (end == optarg)

    einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);

  optarg = end;

}

static void

set_pep_stack_heap (char *resname, char *comname)

{

  set_pep_value (resname);

  if (*optarg == ',')

    {

      optarg++;

      set_pep_value (comname);

    }

  else if (*optarg)

    einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);

}

static bfd_boolean

gld${EMULATION_NAME}_handle_option (int optc)

{

  switch (optc)

    {

    default:

      return FALSE;

    case OPTION_BASE_FILE:

      link_info.base_file = fopen (optarg, FOPEN_WB);

      if (link_info.base_file == NULL)

        {

          /* xgettext:c-format */

          fprintf (stderr, _("%s: Can't open base file %s\n"),

                   program_name, optarg);

          xexit (1);

        }

      break;

      /* PE options.  */

    case OPTION_HEAP:

      set_pep_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");

      break;

    case OPTION_STACK:

      set_pep_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");

      break;

    case OPTION_SUBSYSTEM:

      set_pep_subsystem ();

      break;

    case OPTION_MAJOR_OS_VERSION:

      set_pep_value ("__major_os_version__");

      break;

    case OPTION_MINOR_OS_VERSION:

      set_pep_value ("__minor_os_version__");

      break;

    case OPTION_MAJOR_SUBSYSTEM_VERSION:

      set_pep_value ("__major_subsystem_version__");

      break;

    case OPTION_MINOR_SUBSYSTEM_VERSION:

      set_pep_value ("__minor_subsystem_version__");

      break;

    case OPTION_MAJOR_IMAGE_VERSION:

      set_pep_value ("__major_image_version__");

      break;

    case OPTION_MINOR_IMAGE_VERSION:

      set_pep_value ("__minor_image_version__");

      break;

    case OPTION_FILE_ALIGNMENT:

      set_pep_value ("__file_alignment__");

      break;

    case OPTION_SECTION_ALIGNMENT:

      set_pep_value ("__section_alignment__");

      break;

    case OPTION_DLL:

      set_pep_name ("__dll__", 1);

      break;

    case OPTION_IMAGE_BASE:

      set_pep_value ("__image_base__");

      break;

    case OPTION_SUPPORT_OLD_CODE:

      support_old_code = 1;

      break;

    case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:

      pep_use_nul_prefixed_import_tables = TRUE;

      break;

#ifdef DLL_SUPPORT

    case OPTION_OUT_DEF:

      pep_out_def_filename = xstrdup (optarg);

      break;

    case OPTION_EXPORT_ALL:

      pep_dll_export_everything = 1;

      break;

    case OPTION_EXCLUDE_SYMBOLS:

      pep_dll_add_excludes (optarg, EXCLUDESYMS);

      break;

    case OPTION_EXCLUDE_LIBS:

      pep_dll_add_excludes (optarg, EXCLUDELIBS);

      break;

    case OPTION_EXCLUDE_MODULES_FOR_IMPLIB:

      pep_dll_add_excludes (optarg, EXCLUDEFORIMPLIB);

      break;

    case OPTION_KILL_ATS:

      pep_dll_kill_ats = 1;

      break;

    case OPTION_STDCALL_ALIASES:

      pep_dll_stdcall_aliases = 1;

      break;

    case OPTION_ENABLE_STDCALL_FIXUP:

      pep_enable_stdcall_fixup = 1;

      break;

    case OPTION_DISABLE_STDCALL_FIXUP:

      pep_enable_stdcall_fixup = 0;

      break;

    case OPTION_IMPLIB_FILENAME:

      pep_implib_filename = xstrdup (optarg);

      break;

    case OPTION_WARN_DUPLICATE_EXPORTS:

      pep_dll_warn_dup_exports = 1;

      break;

    case OPTION_IMP_COMPAT:

      pep_dll_compat_implib = 1;

      break;

    case OPTION_ENABLE_AUTO_IMAGE_BASE:

      pep_enable_auto_image_base = 1;

      break;

    case OPTION_DISABLE_AUTO_IMAGE_BASE:

      pep_enable_auto_image_base = 0;

      break;

    case OPTION_DLL_SEARCH_PREFIX:

      pep_dll_search_prefix = xstrdup (optarg);

      break;

    case OPTION_NO_DEFAULT_EXCLUDES:

      pep_dll_do_default_excludes = 0;

      break;

    case OPTION_DLL_ENABLE_AUTO_IMPORT:

      link_info.pei386_auto_import = 1;

      break;

    case OPTION_DLL_DISABLE_AUTO_IMPORT:

      link_info.pei386_auto_import = 0;

      break;

    case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:

      link_info.pei386_runtime_pseudo_reloc = 2;

      break;

    case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:

      link_info.pei386_runtime_pseudo_reloc = 0;

      break;

    case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1:

      link_info.pei386_runtime_pseudo_reloc = 1;

      break;

    case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2:

      link_info.pei386_runtime_pseudo_reloc = 2;

      break;

    case OPTION_ENABLE_EXTRA_PE_DEBUG:

      pep_dll_extra_pe_debug = 1;

      break;

#endif

    case OPTION_ENABLE_LONG_SECTION_NAMES:

      pep_use_coff_long_section_names = 1;

      break;

    case OPTION_DISABLE_LONG_SECTION_NAMES:

      pep_use_coff_long_section_names = 0;

      break;

    /*  Get DLLCharacteristics bits  */

    case OPTION_DYNAMIC_BASE:

      pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;

      break;

    case OPTION_FORCE_INTEGRITY:

      pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;

      break;

    case OPTION_NX_COMPAT:

      pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;

      break;

    case OPTION_NO_ISOLATION:

      pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;

      break;

    case OPTION_NO_SEH:

      pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_SEH;

      break;

    case OPTION_NO_BIND:

      pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_BIND;

      break;

    case OPTION_WDM_DRIVER:

      pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_WDM_DRIVER;

      break;

    case OPTION_TERMINAL_SERVER_AWARE:

      pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE;

      break;

    }

  /*  Set DLLCharacteristics bits  */

  set_pep_name ("__dll_characteristics__", pe_dll_characteristics);

  return TRUE;

}

#ifdef DLL_SUPPORT

static unsigned long

strhash (const char *str)

{

  const unsigned char *s;

  unsigned long hash;

  unsigned int c;

  unsigned int len;

  hash = 0;

  len = 0;

  s = (const unsigned char *) str;

  while ((c = *s++) != '\0')

    {

      hash += c + (c << 17);

      hash ^= hash >> 2;

      ++len;

    }

  hash += len + (len << 17);

  hash ^= hash >> 2;

  return hash;

}

/* Use the output file to create a image base for relocatable DLLs.  */

static bfd_vma

compute_dll_image_base (const char *ofile)

{

  bfd_vma hash = (bfd_vma) strhash (ofile);

  return 0x61300000 + ((hash << 16) & 0x0FFC0000);

}

#endif

/* Assign values to the special symbols before the linker script is

   read.  */

static void

gld_${EMULATION_NAME}_set_symbols (void)

{

  /* Run through and invent symbols for all the

     names and insert the defaults.  */

  int j;

  if (!init[IMAGEBASEOFF].inited)

    {

      if (link_info.relocatable)

        init[IMAGEBASEOFF].value = 0;

      else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))

        {

#ifdef DLL_SUPPORT

          init[IMAGEBASEOFF].value = (pep_enable_auto_image_base

                                      ? compute_dll_image_base (output_filename)

                                      : NT_DLL_IMAGE_BASE);

#else

          init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;

#endif

        }

      else

        init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;

      init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;

    }

  /* Don't do any symbol assignments if this is a relocatable link.  */

  if (link_info.relocatable)

    return;

  /* Glue the assignments into the abs section.  */

  push_stat_ptr (&abs_output_section->children);

  for (j = 0; init[j].ptr; j++)

    {

      bfd_vma val = init[j].value;

      lang_assignment_statement_type *rv;

      rv = lang_add_assignment (exp_assop ('=', init[j].symbol,

                                           exp_intop (val)));

      if (init[j].size == sizeof (short))

        *(short *) init[j].ptr = (short) val;

      else if (init[j].size == sizeof (int))

        *(int *) init[j].ptr = (int) val;

      else if (init[j].size == sizeof (long))

        *(long *) init[j].ptr = (long) val;

      /* This might be a long long or other special type.  */

      else if (init[j].size == sizeof (bfd_vma))

        *(bfd_vma *) init[j].ptr = val;

      else      abort ();

      if (j == IMAGEBASEOFF)

        image_base_statement = rv;

    }

  /* Restore the pointer.  */

  pop_stat_ptr ();

  if (pep.FileAlignment > pep.SectionAlignment)

    {

      einfo (_("%P: warning, file alignment > section alignment.\n"));

    }

}

/* This is called after the linker script and the command line options

   have been read.  */

static void

gld_${EMULATION_NAME}_after_parse (void)

{

  /* PR ld/6744:  Warn the user if they have used an ELF-only

     option hoping it will work on PE+.  */

  if (link_info.export_dynamic)

    einfo (_("%P: warning: --export-dynamic is not supported for PE+ "

      "targets, did you mean --export-all-symbols?\n"));

  after_parse_default ();

}

/* pep-dll.c directly accesses pep_data_import_dll,

   so it must be defined outside of #ifdef DLL_SUPPORT.

   Note - this variable is deliberately not initialised.

   This allows it to be treated as a common varaible, and only

   exist in one incarnation in a multiple target enabled linker.  */

char * pep_data_import_dll;

#ifdef DLL_SUPPORT

static struct bfd_link_hash_entry *pep_undef_found_sym;

static bfd_boolean

pep_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)

{

  int sl;

  char *string = inf;

  sl = strlen (string);

  if (h->type == bfd_link_hash_defined

      && strncmp (h->root.string, string, sl) == 0

      && h->root.string[sl] == '@')

    {

      pep_undef_found_sym = h;

      return FALSE;

    }

  return TRUE;

}

static void

pep_fixup_stdcalls (void)

{

  static int gave_warning_message = 0;

  struct bfd_link_hash_entry *undef, *sym;

  if (pep_dll_extra_pe_debug)

    printf ("%s\n", __FUNCTION__);

  for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)

    if (undef->type == bfd_link_hash_undefined)

      {

        char* at = strchr (undef->root.string, '@');

        int lead_at = (*undef->root.string == '@');

        /* For now, don't try to fixup fastcall symbols.  */

        if (at && !lead_at)

          {

            /* The symbol is a stdcall symbol, so let's look for a

               cdecl symbol with the same name and resolve to that.  */

            char *cname = xstrdup (undef->root.string /* + lead_at */);

            at = strchr (cname, '@');

            *at = 0;

            sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);

            if (sym && sym->type == bfd_link_hash_defined)

              {

                undef->type = bfd_link_hash_defined;

                undef->u.def.value = sym->u.def.value;

                undef->u.def.section = sym->u.def.section;

                if (pep_enable_stdcall_fixup == -1)

                  {

                    einfo (_("Warning: resolving %s by linking to %s\n"),

                           undef->root.string, cname);

                    if (! gave_warning_message)

                      {

                        gave_warning_message = 1;

                        einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));

                        einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));

                      }

                  }

              }

          }

        else

          {

            /* The symbol is a cdecl symbol, so we look for stdcall

               symbols - which means scanning the whole symbol table.  */

            pep_undef_found_sym = 0;

            bfd_link_hash_traverse (link_info.hash, pep_undef_cdecl_match,

                                    (char *) undef->root.string);

            sym = pep_undef_found_sym;

            if (sym)

              {

                undef->type = bfd_link_hash_defined;

                undef->u.def.value = sym->u.def.value;

                undef->u.def.section = sym->u.def.section;

                if (pep_enable_stdcall_fixup == -1)

                  {

                    einfo (_("Warning: resolving %s by linking to %s\n"),

                           undef->root.string, sym->root.string);

                    if (! gave_warning_message)

                      {

                        gave_warning_message = 1;

                        einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));

                        einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));

                      }

                  }

              }

          }

      }

}

static int

make_import_fixup (arelent *rel, asection *s)

{

  struct bfd_symbol *sym = *rel->sym_ptr_ptr;

  char addend[8];

  bfd_vma _addend = 0;

  int suc = 0;

  if (pep_dll_extra_pe_debug)