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 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,

   2005, 2006, 2007, 2008 Free Software Foundation, Inc.

   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_NT */

/* The original file generated returned different default scripts depending

   on whether certain switches were set, but these switches pertain to the

   Linux system and that particular version of coff.  In the NT case, we

   only determine if the subsystem is console or windows in order to select

   the correct entry point by default. */

#define TARGET_IS_${EMULATION_NAME}

/* Do this before including bfd.h, so we prototype the right functions.  */

#if defined(TARGET_IS_armpe) \

    || defined(TARGET_IS_arm_epoc_pe) \

    || defined(TARGET_IS_arm_wince_pe)

#define bfd_arm_allocate_interworking_sections \

        bfd_${EMULATION_NAME}_allocate_interworking_sections

#define bfd_arm_get_bfd_for_interworking \

        bfd_${EMULATION_NAME}_get_bfd_for_interworking

#define bfd_arm_process_before_allocation \

        bfd_${EMULATION_NAME}_process_before_allocation

#endif

#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/i386.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"

#include "deffile.h"

#include "pe-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

#if defined(TARGET_IS_i386pe) \

    || defined(TARGET_IS_shpe) \

    || defined(TARGET_IS_mipspe) \

    || defined(TARGET_IS_armpe) \

    || defined(TARGET_IS_arm_epoc_pe) \

    || defined(TARGET_IS_arm_wince_pe)

#define DLL_SUPPORT

#endif

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

#define PE_DEF_SUBSYSTEM                3

#else

#undef NT_EXE_IMAGE_BASE

#undef PE_DEF_SECTION_ALIGNMENT

#undef PE_DEF_FILE_ALIGNMENT

#define NT_EXE_IMAGE_BASE               0x00010000

#if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)

#define PE_DEF_SECTION_ALIGNMENT        0x00001000

#define PE_DEF_SUBSYSTEM                9

#else

#define PE_DEF_SECTION_ALIGNMENT        0x00000400

#define PE_DEF_SUBSYSTEM                2

#endif

#define PE_DEF_FILE_ALIGNMENT           0x00000200

#endif

#define U(S) ${INITIAL_SYMBOL_CHAR} S

static struct internal_extra_pe_aouthdr pe;

static int dll;

static flagword real_flags = 0;

static int support_old_code = 0;

static char * thumb_entry_symbol = NULL;

static lang_assignment_statement_type *image_base_statement = 0;

#ifdef DLL_SUPPORT

static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable.  */

static char *pe_out_def_filename = NULL;

static char *pe_implib_filename = NULL;

static int pe_enable_auto_image_base = 0;

static char *pe_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 = -1;

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

#if defined TARGET_IS_mipspe || defined TARGET_IS_armpe || defined TARGET_IS_arm_wince_pe

  lang_default_entry ("WinMainCRTStartup");

#else

  lang_default_entry ("_WinMainCRTStartup");

#endif

#else

  lang_default_entry ("${ENTRY}");

#endif

#endif

}

/* PE format extra command line options.  */

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

#define OPTION_BASE_FILE                (300  + 1)

#define OPTION_DLL                      (OPTION_BASE_FILE + 1)

#define OPTION_FILE_ALIGNMENT           (OPTION_DLL + 1)

#define OPTION_IMAGE_BASE               (OPTION_FILE_ALIGNMENT + 1)

#define OPTION_MAJOR_IMAGE_VERSION      (OPTION_IMAGE_BASE + 1)

#define OPTION_MAJOR_OS_VERSION         (OPTION_MAJOR_IMAGE_VERSION + 1)

#define OPTION_MAJOR_SUBSYSTEM_VERSION  (OPTION_MAJOR_OS_VERSION + 1)

#define OPTION_MINOR_IMAGE_VERSION      (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)

#define OPTION_MINOR_OS_VERSION         (OPTION_MINOR_IMAGE_VERSION + 1)

#define OPTION_MINOR_SUBSYSTEM_VERSION  (OPTION_MINOR_OS_VERSION + 1)

#define OPTION_SECTION_ALIGNMENT        (OPTION_MINOR_SUBSYSTEM_VERSION + 1)

#define OPTION_STACK                    (OPTION_SECTION_ALIGNMENT + 1)

#define OPTION_SUBSYSTEM                (OPTION_STACK + 1)

#define OPTION_HEAP                     (OPTION_SUBSYSTEM + 1)

#define OPTION_SUPPORT_OLD_CODE         (OPTION_HEAP + 1)

#define OPTION_OUT_DEF                  (OPTION_SUPPORT_OLD_CODE + 1)

#define OPTION_EXPORT_ALL               (OPTION_OUT_DEF + 1)

#define OPTION_EXCLUDE_SYMBOLS          (OPTION_EXPORT_ALL + 1)

#define OPTION_KILL_ATS                 (OPTION_EXCLUDE_SYMBOLS + 1)

#define OPTION_STDCALL_ALIASES          (OPTION_KILL_ATS + 1)

#define OPTION_ENABLE_STDCALL_FIXUP     (OPTION_STDCALL_ALIASES + 1)

#define OPTION_DISABLE_STDCALL_FIXUP    (OPTION_ENABLE_STDCALL_FIXUP + 1)

#define OPTION_IMPLIB_FILENAME          (OPTION_DISABLE_STDCALL_FIXUP + 1)

#define OPTION_THUMB_ENTRY              (OPTION_IMPLIB_FILENAME + 1)

#define OPTION_WARN_DUPLICATE_EXPORTS   (OPTION_THUMB_ENTRY + 1)

#define OPTION_IMP_COMPAT               (OPTION_WARN_DUPLICATE_EXPORTS + 1)

#define OPTION_ENABLE_AUTO_IMAGE_BASE   (OPTION_IMP_COMPAT + 1)

#define OPTION_DISABLE_AUTO_IMAGE_BASE  (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)

#define OPTION_DLL_SEARCH_PREFIX        (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)

#define OPTION_NO_DEFAULT_EXCLUDES      (OPTION_DLL_SEARCH_PREFIX + 1)

#define OPTION_DLL_ENABLE_AUTO_IMPORT   (OPTION_NO_DEFAULT_EXCLUDES + 1)

#define OPTION_DLL_DISABLE_AUTO_IMPORT  (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)

#define OPTION_ENABLE_EXTRA_PE_DEBUG    (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)

#define OPTION_EXCLUDE_LIBS             (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)

#define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC  \

                                        (OPTION_EXCLUDE_LIBS + 1)

#define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \

                                        (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)

#define OPTION_LARGE_ADDRESS_AWARE \

                                        (OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC + 1)

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},

    {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},

#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},

    {"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-pe-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},

#endif

    {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE},

    {NULL, no_argument, NULL, 0}

  };

  *longopts = (struct option *)

    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;

  int value;

  char *symbol;

  int inited;

} definfo;

#define D(field,symbol,def)  {&pe.field,sizeof(pe.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, U ("__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__", 1),

  D(MinorImageVersion,"__minor_image_version__", 0),

#if defined(TARGET_IS_armpe)  || defined(TARGET_IS_arm_wince_pe)

  D(MajorSubsystemVersion,"__major_subsystem_version__", 3),

#else

  D(MajorSubsystemVersion,"__major_subsystem_version__", 4),

#endif

  D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),

  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),

  { 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"));

  fprintf (file, _("  --thumb-entry=             Set the entry point to be Thumb \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, _("  --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-pe-debug            Enable verbose debug output when building\n\

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

#endif

  fprintf (file, _("  --large-address-aware              Executable supports virtual addresses\n\

                                       greater than 2 gigabytes\n"));

}

static void

set_pe_name (char *name, long 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_pe_name (U ("__ImageBase"), val);

          return;

        }

    }

  abort ();

}

static void

set_pe_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_pe_name ("__major_subsystem_version__",

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

      if (*end == '.')

        set_pe_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_pe_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_pe_value (char *name)

{

  char *end;

  set_pe_name (name,  strtoul (optarg, &end, 0));

  if (end == optarg)

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

  optarg = end;

}

static void

set_pe_stack_heap (char *resname, char *comname)

{

  set_pe_value (resname);

  if (*optarg == ',')

    {

      optarg++;

      set_pe_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_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");

      break;

    case OPTION_STACK:

      set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");

      break;

    case OPTION_SUBSYSTEM:

      set_pe_subsystem ();

      break;

    case OPTION_MAJOR_OS_VERSION:

      set_pe_value ("__major_os_version__");

      break;

    case OPTION_MINOR_OS_VERSION:

      set_pe_value ("__minor_os_version__");

      break;

    case OPTION_MAJOR_SUBSYSTEM_VERSION:

      set_pe_value ("__major_subsystem_version__");

      break;

    case OPTION_MINOR_SUBSYSTEM_VERSION:

      set_pe_value ("__minor_subsystem_version__");

      break;

    case OPTION_MAJOR_IMAGE_VERSION:

      set_pe_value ("__major_image_version__");

      break;

    case OPTION_MINOR_IMAGE_VERSION:

      set_pe_value ("__minor_image_version__");

      break;

    case OPTION_FILE_ALIGNMENT:

      set_pe_value ("__file_alignment__");

      break;

    case OPTION_SECTION_ALIGNMENT:

      set_pe_value ("__section_alignment__");

      break;

    case OPTION_DLL:

      set_pe_name ("__dll__", 1);

      break;

    case OPTION_IMAGE_BASE:

      set_pe_value ("__image_base__");

      break;

    case OPTION_SUPPORT_OLD_CODE:

      support_old_code = 1;

      break;

    case OPTION_THUMB_ENTRY:

      thumb_entry_symbol = optarg;

      break;

#ifdef DLL_SUPPORT

    case OPTION_OUT_DEF:

      pe_out_def_filename = xstrdup (optarg);

      break;

    case OPTION_EXPORT_ALL:

      pe_dll_export_everything = 1;

      break;

    case OPTION_EXCLUDE_SYMBOLS:

      pe_dll_add_excludes (optarg, 0);

      break;

    case OPTION_EXCLUDE_LIBS:

      pe_dll_add_excludes (optarg, 1);

      break;

    case OPTION_KILL_ATS:

      pe_dll_kill_ats = 1;

      break;

    case OPTION_STDCALL_ALIASES:

      pe_dll_stdcall_aliases = 1;

      break;

    case OPTION_ENABLE_STDCALL_FIXUP:

      pe_enable_stdcall_fixup = 1;

      break;

    case OPTION_DISABLE_STDCALL_FIXUP:

      pe_enable_stdcall_fixup = 0;

      break;

    case OPTION_IMPLIB_FILENAME:

      pe_implib_filename = xstrdup (optarg);

      break;

    case OPTION_WARN_DUPLICATE_EXPORTS:

      pe_dll_warn_dup_exports = 1;

      break;

    case OPTION_IMP_COMPAT:

      pe_dll_compat_implib = 1;

      break;

    case OPTION_ENABLE_AUTO_IMAGE_BASE:

      pe_enable_auto_image_base = 1;

      break;

    case OPTION_DISABLE_AUTO_IMAGE_BASE:

      pe_enable_auto_image_base = 0;

      break;

    case OPTION_DLL_SEARCH_PREFIX:

      pe_dll_search_prefix = xstrdup (optarg);

      break;

    case OPTION_NO_DEFAULT_EXCLUDES:

      pe_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 = 1;

      break;

    case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:

      link_info.pei386_runtime_pseudo_reloc = 0;

      break;

    case OPTION_ENABLE_EXTRA_PE_DEBUG:

      pe_dll_extra_pe_debug = 1;

      break;

#endif

    case OPTION_LARGE_ADDRESS_AWARE:

      real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;

      break;

    }

  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 unsigned long

compute_dll_image_base (const char *ofile)

{

  unsigned long hash = 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;

  lang_statement_list_type *save;

  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 = (pe_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.  */

  save = stat_ptr;

  stat_ptr = &(abs_output_section->children);

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

    {

      long 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 = val;

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

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

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

        *(long *) init[j].ptr = 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.  */

  stat_ptr = save;

  if (pe.FileAlignment >

      pe.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)

{

  /* The Windows libraries are designed for the linker to treat the

     entry point as an undefined symbol.  Otherwise, the .obj that

     defines mainCRTStartup is brought in because it is the first

     encountered in libc.lib and it has other symbols in it which will

     be pulled in by the link process.  To avoid this, we act as

     though the user specified -u with the entry point symbol.

     This function is called after the linker script and command line

     options have been read, so at this point we know the right entry

     point.  This function is called before the input files are

     opened, so registering the symbol as undefined will make a

     difference.  */

  if (! link_info.relocatable && entry_symbol.name != NULL)

    ldlang_add_undef (entry_symbol.name);

}

/* pe-dll.c directly accesses pe_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 * pe_data_import_dll;

#ifdef DLL_SUPPORT

static struct bfd_link_hash_entry *pe_undef_found_sym;

static bfd_boolean

pe_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] == '@')

    {

      pe_undef_found_sym = h;

      return FALSE;

    }

  return TRUE;

}

static void

pe_fixup_stdcalls (void)

{

  static int gave_warning_message = 0;

  struct bfd_link_hash_entry *undef, *sym;

  if (pe_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 (pe_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.  */

            pe_undef_found_sym = 0;

            bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,

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

            sym = pe_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 (pe_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[4];

  if (pe_dll_extra_pe_debug)

    printf ("arelent: %s@%#lx: add=%li\n", sym->name,

            (long) rel->address, (long) rel->addend);

  if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))

    einfo (_("%C: Cannot get section contents - auto-import exception\n"),

           s->owner, s, rel->address);

  pe_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));

  return 1;

}

static void

pe_find_data_imports (void)

{

  struct bfd_link_hash_entry *undef, *sym;

  if (link_info.pei386_auto_import == 0)

    return;

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

    {

      if (undef->type == bfd_link_hash_undefined)

        {

          /* C++ symbols are *long*.  */

          char buf[4096];

          if (pe_dll_extra_pe_debug)

            printf ("%s:%s\n", __FUNCTION__, undef->root.string);

          sprintf (buf, "__imp_%s", undef->root.string);

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

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

            {

              bfd *b = sym->u.def.section->owner;

              asymbol **symbols;

              int nsyms, symsize, i;

              if (link_info.pei386_auto_import == -1)

                {

                  static bfd_boolean warned = FALSE;

                  info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),

                            undef->root.string, buf);

                  /* PR linker/4844.  */

                  if (! warned)

                    {