]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blobdiff - ld/pe-dll.c
[gdb/build] Cleanup gdb/features/feature_to_c.sh
[thirdparty/binutils-gdb.git] / ld / pe-dll.c
index 85bf2a7b35c6c5af75c6581d8e25c8b8b2a8a7ae..95eef84f607681fb1f534bccb4939accbbc0cd37 100644 (file)
@@ -1,6 +1,5 @@
 /* Routines to help build PEI-format DLLs (Win32 etc)
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
-   2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+   Copyright (C) 1998-2024 Free Software Foundation, Inc.
    Written by DJ Delorie <dj@cygnus.com>
 
    This file is part of the GNU Binutils.
@@ -26,6 +25,7 @@
 #include "libiberty.h"
 #include "filenames.h"
 #include "safe-ctype.h"
+#include "ctf-api.h"
 
 #include <time.h>
 
@@ -42,7 +42,7 @@
 #include "../bfd/libcoff.h"
 #include "deffile.h"
 
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
 
 #define PE_IDATA4_SIZE 8
 #define PE_IDATA5_SIZE 8
     should run in parallel with addresses vector (FirstThunk), i.e. that they
     should have same number of elements and terminated with zero. We violate
     this, since FirstThunk points directly into machine code. But in practice,
-    OS loader implemented the sane way: it goes thru OriginalFirstThunk and
+    OS loader implemented the sane way: it goes through OriginalFirstThunk and
     puts addresses to FirstThunk, not something else. It once again should be
     noted that dll and symbol name structures are reused across fixup entries
     and should be there anyway to support standard import stuff, so sustained
@@ -160,6 +160,7 @@ int pe_dll_extra_pe_debug = 0;
 int pe_use_nul_prefixed_import_tables = 0;
 int pe_use_coff_long_section_names = -1;
 int pe_leading_underscore = -1;
+int pe_dll_enable_reloc_section = 1;
 
 /* Static variables and types.  */
 
@@ -167,9 +168,10 @@ static bfd_vma image_base;
 static bfd *filler_bfd;
 static struct bfd_section *edata_s, *reloc_s;
 static unsigned char *edata_d, *reloc_d;
-static size_t edata_sz, reloc_sz;
+static unsigned char *reloc_d = NULL;
+static size_t edata_sz, reloc_sz = 0;
 static int runtime_pseudo_relocs_created = 0;
-static int runtime_pseudp_reloc_v2_init = 0;
+static bool runtime_pseudp_reloc_v2_init = false;
 
 typedef struct
 {
@@ -185,7 +187,7 @@ typedef struct
   unsigned int imagebase_reloc;
   int pe_arch;
   int bfd_arch;
-  bfd_boolean underscored;
+  bool underscored;
   const autofilter_entry_type* autofilter_symbollist;
 }
 pe_details_type;
@@ -208,7 +210,7 @@ static const autofilter_entry_type autofilter_symbollist_i386[] =
   { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
   /* Entry point symbols, and entry hooks.  */
   { STRING_COMMA_LEN ("cygwin_crt0") },
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
   { STRING_COMMA_LEN ("DllMain") },
   { STRING_COMMA_LEN ("DllEntryPoint") },
   { STRING_COMMA_LEN ("DllMainCRTStartup") },
@@ -236,6 +238,7 @@ static const autofilter_entry_type autofilter_symbollist_i386[] =
   { STRING_COMMA_LEN ("_impure_ptr") },
   { STRING_COMMA_LEN ("_fmode") },
   { STRING_COMMA_LEN ("environ") },
+  { STRING_COMMA_LEN ("__dso_handle") },
   { NULL, 0 }
 };
 
@@ -243,15 +246,15 @@ static const autofilter_entry_type autofilter_symbollist_i386[] =
 #define PE_ARCH_sh      2
 #define PE_ARCH_mips    3
 #define PE_ARCH_arm     4
-#define PE_ARCH_arm_epoc 5
-#define PE_ARCH_arm_wince 6
+#define PE_ARCH_arm_wince 5
+#define PE_ARCH_aarch64  6
 
 /* Don't make it constant as underscore mode gets possibly overriden
    by target or -(no-)leading-underscore option.  */
 static pe_details_type pe_detail_list[] =
 {
   {
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
     "pei-x86-64",
     "pe-x86-64",
     3 /* R_IMAGEBASE */,
@@ -262,20 +265,41 @@ static pe_details_type pe_detail_list[] =
 #endif
     PE_ARCH_i386,
     bfd_arch_i386,
-#ifdef pe_use_x86_64
-    FALSE,
+#ifdef pe_use_plus
+    false,
 #else
-    TRUE,
+    true,
 #endif
     autofilter_symbollist_i386
   },
+#ifdef pe_use_plus
+  {
+    "pei-x86-64",
+    "pe-bigobj-x86-64",
+    3 /* R_IMAGEBASE */,
+    PE_ARCH_i386,
+    bfd_arch_i386,
+    false,
+    autofilter_symbollist_i386
+  },
+#else
+  {
+    "pei-i386",
+    "pe-bigobj-i386",
+    7 /* R_IMAGEBASE */,
+    PE_ARCH_i386,
+    bfd_arch_i386,
+    true,
+    autofilter_symbollist_i386
+  },
+#endif
   {
     "pei-shl",
     "pe-shl",
     16 /* R_SH_IMAGEBASE */,
     PE_ARCH_sh,
     bfd_arch_sh,
-    TRUE,
+    true,
     autofilter_symbollist_generic
   },
   {
@@ -284,7 +308,7 @@ static pe_details_type pe_detail_list[] =
     34 /* MIPS_R_RVA */,
     PE_ARCH_mips,
     bfd_arch_mips,
-    FALSE,
+    false,
     autofilter_symbollist_generic
   },
   {
@@ -293,16 +317,7 @@ static pe_details_type pe_detail_list[] =
     11 /* ARM_RVA32 */,
     PE_ARCH_arm,
     bfd_arch_arm,
-    TRUE,
-    autofilter_symbollist_generic
-  },
-  {
-    "epoc-pei-arm-little",
-    "epoc-pe-arm-little",
-    11 /* ARM_RVA32 */,
-    PE_ARCH_arm_epoc,
-    bfd_arch_arm,
-    FALSE,
+    true,
     autofilter_symbollist_generic
   },
   {
@@ -311,10 +326,19 @@ static pe_details_type pe_detail_list[] =
     2,  /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c.  */
     PE_ARCH_arm_wince,
     bfd_arch_arm,
-    FALSE,
+    false,
     autofilter_symbollist_generic
   },
-  { NULL, NULL, 0, 0, 0, FALSE, NULL }
+  {
+    "pei-aarch64-little",
+    "pe-aarch64-little",
+    2,  /* ARM64_RVA32 */
+    PE_ARCH_aarch64,
+    bfd_arch_aarch64,
+    false,
+    autofilter_symbollist_generic
+  },
+  { NULL, NULL, 0, 0, 0, false, NULL }
 };
 
 static const pe_details_type *pe_details;
@@ -333,6 +357,10 @@ static const autofilter_entry_type autofilter_liblist[] =
   { STRING_COMMA_LEN ("libsupc++") },
   { STRING_COMMA_LEN ("libobjc") },
   { STRING_COMMA_LEN ("libgcj") },
+  { STRING_COMMA_LEN ("libmsvcrt") },
+  { STRING_COMMA_LEN ("libmsvcrt-os") },
+  { STRING_COMMA_LEN ("libucrt") },
+  { STRING_COMMA_LEN ("libucrtbase") },
   { NULL, 0 }
 };
 
@@ -423,12 +451,12 @@ pe_dll_id_target (const char *target)
          bfd_get_target_info (target, NULL, NULL, &u, NULL);
        if (u == -1)
          abort ();
-       pe_detail_list[i].underscored = (u != 0 ? TRUE : FALSE);
+       pe_detail_list[i].underscored = u != 0;
        pe_details = pe_detail_list + i;
        pe_leading_underscore = (u != 0 ? 1 : 0);
        return;
       }
-  einfo (_("%XUnsupported PEI architecture: %s\n"), target);
+  einfo (_("%X%P: unsupported PEI architecture: %s\n"), target);
   exit (1);
 }
 
@@ -440,16 +468,25 @@ typedef struct
     bfd_vma vma;
     char type;
     short extra;
+    int idx;
   }
 reloc_data_type;
 
 static int
 reloc_sort (const void *va, const void *vb)
 {
-  bfd_vma a = ((const reloc_data_type *) va)->vma;
-  bfd_vma b = ((const reloc_data_type *) vb)->vma;
+  const reloc_data_type *a = (const reloc_data_type *) va;
+  const reloc_data_type *b = (const reloc_data_type *) vb;
 
-  return (a > b) ? 1 : ((a < b) ? -1 : 0);
+  if (a->vma > b->vma)
+    return 1;
+  if (a->vma < b->vma)
+    return -1;
+  if (a->idx > b->idx)
+    return 1;
+  if (a->idx < b->idx)
+    return -1;
+  return 0;
 }
 
 static int
@@ -479,7 +516,7 @@ static int export_table_size;
 static int count_exported;
 static int count_exported_byname;
 static int count_with_ordinals;
-static const char *dll_name;
+static const char *dll_filename;
 static int min_ordinal, max_ordinal;
 static int *exported_symbols;
 
@@ -517,10 +554,10 @@ pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
   free (local_copy);
 }
 
-static bfd_boolean
+static bool
 is_import (const char* n)
 {
-  return (CONST_STRNEQ (n, "__imp_"));
+  return (startswith (n, "__imp_"));
 }
 
 /* abfd is a bfd containing n (or NULL)
@@ -535,13 +572,14 @@ auto_export (bfd *abfd, def_file *d, const char *n)
   const char * libname = NULL;
 
   if (abfd && abfd->my_archive)
-    libname = lbasename (abfd->my_archive->filename);
+    libname = lbasename (bfd_get_filename (abfd->my_archive));
 
   key.name = key.its_name = (char *) n;
 
   /* Return false if n is in the d->exports table.  */
-  if (bsearch (&key, d->exports, d->num_exports,
-               sizeof (pe_def_file->exports[0]), pe_export_sort))
+  if (d->num_exports != 0
+      && bsearch (&key, d->exports, d->num_exports,
+                 sizeof (pe_def_file->exports[0]), pe_export_sort))
     return 0;
 
   if (pe_dll_do_default_excludes)
@@ -569,7 +607,7 @@ auto_export (bfd *abfd, def_file *d, const char *n)
 
       /* Next, exclude symbols from certain startup objects.  */
 
-      if (abfd && (p = lbasename (abfd->filename)))
+      if (abfd && (p = lbasename (bfd_get_filename (abfd))))
        {
          afptr = autofilter_objlist;
          while (afptr->name)
@@ -630,7 +668,7 @@ auto_export (bfd *abfd, def_file *d, const char *n)
        }
       else if (ex->type == EXCLUDEFORIMPLIB)
        {
-         if (filename_cmp (abfd->filename, ex->string) == 0)
+         if (filename_cmp (bfd_get_filename (abfd), ex->string) == 0)
            return 0;
        }
       else if (strcmp (n, ex->string) == 0)
@@ -644,18 +682,19 @@ static void
 process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
 {
   int i, j;
+  unsigned int ui;
   struct bfd_link_hash_entry *blhe;
   bfd *b;
   struct bfd_section *s;
   def_file_export *e = 0;
-  bfd_boolean resort_needed;
+  bool resort_needed;
 
   if (!pe_def_file)
     pe_def_file = def_file_empty ();
 
   /* First, run around to all the objects looking for the .drectve
      sections, and push those into the def file too.  */
-  for (b = info->input_bfds; b; b = b->link_next)
+  for (b = info->input_bfds; b; b = b->link.next)
     {
       s = bfd_get_section_by_name (b, ".drectve");
       if (s)
@@ -681,9 +720,9 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
        {
          struct coff_link_hash_entry *sym_hash;
          sym_hash = coff_link_hash_lookup (coff_hash_table (info),
-               ac->symbol_name, FALSE, FALSE, FALSE);
+                                           ac->symbol_name, false, false, false);
          if (sym_hash && sym_hash->root.type == bfd_link_hash_common
-           && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
+             && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
            {
              sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
            }
@@ -691,9 +730,18 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
        }
     }
 
+  if (pe_def_file->exclude_symbols)
+    {
+      for (ui = 0; ui < pe_def_file->num_exclude_symbols; ui++)
+       {
+         pe_dll_add_excludes (pe_def_file->exclude_symbols[ui].symbol_name,
+                              EXCLUDESYMS);
+       }
+    }
+
   /* If we are building an executable and there is nothing
      to export, we do not build an export table at all.  */
-  if (info->executable && pe_def_file->num_exports == 0
+  if (bfd_link_executable (info) && pe_def_file->num_exports == 0
       && (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
     return;
 
@@ -701,14 +749,14 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
   if ((pe_dll_export_everything || pe_def_file->num_exports == 0)
       && !pe_dll_exclude_all_symbols)
     {
-      for (b = info->input_bfds; b; b = b->link_next)
+      for (b = info->input_bfds; b; b = b->link.next)
        {
          asymbol **symbols;
          int nsyms;
 
          if (!bfd_generic_link_read_symbols (b))
            {
-             einfo (_("%B%F: could not read symbols: %E\n"), b);
+             einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
              return;
            }
 
@@ -720,13 +768,14 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
              /* We should export symbols which are either global or not
                 anything at all.  (.bss data is the latter)
                 We should not export undefined symbols.  */
-             bfd_boolean would_export = symbols[j]->section != &bfd_und_section
-                     && ((symbols[j]->flags & BSF_GLOBAL)
-                         || (symbols[j]->flags == 0));
+             bool would_export
+               = (symbols[j]->section != bfd_und_section_ptr
+                  && ((symbols[j]->flags & BSF_GLOBAL)
+                      || (symbols[j]->flags == 0)));
              if (link_info.version_info && would_export)
-                 would_export
-                   = !bfd_hide_sym_by_version (link_info.version_info,
-                                               symbols[j]->name);
+               would_export
+                 = !bfd_hide_sym_by_version (link_info.version_info,
+                                             symbols[j]->name);
              if (would_export)
                {
                  const char *sn = symbols[j]->name;
@@ -735,13 +784,13 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
                  {
                    char *name;
                    if (is_import (sn))
-                         continue;
+                     continue;
 
                    name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
                    sprintf (name, "%s%s", "__imp_", sn);
 
                    blhe = bfd_link_hash_lookup (info->hash, name,
-                                                FALSE, FALSE, FALSE);
+                                                false, false, false);
                    free (name);
 
                    if (blhe && blhe->type == bfd_link_hash_defined)
@@ -753,14 +802,14 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
 
                  if (auto_export (b, pe_def_file, sn))
                    {
-                     int is_dup = 0;
+                     bool is_dup = false;
                      def_file_export *p;
 
                      p = def_file_add_export (pe_def_file, sn, 0, -1,
                                               NULL, &is_dup);
                      /* Fill data flag properly, from dlltool.c.  */
                      if (!is_dup)
-                       p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
+                       p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
                    }
                }
            }
@@ -774,29 +823,32 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
   if (NE == 0)
     return;
 
-  resort_needed = FALSE;
+  resort_needed = false;
 
   /* Canonicalize the export list.  */
   if (pe_dll_kill_ats)
     {
       for (i = 0; i < NE; i++)
        {
-         if (strchr (pe_def_file->exports[i].name, '@'))
+         /* Check for fastcall/stdcall-decoration, but ignore
+            C++ mangled names.  */
+         if (pe_def_file->exports[i].name[0] != '?'
+             && strchr (pe_def_file->exports[i].name, '@'))
            {
              /* This will preserve internal_name, which may have been
                 pointing to the same memory as name, or might not
                 have.  */
              int lead_at = (*pe_def_file->exports[i].name == '@');
              char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
-             char *tmp_at = strchr (tmp, '@');
+             char *tmp_at = strrchr (tmp, '@');
 
              if (tmp_at)
-               *tmp_at = 0;
+               *tmp_at = 0;
              else
-               einfo (_("%XCannot export %s: invalid export name\n"),
+               einfo (_("%X%P: cannot export %s: invalid export name\n"),
                       pe_def_file->exports[i].name);
              pe_def_file->exports[i].name = tmp;
-              resort_needed = TRUE;
+             resort_needed = true;
            }
        }
     }
@@ -805,7 +857,7 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
      by removing leading @.  */
   if (resort_needed)
     qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
-           pe_export_sort);
+          pe_export_sort);
 
   if (pe_dll_stdcall_aliases)
     {
@@ -816,7 +868,7 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
 
          if (strchr (pe_def_file->exports[i].name, '@'))
            {
-             int is_dup = 1;
+             bool is_dup = true;
              int lead_at = (*pe_def_file->exports[i].name == '@');
              char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
 
@@ -826,7 +878,7 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
                                     pe_def_file->exports[i].internal_name,
                                     -1, NULL, &is_dup);
              if (is_dup)
-               free (tmp);
+               free (tmp);
            }
        }
     }
@@ -845,14 +897,14 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
            {
              if (pe_dll_warn_dup_exports)
                /* xgettext:c-format */
-               einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
+               einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
                       e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
            }
          else
            {
              if (pe_dll_warn_dup_exports)
                /* xgettext:c-format */
-               einfo (_("Warning, duplicate EXPORT: %s\n"),
+               einfo (_("%P: warning, duplicate EXPORT: %s\n"),
                       e[j - 1].name);
            }
 
@@ -862,12 +914,9 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
          e[j - 1].flag_constant |= e[i].flag_constant;
          e[j - 1].flag_noname |= e[i].flag_noname;
          e[j - 1].flag_data |= e[i].flag_data;
-         if (e[i].name)
-           free (e[i].name);
-         if (e[i].internal_name)
-           free (e[i].internal_name);
-         if (e[i].its_name)
-           free (e[i].its_name);
+         free (e[i].name);
+         free (e[i].internal_name);
+         free (e[i].its_name);
        }
       else
        {
@@ -890,20 +939,27 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
 
   for (i = 0; i < NE; i++)
     {
+      char *int_name = pe_def_file->exports[i].internal_name;
       char *name;
-      name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
-      if (pe_details->underscored
-         && (*pe_def_file->exports[i].internal_name != '@'))
+
+      /* PR 19803: Make sure that any exported symbol does not get garbage collected.  */
+      lang_add_gc_name (int_name);
+
+      name = xmalloc (strlen (int_name) + 2);
+      if (pe_details->underscored && int_name[0] != '@')
        {
          *name = '_';
-         strcpy (name + 1, pe_def_file->exports[i].internal_name);
+         strcpy (name + 1, int_name);
+
+         /* PR 19803: The alias must be preserved as well.  */
+         lang_add_gc_name (xstrdup (name));
        }
       else
-       strcpy (name, pe_def_file->exports[i].internal_name);
+       strcpy (name, int_name);
 
       blhe = bfd_link_hash_lookup (info->hash,
                                   name,
-                                  FALSE, FALSE, TRUE);
+                                  false, false, true);
 
       if (blhe
          && (blhe->type == bfd_link_hash_defined
@@ -931,11 +987,11 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
            }
        }
       /* Check for forward exports.  These are indicated in DEF files by an
-         export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
+        export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
         but we must take care not to be fooled when the user wants to export
         a symbol that actually really has a dot in it, so we only check
         for them here, after real defined symbols have already been matched.  */
-      else if (strchr (pe_def_file->exports[i].internal_name, '.'))
+      else if (strchr (int_name, '.'))
        {
          count_exported++;
          if (!pe_def_file->exports[i].flag_noname)
@@ -955,21 +1011,21 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
       else if (blhe && blhe->type == bfd_link_hash_undefined)
        {
          /* xgettext:c-format */
-         einfo (_("%XCannot export %s: symbol not defined\n"),
-                pe_def_file->exports[i].internal_name);
+         einfo (_("%X%P: cannot export %s: symbol not defined\n"),
+                int_name);
        }
       else if (blhe)
        {
          /* xgettext:c-format */
-         einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
-                pe_def_file->exports[i].internal_name,
+         einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
+                int_name,
                 blhe->type, bfd_link_hash_defined);
        }
       else
        {
          /* xgettext:c-format */
-         einfo (_("%XCannot export %s: symbol not found\n"),
-                pe_def_file->exports[i].internal_name);
+         einfo (_("%X%P: cannot export %s: symbol not found\n"),
+                int_name);
        }
       free (name);
     }
@@ -978,9 +1034,10 @@ process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *
 /* Build the bfd that will contain .edata and .reloc sections.  */
 
 static void
-build_filler_bfd (int include_edata)
+build_filler_bfd (bool include_edata)
 {
   lang_input_statement_type *filler_file;
+
   filler_file = lang_add_input_file ("dll stuff",
                                     lang_input_file_is_fake_enum,
                                     NULL);
@@ -991,7 +1048,7 @@ build_filler_bfd (int include_edata)
                             bfd_get_arch (link_info.output_bfd),
                             bfd_get_mach (link_info.output_bfd)))
     {
-      einfo ("%X%P: can not create BFD: %E\n");
+      einfo (_("%F%P: can not create BFD: %E\n"));
       return;
     }
 
@@ -999,33 +1056,31 @@ build_filler_bfd (int include_edata)
     {
       edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
       if (edata_s == NULL
-         || !bfd_set_section_flags (filler_bfd, edata_s,
-                                    (SEC_HAS_CONTENTS
-                                     | SEC_ALLOC
-                                     | SEC_LOAD
-                                     | SEC_KEEP
-                                     | SEC_IN_MEMORY)))
+         || !bfd_set_section_flags (edata_s, (SEC_HAS_CONTENTS
+                                              | SEC_ALLOC
+                                              | SEC_LOAD
+                                              | SEC_KEEP
+                                              | SEC_IN_MEMORY)))
        {
-         einfo ("%X%P: can not create .edata section: %E\n");
+         einfo (_("%X%P: can not create .edata section: %E\n"));
          return;
        }
-      bfd_set_section_size (filler_bfd, edata_s, edata_sz);
+      bfd_set_section_size (edata_s, edata_sz);
     }
 
   reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
   if (reloc_s == NULL
-      || !bfd_set_section_flags (filler_bfd, reloc_s,
-                                (SEC_HAS_CONTENTS
-                                 | SEC_ALLOC
-                                 | SEC_LOAD
-                                 | SEC_KEEP
-                                 | SEC_IN_MEMORY)))
-    {
-      einfo ("%X%P: can not create .reloc section: %E\n");
+      || !bfd_set_section_flags (reloc_s, (SEC_HAS_CONTENTS
+                                          | SEC_ALLOC
+                                          | SEC_LOAD
+                                          | SEC_KEEP
+                                          | SEC_IN_MEMORY)))
+    {
+      einfo (_("%X%P: can not create .reloc section: %E\n"));
       return;
     }
 
-  bfd_set_section_size (filler_bfd, reloc_s, 0);
+  bfd_set_section_size (reloc_s, 0);
 
   ldlang_add_file (filler_file);
 }
@@ -1033,25 +1088,13 @@ build_filler_bfd (int include_edata)
 /* Gather all the exported symbols and build the .edata section.  */
 
 static void
-generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
+generate_edata (void)
 {
   int i, next_ordinal;
   int name_table_size = 0;
-  const char *dlnp;
 
   /* First, we need to know how many exported symbols there are,
      and what the range of ordinals is.  */
-  if (pe_def_file->name)
-    dll_name = pe_def_file->name;
-  else
-    {
-      dll_name = abfd->filename;
-
-      for (dlnp = dll_name; *dlnp; dlnp++)
-       if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
-         dll_name = dlnp + 1;
-    }
-
   if (count_with_ordinals && max_ordinal > count_exported)
     {
       if (min_ordinal > max_ordinal - count_exported + 1)
@@ -1071,8 +1114,8 @@ generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
   /* Now we need to assign ordinals to those that don't have them.  */
   for (i = 0; i < NE; i++)
     {
-      if (exported_symbol_sections[i] ||
-          pe_def_file->exports[i].flag_forward)
+      if (exported_symbol_sections[i]
+         || pe_def_file->exports[i].flag_forward)
        {
          if (pe_def_file->exports[i].ordinal != -1)
            {
@@ -1082,7 +1125,7 @@ generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
              if (pi != -1)
                {
                  /* xgettext:c-format */
-                 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
+                 einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
                         pe_def_file->exports[i].ordinal,
                         pe_def_file->exports[i].name,
                         pe_def_file->exports[pi].name);
@@ -1104,9 +1147,9 @@ generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
 
   next_ordinal = min_ordinal;
   for (i = 0; i < NE; i++)
-    if ((exported_symbol_sections[i] ||
-         pe_def_file->exports[i].flag_forward) &&
-        pe_def_file->exports[i].ordinal == -1)
+    if ((exported_symbol_sections[i]
+        || pe_def_file->exports[i].flag_forward)
+       && pe_def_file->exports[i].ordinal == -1)
       {
        while (exported_symbols[next_ordinal - min_ordinal] != -1)
          next_ordinal++;
@@ -1115,12 +1158,18 @@ generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
        pe_def_file->exports[i].ordinal = next_ordinal;
       }
 
+  /* PR 12969: Check for more than 1^16 ordinals.  */
+  if (max_ordinal > 65535 || next_ordinal > 65535)
+    /* xgettext:c-format */
+    einfo(_("%X%P: error: export ordinal too large: %d\n"),
+         max_ordinal > next_ordinal ? max_ordinal : next_ordinal);
+
   /* OK, now we can allocate some memory.  */
   edata_sz = (40                               /* directory */
              + 4 * export_table_size           /* addresses */
              + 4 * count_exported_byname       /* name ptrs */
              + 2 * count_exported_byname       /* ordinals */
-             + name_table_size + strlen (dll_name) + 1);
+             + name_table_size + strlen (dll_filename) + 1);
 }
 
 /* Fill the exported symbol offsets. The preliminary work has already
@@ -1138,7 +1187,7 @@ fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
 
       name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
       if (pe_details->underscored
-         && *pe_def_file->exports[i].internal_name != '@')
+         && *pe_def_file->exports[i].internal_name != '@')
        {
          *name = '_';
          strcpy (name + 1, pe_def_file->exports[i].internal_name);
@@ -1148,7 +1197,7 @@ fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
 
       blhe = bfd_link_hash_lookup (info->hash,
                                   name,
-                                  FALSE, FALSE, TRUE);
+                                  false, false, true);
 
       if (blhe && blhe->type == bfd_link_hash_defined)
        exported_symbol_offsets[i] = blhe->u.def.value;
@@ -1166,9 +1215,6 @@ fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
   unsigned char *enameptrs;
   unsigned char *eordinals;
   char *enamestr;
-  time_t now;
-
-  time (&now);
 
   edata_d = xmalloc (edata_sz);
 
@@ -1183,7 +1229,15 @@ fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
                   + edata_s->output_section->vma - image_base)
 
   memset (edata_d, 0, edata_sz);
-  bfd_put_32 (abfd, now, edata_d + 4);
+
+  if (pe_data (abfd)->timestamp == -1)
+    {
+      time_t now = bfd_get_current_time (0);
+      H_PUT_32 (abfd, now, edata_d + 4);
+    }
+  else
+    H_PUT_32 (abfd, pe_data (abfd)->timestamp, edata_d + 4);
+
   if (pe_def_file->version_major != -1)
     {
       bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
@@ -1191,7 +1245,7 @@ fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
     }
 
   bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
-  strcpy (enamestr, dll_name);
+  strcpy (enamestr, dll_filename);
   enamestr += strlen (enamestr) + 1;
   bfd_put_32 (abfd, min_ordinal, edata_d + 16);
   bfd_put_32 (abfd, export_table_size, edata_d + 20);
@@ -1206,21 +1260,21 @@ fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
      Scan alphabetically - ie the ordering in the exports[] table,
      rather than by ordinal - the ordering in the exported_symbol[]
      table.  See dlltool.c and:
-        http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
+       http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
      for more information.  */
   hint = 0;
   for (s = 0; s < NE; s++)
     {
       struct bfd_section *ssec = exported_symbol_sections[s];
-      if (pe_def_file->exports[s].ordinal != -1 &&
-          (pe_def_file->exports[s].flag_forward || ssec != NULL))
+      if (pe_def_file->exports[s].ordinal != -1
+         && (pe_def_file->exports[s].flag_forward || ssec != NULL))
        {
          int ord = pe_def_file->exports[s].ordinal;
 
          if (pe_def_file->exports[s].flag_forward)
            {
              bfd_put_32 (abfd, ERVA (enamestr),
-                         eaddresses + 4 * (ord - min_ordinal));
+                         eaddresses + 4 * (ord - min_ordinal));
 
              strcpy (enamestr, pe_def_file->exports[s].internal_name);
              enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
@@ -1232,7 +1286,7 @@ fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
                                    + ssec->output_offset);
 
              bfd_put_32 (abfd, srva - image_base,
-                         eaddresses + 4 * (ord - min_ordinal));
+                         eaddresses + 4 * (ord - min_ordinal));
            }
 
          if (!pe_def_file->exports[s].flag_noname)
@@ -1256,21 +1310,23 @@ fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
 
 static struct bfd_section *current_sec;
 
-void
-pe_walk_relocs_of_symbol (struct bfd_link_info *info,
-                         const char *name,
-                         int (*cb) (arelent *, asection *))
+static void
+pe_walk_relocs (struct bfd_link_info *info,
+               char *name,
+               const char *symname,
+               struct bfd_hash_table *import_hash,
+               void (*cb) (arelent *, asection *, char *, const char *))
 {
   bfd *b;
   asection *s;
 
-  for (b = info->input_bfds; b; b = b->link_next)
+  for (b = info->input_bfds; b; b = b->link.next)
     {
       asymbol **symbols;
 
       if (!bfd_generic_link_read_symbols (b))
        {
-         einfo (_("%B%F: could not read symbols: %E\n"), b);
+         einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
          return;
        }
 
@@ -1280,7 +1336,7 @@ pe_walk_relocs_of_symbol (struct bfd_link_info *info,
        {
          arelent **relocs;
          int relsize, nrelocs, i;
-         int flags = bfd_get_section_flags (b, s);
+         int flags = bfd_section_flags (s);
 
          /* Skip discarded linkonce sections.  */
          if (flags & SEC_LINK_ONCE
@@ -1297,8 +1353,20 @@ pe_walk_relocs_of_symbol (struct bfd_link_info *info,
            {
              struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
 
-             if (!strcmp (name, sym->name))
-               cb (relocs[i], s);
+             /* Warning: the callback needs to be passed NAME directly.  */
+             if (import_hash)
+               {
+                 if (bfd_hash_lookup (import_hash, sym->name, false, false))
+                   {
+                     strcpy (name, sym->name);
+                     cb (relocs[i], s, name, symname);
+                   }
+               }
+             else
+               {
+                 if (strcmp (name, sym->name) == 0)
+                   cb (relocs[i], s, name, symname);
+               }
            }
 
          free (relocs);
@@ -1310,66 +1378,212 @@ pe_walk_relocs_of_symbol (struct bfd_link_info *info,
     }
 }
 
+void
+pe_find_data_imports (const char *symhead,
+                     void (*cb) (arelent *, asection *, char *, const char *))
+{
+  struct bfd_link_hash_entry *undef;
+  const size_t headlen = strlen (symhead);
+  size_t namelen = 0;
+  char *buf, *name;
+  struct bfd_hash_table *import_hash;
+
+  for (undef = link_info.hash->undefs; undef; undef = undef->u.undef.next)
+    if (undef->type == bfd_link_hash_undefined)
+      {
+       size_t len = strlen (undef->root.string);
+       if (namelen < len)
+         namelen = len;
+      }
+  if (namelen == 0)
+    return;
+
+  /* For the pseudo-relocation support version 2, we can collect the symbols
+     that are subject to auto-import and adjust the relocations en masse.  */
+  if (link_info.pei386_runtime_pseudo_reloc == 2)
+    {
+      import_hash
+       = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
+      if (!bfd_hash_table_init (import_hash,
+                               bfd_hash_newfunc,
+                               sizeof (struct bfd_hash_entry)))
+       einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
+    }
+  else
+    import_hash = NULL;
+
+  /* We are being a bit cunning here.  The buffer will have space for
+     prefixes at the beginning.  The prefix is modified here and in a
+     number of functions called from this function.  */
+#define PREFIX_LEN 32
+  buf = xmalloc (PREFIX_LEN + namelen + 1);
+  name = buf + PREFIX_LEN;
+
+  for (undef = link_info.hash->undefs; undef; undef = undef->u.undef.next)
+    if (undef->type == bfd_link_hash_undefined)
+      {
+       struct bfd_link_hash_entry *sym;
+       char *impname;
+
+       if (pe_dll_extra_pe_debug)
+         printf ("%s:%s\n", __func__, undef->root.string);
+
+       strcpy (name, undef->root.string);
+       impname = name - (sizeof "__imp_" - 1);
+       memcpy (impname, "__imp_", sizeof "__imp_" - 1);
+
+       sym = bfd_link_hash_lookup (link_info.hash, impname, 0, 0, 1);
+
+       if (sym && sym->type == bfd_link_hash_defined)
+         {
+           if (import_hash)
+             bfd_hash_lookup (import_hash, undef->root.string, true, false);
+           else
+             {
+               bfd *b = sym->u.def.section->owner;
+               const char *symname = NULL;
+               asymbol **symbols;
+               int nsyms, i;
+
+               if (!bfd_generic_link_read_symbols (b))
+                 {
+                   einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
+                   return;
+                 }
+
+               symbols = bfd_get_outsymbols (b);
+               nsyms = bfd_get_symcount (b);
+
+               for (i = 0; i < nsyms; i++)
+                 if (strncmp (symbols[i]->name, symhead, headlen) == 0)
+                   {
+                     if (pe_dll_extra_pe_debug)
+                       printf ("->%s\n", symbols[i]->name);
+
+                     symname = symbols[i]->name + headlen;
+                     break;
+                   }
+
+               /* If the symobl isn't part of an import table, there is no
+                  point in building a fixup, this would give rise to link
+                  errors for mangled symbols instead of the original one.  */
+               if (symname)
+                 pe_walk_relocs (&link_info, name, symname, NULL, cb);
+               else
+                 continue;
+             }
+
+           /* Let's differentiate it somehow from defined.  */
+           undef->type = bfd_link_hash_defweak;
+           undef->u.def.value = sym->u.def.value;
+           undef->u.def.section = sym->u.def.section;
+
+           /* We replace the original name with the __imp_ prefixed one, this
+              1) may trash memory 2) leads to duplicate symbols.  But this is
+              better than having a misleading name that can confuse GDB.  */
+           undef->root.string = sym->root.string;
+
+           if (link_info.pei386_auto_import == -1)
+             {
+               static bool warned = false;
+
+               info_msg (_("Info: resolving %s by linking to %s "
+                           "(auto-import)\n"), name, impname);
+
+               /* PR linker/4844.  */
+               if (!warned)
+                 {
+                   einfo (_("%P: warning: auto-importing has been activated "
+                            "without --enable-auto-import specified on the "
+                            "command line; this should work unless it "
+                            "involves constant data structures referencing "
+                            "symbols from auto-imported DLLs\n"));
+                   warned = true;
+                 }
+             }
+         }
+      }
+
+  /* If we have the import hash table, walk the relocations only once.  */
+  if (import_hash)
+    {
+      pe_walk_relocs (&link_info, name, NULL, import_hash, cb);
+      bfd_hash_table_free (import_hash);
+      free (import_hash);
+    }
+
+  free (buf);
+}
+
 /* Gather all the relocations and build the .reloc section.  */
 
 static void
 generate_reloc (bfd *abfd, struct bfd_link_info *info)
 {
-
   /* For .reloc stuff.  */
   reloc_data_type *reloc_data;
   int total_relocs = 0;
   int i;
   bfd_vma sec_page = (bfd_vma) -1;
-  bfd_vma page_ptr, page_count;
-  int bi;
+  bfd_vma page_ptr;
   bfd *b;
   struct bfd_section *s;
 
+  if (reloc_s == NULL || reloc_s->output_section == bfd_abs_section_ptr)
+    return;
+
+  /* Set an upper bound for the total number of relocations we will have to generate.  */
   total_relocs = 0;
-  for (b = info->input_bfds; b; b = b->link_next)
+  for (b = info->input_bfds; b; b = b->link.next)
     for (s = b->sections; s; s = s->next)
       total_relocs += s->reloc_count;
 
   reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
 
   total_relocs = 0;
-  bi = 0;
-  for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
+  for (b = info->input_bfds; b; b = b->link.next)
     {
       arelent **relocs;
       int relsize, nrelocs;
+      asymbol **symbols;
+
+      if (!bfd_generic_link_read_symbols (b))
+       {
+         einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
+         return;
+       }
+
+      symbols = bfd_get_outsymbols (b);
 
       for (s = b->sections; s; s = s->next)
        {
-         bfd_vma sec_vma = s->output_section->vma + s->output_offset;
-         asymbol **symbols;
+         bfd_vma sec_vma;
 
-         /* If it's not loaded, we don't need to relocate it this way.  */
-         if (!(s->output_section->flags & SEC_LOAD))
-           continue;
+         /* If the section is not going to be output, then ignore it.  */
+         if (s->output_section == NULL)
+           {
+             /* FIXME: This should not happen.  Convert to the correct
+                form here, but really, this should be investigated.  */
+             s->output_section = bfd_abs_section_ptr;
+             continue;
+           }
 
          /* I don't know why there would be a reloc for these, but I've
             seen it happen - DJ  */
-         if (s->output_section == &bfd_abs_section)
+         if (s->output_section == bfd_abs_section_ptr)
+           continue;
+
+         /* If it's not loaded, we don't need to relocate it this way.  */
+         if (!(s->output_section->flags & SEC_LOAD))
            continue;
 
+         /* This happens when linking with --just-symbols=<file>
+            so do not generate an error.  */
          if (s->output_section->vma == 0)
-           {
-             /* Huh?  Shouldn't happen, but punt if it does.  */
-             einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
-                    s->output_section->name, s->output_section->index,
-                    s->output_section->flags);
-             continue;
-           }
+           continue;
 
-         if (!bfd_generic_link_read_symbols (b))
-           {
-             einfo (_("%B%F: could not read symbols: %E\n"), b);
-             return;
-           }
+         sec_vma = s->output_section->vma + s->output_offset;
 
-         symbols = bfd_get_outsymbols (b);
          relsize = bfd_get_reloc_upper_bound (b, s);
          relocs = xmalloc (relsize);
          nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
@@ -1385,13 +1599,13 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
                  && relocs[i]->howto->type != pe_details->imagebase_reloc)
                {
                  struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
+                 const struct bfd_link_hash_entry *blhe
+                   = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
+                                                   false, false, false);
 
                  /* Don't create relocs for undefined weak symbols.  */
                  if (sym->flags == BSF_WEAK)
                    {
-                     struct bfd_link_hash_entry *blhe
-                       = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
-                                               FALSE, FALSE, FALSE);
                      if (blhe && blhe->type == bfd_link_hash_undefweak)
                        {
                          /* Check aux sym and see if it is defined or not. */
@@ -1400,7 +1614,7 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
                          if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
                            continue;
                          h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
-                                               [h->aux->x_sym.x_tagndx.l];
+                                               [h->aux->x_sym.x_tagndx.u32];
                          /* We don't want a base reloc if the aux sym is not
                             found, undefined, or if it is the constant ABS
                             zero default value.  (We broaden that slightly by
@@ -1408,7 +1622,7 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
                             no reason we'd want a reference to any absolute
                             address to get relocated during rebasing).  */
                          if (!h2 || h2->root.type == bfd_link_hash_undefined
-                               || h2->root.u.def.section == &bfd_abs_section)
+                               || h2->root.u.def.section == bfd_abs_section_ptr)
                            continue;
                        }
                      else if (!blhe || blhe->type != bfd_link_hash_defined)
@@ -1423,30 +1637,46 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
                      if (!strcmp (s->name, ".eh_frame"))
                        continue;
                    }
+                 /* Nor for absolute symbols.  */
+                 else if (blhe && ldexp_is_final_sym_absolute (blhe)
+                          && (!blhe->linker_def
+                              || (strcmp (sym->name, "__image_base__")
+                                  && strcmp (sym->name, U ("__ImageBase")))))
+                   continue;
 
                  reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
+                 reloc_data[total_relocs].idx = total_relocs;
+
+                 /* Since we're only about to determine .reloc's size,
+                    subsequent output section VMA calculations will shift up
+                    sections at this or higher addresses.  Relocations for
+                    such sections would hence end up not being correct.  */
+                 if (reloc_data[total_relocs].vma
+                     >= reloc_s->output_section->vma)
+                   einfo (_("%P: base relocation for section `%s' above "
+                            ".reloc section\n"), s->output_section->name);
 
 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
 
                  switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
                                         relocs[i]->howto->rightshift)
                    {
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
                    case BITS_AND_SHIFT (64, 0):
-                     reloc_data[total_relocs].type = 10;
+                     reloc_data[total_relocs].type = IMAGE_REL_BASED_DIR64;
                      total_relocs++;
                      break;
 #endif
                    case BITS_AND_SHIFT (32, 0):
-                     reloc_data[total_relocs].type = 3;
+                     reloc_data[total_relocs].type = IMAGE_REL_BASED_HIGHLOW;
                      total_relocs++;
                      break;
                    case BITS_AND_SHIFT (16, 0):
-                     reloc_data[total_relocs].type = 2;
+                     reloc_data[total_relocs].type = IMAGE_REL_BASED_LOW;
                      total_relocs++;
                      break;
                    case BITS_AND_SHIFT (16, 16):
-                     reloc_data[total_relocs].type = 4;
+                     reloc_data[total_relocs].type = IMAGE_REL_BASED_HIGHADJ;
                      /* FIXME: we can't know the symbol's right value
                         yet, but we probably can safely assume that
                         CE will relocate us in 64k blocks, so leaving
@@ -1455,7 +1685,8 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
                      total_relocs++;
                      break;
                    case BITS_AND_SHIFT (26, 2):
-                     reloc_data[total_relocs].type = 5;
+                     reloc_data[total_relocs].type =
+                        IMAGE_REL_BASED_ARM_MOV32;
                      total_relocs++;
                      break;
                    case BITS_AND_SHIFT (24, 2):
@@ -1472,18 +1703,23 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
                      /* Fall through.  */
                    default:
                      /* xgettext:c-format */
-                     einfo (_("%XError: %d-bit reloc in dll\n"),
+                     einfo (_("%X%P: error: %d-bit reloc in dll\n"),
                             relocs[i]->howto->bitsize);
                      break;
                    }
                }
            }
+
          free (relocs);
          /* Warning: the allocated symbols are remembered in BFD and
             reused later, so don't free them!  */
        }
     }
 
+  /* This can happen for example when LTO has eliminated all code.  */
+  if (total_relocs == 0)
+    return;
+  
   /* At this point, we have total_relocs relocation addresses in
      reloc_addresses, which are all suitable for the .reloc section.
      We must now create the new sections.  */
@@ -1502,16 +1738,15 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
 
       reloc_sz += 2;
 
-      if (reloc_data[i].type == 4)
+      if (reloc_data[i].type == IMAGE_REL_BASED_HIGHADJ)
        reloc_sz += 2;
     }
 
   reloc_sz = (reloc_sz + 3) & ~3;      /* 4-byte align.  */
   reloc_d = xmalloc (reloc_sz);
-  sec_page = (bfd_vma) -1;
+
+  page_ptr = sec_page = (bfd_vma) -1;
   reloc_sz = 0;
-  page_ptr = (bfd_vma) -1;
-  page_count = 0;
 
   for (i = 0; i < total_relocs; i++)
     {
@@ -1530,20 +1765,17 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
          page_ptr = reloc_sz;
          reloc_sz += 8;
          sec_page = this_page;
-         page_count = 0;
        }
 
       bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
                  reloc_d + reloc_sz);
       reloc_sz += 2;
 
-      if (reloc_data[i].type == 4)
+      if (reloc_data[i].type == IMAGE_REL_BASED_HIGHADJ)
        {
          bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
          reloc_sz += 2;
        }
-
-      page_count++;
     }
 
   while (reloc_sz & 3)
@@ -1551,9 +1783,6 @@ generate_reloc (bfd *abfd, struct bfd_link_info *info)
 
   if (page_ptr != (bfd_vma) -1)
     bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
-
-  while (reloc_sz < reloc_s->size)
-    reloc_d[reloc_sz++] = 0;
 }
 
 /* Given the exiting def_file structure, print out a .DEF file that
@@ -1600,8 +1829,8 @@ pe_dll_generate_def_file (const char *pe_out_def_filename)
 
   if (out == NULL)
     /* xgettext:c-format */
-    einfo (_("%s: Can't open output def file %s\n"),
-          program_name, pe_out_def_filename);
+    einfo (_("%P: can't open output def file %s\n"),
+          pe_out_def_filename);
 
   if (pe_def_file)
     {
@@ -1615,10 +1844,8 @@ pe_dll_generate_def_file (const char *pe_out_def_filename)
          quoteput (pe_def_file->name, out, 1);
 
          if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
-           {
-             fprintf (out, " BASE=0x");
-             fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
-           }
+           fprintf (out, " BASE=0x%" PRIx64,
+                    (uint64_t) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase);
          fprintf (out, "\n");
        }
 
@@ -1755,7 +1982,7 @@ pe_dll_generate_def_file (const char *pe_out_def_filename)
 
   if (fclose (out) == EOF)
     /* xgettext:c-format */
-    einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
+    einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename);
 }
 
 /* Generate the import library.  */
@@ -1763,11 +1990,9 @@ pe_dll_generate_def_file (const char *pe_out_def_filename)
 static asymbol **symtab;
 static int symptr;
 static int tmp_seq;
-static int tmp_seq2;
-static const char *dll_filename;
 static char *dll_symname;
 
-#define UNDSEC (asection *) &bfd_und_section
+#define UNDSEC bfd_und_section_ptr
 
 static asection *
 quick_section (bfd *abfd, const char *name, int flags, int align)
@@ -1776,8 +2001,8 @@ quick_section (bfd *abfd, const char *name, int flags, int align)
   asymbol *sym;
 
   sec = bfd_make_section_old_way (abfd, name);
-  bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
-  bfd_set_section_alignment (abfd, sec, align);
+  bfd_set_section_flags (sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
+  bfd_set_section_alignment (sec, align);
   /* Remember to undo this before trying to link internally!  */
   sec->output_section = sec;
 
@@ -1852,20 +2077,20 @@ save_relocs (asection *sec)
 }
 
 /*     .section        .idata$2
-       .global         __head_my_dll
+       .global         __head_my_dll
    __head_my_dll:
-       .rva            hname
-       .long           0
-       .long           0
-       .rva            __my_dll_iname
-       .rva            fthunk
-
-       .section        .idata$5
-       .long           0
+       .rva            hname
+       .long           0
+       .long           0
+       .rva            __my_dll_iname
+       .rva            fthunk
+
+       .section        .idata$5
+       .long           0
    fthunk:
 
-       .section        .idata$4
-       .long           0
+       .section        .idata$4
+       .long           0
    hname:                              */
 
 static bfd *
@@ -1876,11 +2101,16 @@ make_head (bfd *parent)
   char *oname;
   bfd *abfd;
 
-  oname = xmalloc (20);
-  sprintf (oname, "d%06d.o", tmp_seq);
+  if (asprintf (&oname, "%s_d%06d.o", dll_symname, tmp_seq) < 4)
+    /* In theory we should return NULL here at let our caller decide what to
+       do.  But currently the return value is not checked, just used, and
+       besides, this condition only happens when the system has run out of
+       memory.  So just give up.  */
+    exit (EXIT_FAILURE);
   tmp_seq++;
 
   abfd = bfd_create (oname, parent);
+  free (oname);
   bfd_find_target (pe_details->object_target, abfd);
   bfd_make_writable (abfd);
 
@@ -1901,7 +2131,7 @@ make_head (bfd *parent)
      pointer to the list points to the *end* of this section, which is
      the start of the list of sections from other objects.  */
 
-  bfd_set_section_size (abfd, id2, 20);
+  bfd_set_section_size (id2, 20);
   d2 = xmalloc (20);
   id2->contents = d2;
   memset (d2, 0, 20);
@@ -1913,16 +2143,16 @@ make_head (bfd *parent)
   save_relocs (id2);
 
   if (pe_use_nul_prefixed_import_tables)
-    bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+    bfd_set_section_size (id5, PE_IDATA5_SIZE);
   else
-    bfd_set_section_size (abfd, id5, 0);
+    bfd_set_section_size (id5, 0);
   d5 = xmalloc (PE_IDATA5_SIZE);
   id5->contents = d5;
   memset (d5, 0, PE_IDATA5_SIZE);
   if (pe_use_nul_prefixed_import_tables)
-    bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+    bfd_set_section_size (id4, PE_IDATA4_SIZE);
   else
-    bfd_set_section_size (abfd, id4, 0);
+    bfd_set_section_size (id4, 0);
   d4 = xmalloc (PE_IDATA4_SIZE);
   id4->contents = d4;
   memset (d4, 0, PE_IDATA4_SIZE);
@@ -1946,15 +2176,15 @@ make_head (bfd *parent)
 }
 
 /*     .section        .idata$4
-       .long           0
+       .long           0
        [.long          0] for PE+
-       .section        .idata$5
-       .long           0
+       .section        .idata$5
+       .long           0
        [.long          0] for PE+
-       .section        idata$7
-       .global         __my_dll_iname
+       .section        idata$7
+       .global         __my_dll_iname
   __my_dll_iname:
-       .asciz          "my.dll"       */
+       .asciz          "my.dll"       */
 
 static bfd *
 make_tail (bfd *parent)
@@ -1965,11 +2195,16 @@ make_tail (bfd *parent)
   char *oname;
   bfd *abfd;
 
-  oname = xmalloc (20);
-  sprintf (oname, "d%06d.o", tmp_seq);
+  if (asprintf (&oname, "%s_d%06d.o", dll_symname, tmp_seq) < 4)
+    /* In theory we should return NULL here at let our caller decide what to
+       do.  But currently the return value is not checked, just used, and
+       besides, this condition only happens when the system has run out of
+       memory.  So just give up.  */
+    exit (EXIT_FAILURE);
   tmp_seq++;
 
   abfd = bfd_create (oname, parent);
+  free (oname);
   bfd_find_target (pe_details->object_target, abfd);
   bfd_make_writable (abfd);
 
@@ -1983,12 +2218,12 @@ make_tail (bfd *parent)
   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
   quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
 
-  bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+  bfd_set_section_size (id4, PE_IDATA4_SIZE);
   d4 = xmalloc (PE_IDATA4_SIZE);
   id4->contents = d4;
   memset (d4, 0, PE_IDATA4_SIZE);
 
-  bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+  bfd_set_section_size (id5, PE_IDATA5_SIZE);
   d5 = xmalloc (PE_IDATA5_SIZE);
   id5->contents = d5;
   memset (d5, 0, PE_IDATA5_SIZE);
@@ -1996,7 +2231,7 @@ make_tail (bfd *parent)
   len = strlen (dll_filename) + 1;
   if (len & 1)
     len++;
-  bfd_set_section_size (abfd, id7, len);
+  bfd_set_section_size (id7, len);
   d7 = xmalloc (len);
   id7->contents = d7;
   strcpy ((char *) d7, dll_filename);
@@ -2016,37 +2251,45 @@ make_tail (bfd *parent)
 }
 
 /*     .text
-       .global         _function
-       .global         ___imp_function
-       .global         __imp__function
+       .global         _function
+       .global         ___imp_function
+       .global         __imp__function
   _function:
-       jmp             *__imp__function:
+       jmp             *__imp__function:
 
-       .section        idata$7
-       .long           __head_my_dll
+       .section        idata$7
+       .long           __head_my_dll
 
-       .section        .idata$5
+       .section        .idata$5
   ___imp_function:
   __imp__function:
   iat?
-       .section        .idata$4
+       .section        .idata$4
   iat?
-       .section        .idata$6
+       .section        .idata$6
   ID<ordinal>:
-       .short          <hint>
-       .asciz          "function" xlate? (add underscore, kill at)  */
+       .short          <hint>
+       .asciz          "function" xlate? (add underscore, kill at)  */
 
 static const unsigned char jmp_ix86_bytes[] =
 {
   0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
 };
 
+static const unsigned char jmp_aarch64_bytes[] =
+{
+  0x10, 0x00, 0x00, 0x90, /* adrp x16, 0        */
+  0x10, 0x02, 0x00, 0x91, /* add x16, x16, #0x0 */
+  0x10, 0x02, 0x40, 0xf9, /* ldr x16, [x16]     */
+  0x00, 0x02, 0x1f, 0xd6  /* br x16             */
+};
+
 /* _function:
-       mov.l   ip+8,r0
-       mov.l   @r0,r0
-       jmp     @r0
-       nop
-       .dw     __imp_function   */
+       mov.l   ip+8,r0
+       mov.l   @r0,r0
+       jmp     @r0
+       nop
+       .dw     __imp_function   */
 
 static const unsigned char jmp_sh_bytes[] =
 {
@@ -2054,10 +2297,10 @@ static const unsigned char jmp_sh_bytes[] =
 };
 
 /* _function:
-       lui     $t0,<high:__imp_function>
-       lw      $t0,<low:__imp_function>
-       jr      $t0
-       nop                              */
+       lui     $t0,<high:__imp_function>
+       lw      $t0,<low:__imp_function>
+       jr      $t0
+       nop                              */
 
 static const unsigned char jmp_mips_bytes[] =
 {
@@ -2074,7 +2317,7 @@ static const unsigned char jmp_arm_bytes[] =
 
 
 static bfd *
-make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
+make_one (def_file_export *exp, bfd *parent, bool include_jmp_stub)
 {
   asection *tx, *id7, *id5, *id4, *id6;
   unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
@@ -2083,6 +2326,31 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
   bfd *abfd;
   const unsigned char *jmp_bytes = NULL;
   int jmp_byte_count = 0;
+  const char *internal_name = exp->internal_name;
+
+  if (!exp->flag_noname)
+    {
+      /* Check for a decorated symbol name */
+      struct decoration_hash_entry *entry;
+
+      entry = (struct decoration_hash_entry *)
+             bfd_hash_lookup (&(coff_hash_table (&link_info)->decoration_hash),
+                              internal_name, false, false);
+      if (entry)
+       {
+         if (entry->decorated_link)
+           {
+             internal_name = entry->decorated_link->root.string;
+
+             if (pe_details->underscored && internal_name[0] == '_')
+               internal_name++;
+           }
+         else
+           {
+             einfo (_("%P: error: NULL decorated name for %s\n"), internal_name);
+           }
+       }
+    }
 
   /* Include the jump stub section only if it is needed. A jump
      stub is needed if the symbol being imported <sym> is a function
@@ -2107,21 +2375,29 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
          jmp_byte_count = sizeof (jmp_mips_bytes);
          break;
        case PE_ARCH_arm:
-       case PE_ARCH_arm_epoc:
        case PE_ARCH_arm_wince:
          jmp_bytes = jmp_arm_bytes;
          jmp_byte_count = sizeof (jmp_arm_bytes);
          break;
+       case PE_ARCH_aarch64:
+         jmp_bytes = jmp_aarch64_bytes;
+         jmp_byte_count = sizeof (jmp_aarch64_bytes);
+         break;
        default:
          abort ();
        }
     }
 
-  oname = xmalloc (20);
-  sprintf (oname, "d%06d.o", tmp_seq);
+  if (asprintf (&oname, "%s_d%06d.o", dll_symname, tmp_seq) < 4)
+    /* In theory we should return NULL here at let our caller decide what to
+       do.  But currently the return value is not checked, just used, and
+       besides, this condition only happens when the system has run out of
+       memory.  So just give up.  */
+    exit (EXIT_FAILURE);
   tmp_seq++;
 
   abfd = bfd_create (oname, parent);
+  free (oname);
   bfd_find_target (pe_details->object_target, abfd);
   bfd_make_writable (abfd);
 
@@ -2137,13 +2413,13 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
   id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
 
-  if  (*exp->internal_name == '@')
+  if  (*internal_name == '@')
     {
       quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
                    BSF_GLOBAL, 0);
       if (include_jmp_stub)
-       quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
-      quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
+       quick_symbol (abfd, "", internal_name, "", tx, BSF_GLOBAL, 0);
+      quick_symbol (abfd, "__imp_", internal_name, "", id5,
                    BSF_GLOBAL, 0);
       /* Fastcall applies only to functions,
         so no need for auto-import symbol.  */
@@ -2153,23 +2429,23 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
       quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
                    BSF_GLOBAL, 0);
       if (include_jmp_stub)
-       quick_symbol (abfd, U (""), exp->internal_name, "", tx,
+       quick_symbol (abfd, U (""), internal_name, "", tx,
                      BSF_GLOBAL, 0);
-      quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
+      quick_symbol (abfd, "__imp_", U (""), internal_name, id5,
                    BSF_GLOBAL, 0);
       /* Symbol to reference ord/name of imported
         data symbol, used to implement auto-import.  */
       if (exp->flag_data)
-       quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
+       quick_symbol (abfd, "__nm_", U (""), internal_name, id6,
                      BSF_GLOBAL,0);
     }
   if (pe_dll_compat_implib)
-    quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
+    quick_symbol (abfd, "___imp_", internal_name, "", id5,
                  BSF_GLOBAL, 0);
 
   if (include_jmp_stub)
     {
-      bfd_set_section_size (abfd, tx, jmp_byte_count);
+      bfd_set_section_size (tx, jmp_byte_count);
       td = xmalloc (jmp_byte_count);
       tx->contents = td;
       memcpy (td, jmp_bytes, jmp_byte_count);
@@ -2177,13 +2453,13 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
       switch (pe_details->pe_arch)
        {
        case PE_ARCH_i386:
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
          quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
 #else
          /* Mark this object as SAFESEH compatible.  */
          quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
                        BSF_LOCAL, 1);
-          quick_reloc (abfd, 2, BFD_RELOC_32, 2);
+         quick_reloc (abfd, 2, BFD_RELOC_32, 2);
 #endif
          break;
        case PE_ARCH_sh:
@@ -2195,26 +2471,29 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
          quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
          break;
        case PE_ARCH_arm:
-       case PE_ARCH_arm_epoc:
-       case PE_ARCH_arm_wince:
+       case PE_ARCH_arm_wince:
          quick_reloc (abfd, 8, BFD_RELOC_32, 2);
          break;
+       case PE_ARCH_aarch64:
+         quick_reloc (abfd, 0, BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL, 2);
+         quick_reloc (abfd, 4, BFD_RELOC_AARCH64_ADD_LO12, 2);
+         break;
        default:
          abort ();
        }
       save_relocs (tx);
     }
   else
-    bfd_set_section_size (abfd, tx, 0);
+    bfd_set_section_size (tx, 0);
 
-  bfd_set_section_size (abfd, id7, 4);
+  bfd_set_section_size (id7, 4);
   d7 = xmalloc (4);
   id7->contents = d7;
   memset (d7, 0, 4);
   quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
   save_relocs (id7);
 
-  bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+  bfd_set_section_size (id5, PE_IDATA5_SIZE);
   d5 = xmalloc (PE_IDATA5_SIZE);
   id5->contents = d5;
   memset (d5, 0, PE_IDATA5_SIZE);
@@ -2231,7 +2510,7 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
       save_relocs (id5);
     }
 
-  bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+  bfd_set_section_size (id4, PE_IDATA4_SIZE);
   d4 = xmalloc (PE_IDATA4_SIZE);
   id4->contents = d4;
   memset (d4, 0, PE_IDATA4_SIZE);
@@ -2251,10 +2530,12 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
   if (exp->flag_noname)
     {
       len = 0;
-      bfd_set_section_size (abfd, id6, 0);
+      bfd_set_section_size (id6, 0);
     }
   else
     {
+      int ord;
+
       /* { short, asciz }  */
       if (exp->its_name)
        len = 2 + strlen (exp->its_name) + 1;
@@ -2262,12 +2543,17 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
        len = 2 + strlen (exp->name) + 1;
       if (len & 1)
        len++;
-      bfd_set_section_size (abfd, id6, len);
+      bfd_set_section_size (id6, len);
       d6 = xmalloc (len);
       id6->contents = d6;
       memset (d6, 0, len);
-      d6[0] = exp->hint & 0xff;
-      d6[1] = exp->hint >> 8;
+
+      /* PR 20880:  Use exp->hint as a backup, just in case exp->ordinal
+        contains an invalid value (-1).  */
+      ord = (exp->ordinal >= 0) ? exp->ordinal : exp->hint;
+      d6[0] = ord;
+      d6[1] = ord >> 8;
+
       if (exp->its_name)
        strcpy ((char*) d6 + 2, exp->its_name);
       else
@@ -2288,47 +2574,6 @@ make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
   return abfd;
 }
 
-static bfd *
-make_singleton_name_imp (const char *import, bfd *parent)
-{
-  /* Name thunks go to idata$4.  */
-  asection *id5;
-  unsigned char *d5;
-  char *oname;
-  bfd *abfd;
-
-  oname = xmalloc (20);
-  sprintf (oname, "nmimp%06d.o", tmp_seq2);
-  tmp_seq2++;
-
-  abfd = bfd_create (oname, parent);
-  bfd_find_target (pe_details->object_target, abfd);
-  bfd_make_writable (abfd);
-
-  bfd_set_format (abfd, bfd_object);
-  bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
-
-  symptr = 0;
-  symtab = xmalloc (3 * sizeof (asymbol *));
-  id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
-  quick_symbol (abfd, "__imp_", import, "", id5, BSF_GLOBAL, 0);
-
-  /* We need space for the real thunk and for the null terminator.  */
-  bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
-  d5 = xmalloc (PE_IDATA5_SIZE * 2);
-  id5->contents = d5;
-  memset (d5, 0, PE_IDATA5_SIZE * 2);
-  quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
-  save_relocs (id5);
-
-  bfd_set_symtab (abfd, symtab, symptr);
-
-  bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
-
-  bfd_make_readable (abfd);
-  return abfd;
-}
-
 static bfd *
 make_singleton_name_thunk (const char *import, bfd *parent)
 {
@@ -2338,11 +2583,16 @@ make_singleton_name_thunk (const char *import, bfd *parent)
   char *oname;
   bfd *abfd;
 
-  oname = xmalloc (20);
-  sprintf (oname, "nmth%06d.o", tmp_seq);
+  if (asprintf (&oname, "%s_nmth%06d.o", dll_symname, tmp_seq) < 4)
+    /* In theory we should return NULL here at let our caller decide what to
+       do.  But currently the return value is not checked, just used, and
+       besides, this condition only happens when the system has run out of
+       memory.  So just give up.  */
+    exit (EXIT_FAILURE);
   tmp_seq++;
 
   abfd = bfd_create (oname, parent);
+  free (oname);
   bfd_find_target (pe_details->object_target, abfd);
   bfd_make_writable (abfd);
 
@@ -2356,7 +2606,7 @@ make_singleton_name_thunk (const char *import, bfd *parent)
   quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
 
   /* We need space for the real thunk and for the null terminator.  */
-  bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
+  bfd_set_section_size (id4, PE_IDATA4_SIZE * 2);
   d4 = xmalloc (PE_IDATA4_SIZE * 2);
   id4->contents = d4;
   memset (d4, 0, PE_IDATA4_SIZE * 2);
@@ -2371,53 +2621,37 @@ make_singleton_name_thunk (const char *import, bfd *parent)
   return abfd;
 }
 
-static char *
-make_import_fixup_mark (arelent *rel)
+static const char *
+make_import_fixup_mark (arelent *rel, char *name)
 {
   /* We convert reloc to symbol, for later reference.  */
-  static int counter;
-  static char *fixup_name = NULL;
-  static size_t buffer_len = 0;
-
+  static unsigned int counter;
   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
-
   bfd *abfd = bfd_asymbol_bfd (sym);
   struct bfd_link_hash_entry *bh;
+  char *fixup_name, buf[256];
+  size_t prefix_len;
 
-  if (!fixup_name)
-    {
-      fixup_name = xmalloc (384);
-      buffer_len = 384;
-    }
-
-  if (strlen (sym->name) + 25 > buffer_len)
-  /* Assume 25 chars for "__fu" + counter + "_".  If counter is
-     bigger than 20 digits long, we've got worse problems than
-     overflowing this buffer...  */
-    {
-      free (fixup_name);
-      /* New buffer size is length of symbol, plus 25, but
-        then rounded up to the nearest multiple of 128.  */
-      buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
-      fixup_name = xmalloc (buffer_len);
-    }
-
-  sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
+  /* "name" buffer has space before the symbol name for prefixes.  */
+  sprintf (buf, "__fu%d_", counter++);
+  prefix_len = strlen (buf);
+  fixup_name = name - prefix_len;
+  memcpy (fixup_name, buf, prefix_len);
 
   bh = NULL;
   bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
                                current_sec, /* sym->section, */
-                               rel->address, NULL, TRUE, FALSE, &bh);
+                               rel->address, NULL, true, false, &bh);
 
-  return fixup_name;
+  return bh->root.string;
 }
 
 /*     .section        .idata$2
-       .rva            __nm_thnk_SYM (singleton thunk with name of func)
-       .long           0
-       .long           0
-       .rva            __my_dll_iname (name of dll)
-       .rva            __fuNN_SYM (pointer to reference (address) in text)  */
+       .rva            __nm_thnk_SYM (singleton thunk with name of func)
+       .long           0
+       .long           0
+       .rva            __my_dll_iname (name of dll)
+       .rva            __fuNN_SYM (pointer to reference (address) in text)  */
 
 static bfd *
 make_import_fixup_entry (const char *name,
@@ -2430,11 +2664,16 @@ make_import_fixup_entry (const char *name,
   char *oname;
   bfd *abfd;
 
-  oname = xmalloc (20);
-  sprintf (oname, "fu%06d.o", tmp_seq);
+  if (asprintf (&oname, "%s_fu%06d.o", dll_symname, tmp_seq) < 4)
+    /* In theory we should return NULL here at let our caller decide what to
+       do.  But currently the return value is not checked, just used, and
+       besides, this condition only happens when the system has run out of
+       memory.  So just give up.  */
+    exit (EXIT_FAILURE);
   tmp_seq++;
 
   abfd = bfd_create (oname, parent);
+  free (oname);
   bfd_find_target (pe_details->object_target, abfd);
   bfd_make_writable (abfd);
 
@@ -2447,14 +2686,9 @@ make_import_fixup_entry (const char *name,
 
   quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
   quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
-  /* For relocator v2 we have to use the .idata$5 element and not
-     fixup_name.  */
-  if (link_info.pei386_runtime_pseudo_reloc == 2)
-    quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
-  else
-    quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
+  quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
 
-  bfd_set_section_size (abfd, id2, 20);
+  bfd_set_section_size (id2, 20);
   d2 = xmalloc (20);
   id2->contents = d2;
   memset (d2, 0, 20);
@@ -2473,8 +2707,8 @@ make_import_fixup_entry (const char *name,
 }
 
 /*     .section        .rdata_runtime_pseudo_reloc
-       .long           addend
-       .rva            __fuNN_SYM (pointer to reference (address) in text)  */
+       .long           addend
+       .rva            __fuNN_SYM (pointer to reference (address) in text)  */
 
 static bfd *
 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
@@ -2487,59 +2721,72 @@ make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
   unsigned char *rt_rel_d;
   char *oname;
   bfd *abfd;
-  oname = xmalloc (20);
-  sprintf (oname, "rtr%06d.o", tmp_seq);
+  bfd_size_type size;
+
+  if (asprintf (&oname, "%s_rtr%06d.o", dll_symname, tmp_seq) < 4)
+    /* In theory we should return NULL here at let our caller decide what to
+       do.  But currently the return value is not checked, just used, and
+       besides, this condition only happens when the system has run out of
+       memory.  So just give up.  */
+    exit (EXIT_FAILURE);
   tmp_seq++;
 
   abfd = bfd_create (oname, parent);
+  free (oname);
   bfd_find_target (pe_details->object_target, abfd);
   bfd_make_writable (abfd);
 
   bfd_set_format (abfd, bfd_object);
   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
 
-  symptr = 0;
   if (link_info.pei386_runtime_pseudo_reloc == 2)
     {
-      symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
+      if (runtime_pseudp_reloc_v2_init)
+       size = 3 * sizeof (asymbol *);
+      else
+       size = 6 * sizeof (asymbol *);
     }
   else
-    {
-      symtab = xmalloc (2 * sizeof (asymbol *));
-    }
-  rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
-                         SEC_HAS_CONTENTS, 2);
+    size = 2 * sizeof (asymbol *);
+
+  symptr = 0;
+  symtab = xmalloc (size);
+
+  rt_rel
+    = quick_section (abfd, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS, 2);
+  bfd_coff_set_long_section_names (abfd, true);
 
   quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
 
   if (link_info.pei386_runtime_pseudo_reloc == 2)
     {
-         size_t size = 12;
-         if (! runtime_pseudp_reloc_v2_init)
-           {
-                 size += 12;
-                 runtime_pseudp_reloc_v2_init = 1;
-           }
+      size = 12;
+      if (!runtime_pseudp_reloc_v2_init)
+       {
+         size += 12;
+         runtime_pseudp_reloc_v2_init = true;
+       }
+
       quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
 
-      bfd_set_section_size (abfd, rt_rel, size);
+      bfd_set_section_size (rt_rel, size);
       rt_rel_d = xmalloc (size);
       rt_rel->contents = rt_rel_d;
       memset (rt_rel_d, 0, size);
-         quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
-         quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
-         bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
-         if (size != 12)
-           bfd_put_32 (abfd, 1, rt_rel_d + 8);
+      quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
+      quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
+      bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
+      if (size != 12)
+       bfd_put_32 (abfd, 1, rt_rel_d + 8);
       save_relocs (rt_rel);
 
       bfd_set_symtab (abfd, symtab, symptr);
 
       bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
-   }
+    }
   else
-   {
-      bfd_set_section_size (abfd, rt_rel, 8);
+    {
+      bfd_set_section_size (rt_rel, 8);
       rt_rel_d = xmalloc (8);
       rt_rel->contents = rt_rel_d;
       memset (rt_rel_d, 0, 8);
@@ -2553,12 +2800,13 @@ make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
 
       bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
    }
+
   bfd_make_readable (abfd);
   return abfd;
 }
 
 /*     .section        .rdata
-       .rva            __pei386_runtime_relocator  */
+       .rva            __pei386_runtime_relocator  */
 
 static bfd *
 pe_create_runtime_relocator_reference (bfd *parent)
@@ -2568,11 +2816,16 @@ pe_create_runtime_relocator_reference (bfd *parent)
   char *oname;
   bfd *abfd;
 
-  oname = xmalloc (20);
-  sprintf (oname, "ertr%06d.o", tmp_seq);
+  if (asprintf (&oname, "%s_ertr%06d.o", dll_symname, tmp_seq) < 4)
+    /* In theory we should return NULL here at let our caller decide what to
+       do.  But currently the return value is not checked, just used, and
+       besides, this condition only happens when the system has run out of
+       memory.  So just give up.  */
+    exit (EXIT_FAILURE);
   tmp_seq++;
 
   abfd = bfd_create (oname, parent);
+  free (oname);
   bfd_find_target (pe_details->object_target, abfd);
   bfd_make_writable (abfd);
 
@@ -2586,8 +2839,8 @@ pe_create_runtime_relocator_reference (bfd *parent)
   quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
                BSF_NO_FLAGS, 0);
 
-  bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
-  extern_rt_rel_d = xmalloc (PE_IDATA5_SIZE);
+  bfd_set_section_size (extern_rt_rel, PE_IDATA5_SIZE);
+  extern_rt_rel_d = xcalloc (1, PE_IDATA5_SIZE);
   extern_rt_rel->contents = extern_rt_rel_d;
 
   quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
@@ -2602,88 +2855,68 @@ pe_create_runtime_relocator_reference (bfd *parent)
 }
 
 void
-pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend)
+pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend, char *name,
+                       const char *symname)
 {
-  char buf[300];
-  struct bfd_symbol *sym = *rel->sym_ptr_ptr;
-  struct bfd_link_hash_entry *name_thunk_sym;
-  struct bfd_link_hash_entry *name_imp_sym;
-  const char *name = sym->name;
-  char *fixup_name = make_import_fixup_mark (rel);
+  const char *fixup_name = make_import_fixup_mark (rel, name);
   bfd *b;
-  int need_import_table = 1;
-
-  sprintf (buf, "__imp_%s", name);
-  name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
-
-  sprintf (buf, "__nm_thnk_%s", name);
-
-  name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
-
-  /* For version 2 pseudo relocation we don't need to add an import
-     if the import symbol is already present.  */
-  if (link_info.pei386_runtime_pseudo_reloc == 2
-      && name_imp_sym
-      && name_imp_sym->type == bfd_link_hash_defined)
-    need_import_table = 0;
-
-  if (need_import_table == 1
-      && (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined))
-    {
-      b = make_singleton_name_thunk (name, link_info.output_bfd);
-      add_bfd_to_link (b, b->filename, &link_info);
-
-      /* If we ever use autoimport, we have to cast text section writable.
-         But not for version 2.  */
-      if (link_info.pei386_runtime_pseudo_reloc != 2)
-        {
-          config.text_read_only = FALSE;
-          link_info.output_bfd->flags &= ~WP_TEXT;
-        }
-      if (link_info.pei386_runtime_pseudo_reloc == 2)
-        {
-         b = make_singleton_name_imp (name, link_info.output_bfd);
-          add_bfd_to_link (b, b->filename, &link_info);
-       }
-    }
 
-  if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
-      && need_import_table == 1)
+  /* This is the original implementation of the auto-import feature, which
+     primarily relied on the OS loader to patch things up with some help
+     from the pseudo-relocator to overcome the main limitation.  See the
+     comment at the beginning of the file for an overview of the feature.  */
+  if (link_info.pei386_runtime_pseudo_reloc != 2)
     {
-      extern char * pe_data_import_dll;
-      char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
+      struct bfd_link_hash_entry *name_thunk_sym;
+      /* name buffer is allocated with space at beginning for prefixes.  */
+      char *thname = name - (sizeof "__nm_thnk_" - 1);
+      memcpy (thname, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
+      name_thunk_sym = bfd_link_hash_lookup (link_info.hash, thname, 0, 0, 1);
 
-      b = make_import_fixup_entry (name, fixup_name, symname,
-                                  link_info.output_bfd);
-      add_bfd_to_link (b, b->filename, &link_info);
-    }
+      if (!(name_thunk_sym && name_thunk_sym->type == bfd_link_hash_defined))
+       {
+         b = make_singleton_name_thunk (name, link_info.output_bfd);
+         add_bfd_to_link (b, bfd_get_filename (b), &link_info);
 
-    if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
-        || link_info.pei386_runtime_pseudo_reloc == 2)
-      {
-       if (pe_dll_extra_pe_debug)
-         printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
-                 fixup_name, (int) addend);
+         /* If we ever use autoimport, we have to cast text section writable.  */
+         config.text_read_only = false;
+         link_info.output_bfd->flags &= ~WP_TEXT;
+       }
 
-       b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
+      if (addend == 0 || link_info.pei386_runtime_pseudo_reloc == 1)
+       {
+         b = make_import_fixup_entry (name, fixup_name, symname,
                                       link_info.output_bfd);
-       add_bfd_to_link (b, b->filename, &link_info);
+         add_bfd_to_link (b, bfd_get_filename (b), &link_info);
+       }
+    }
 
-       if (runtime_pseudo_relocs_created == 0)
-         {
-           b = pe_create_runtime_relocator_reference (link_info.output_bfd);
-           add_bfd_to_link (b, b->filename, &link_info);
-         }
-       runtime_pseudo_relocs_created++;
-      }
-    else if (addend != 0)
-      {
-       einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
-              s->owner, s, rel->address, sym->name);
-       einfo ("%X");
-      }
-}
+  /* In the original implementation, the pseudo-relocator was only used when
+     the addend was not null.  In the new implementation, the OS loader is
+     completely bypassed and the pseudo-relocator does the entire work.  */
+  if ((addend != 0 && link_info.pei386_runtime_pseudo_reloc == 1)
+      || link_info.pei386_runtime_pseudo_reloc == 2)
+    {
+      if (pe_dll_extra_pe_debug)
+       printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
+               fixup_name, (int) addend);
 
+      b = make_runtime_pseudo_reloc (name, fixup_name, addend,
+                                    rel->howto->bitsize,
+                                    link_info.output_bfd);
+      add_bfd_to_link (b, bfd_get_filename (b), &link_info);
+
+      if (runtime_pseudo_relocs_created++ == 0)
+       {
+         b = pe_create_runtime_relocator_reference (link_info.output_bfd);
+         add_bfd_to_link (b, bfd_get_filename (b), &link_info);
+       }
+    }
+
+  else if (addend != 0)
+    einfo (_("%X%P: %H: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
+          s->owner, s, rel->address, (*rel->sym_ptr_ptr)->name);
+}
 
 void
 pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
@@ -2695,12 +2928,6 @@ pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_
   bfd *ibfd;
   bfd *head = 0;
 
-  dll_filename = (def->name) ? def->name : dll_name;
-  dll_symname = xstrdup (dll_filename);
-  for (i = 0; dll_symname[i]; i++)
-    if (!ISALNUM (dll_symname[i]))
-      dll_symname[i] = '_';
-
   unlink_if_ordinary (impfilename);
 
   outarch = bfd_openw (impfilename, 0);
@@ -2708,12 +2935,13 @@ pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_
   if (!outarch)
     {
       /* xgettext:c-format */
-      einfo (_("%XCan't open .lib file: %s\n"), impfilename);
+      einfo (_("%X%P: can't open .lib file: %s\n"), impfilename);
       return;
     }
 
-  /* xgettext:c-format */
-  info_msg (_("Creating library file: %s\n"), impfilename);
+  if (verbose)
+    /* xgettext:c-format */
+    info_msg (_("Creating library file: %s\n"), impfilename);
 
   bfd_set_format (outarch, bfd_archive);
   outarch->has_armap = 1;
@@ -2722,7 +2950,7 @@ pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_
   ar_head = make_head (outarch);
 
   /* Iterate the input BFDs, looking for exclude-modules-for-implib.  */
-  for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next)
+  for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
     {
       /* Iterate the exclude list.  */
       struct exclude_list_struct *ex;
@@ -2731,18 +2959,19 @@ pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_
        {
          if (ex->type != EXCLUDEFORIMPLIB)
            continue;
-         found = (filename_cmp (ex->string, ibfd->filename) == 0);
+         found = (filename_cmp (ex->string, bfd_get_filename (ibfd)) == 0);
        }
       /* If it matched, we must open a fresh BFD for it (the original
-        input BFD is still needed for the DLL's final link) and add
-       it into the archive member chain.  */
+        input BFD is still needed for the DLL's final link) and add
+        it into the archive member chain.  */
       if (found)
        {
          bfd *newbfd = bfd_openr (ibfd->my_archive
-               ? ibfd->my_archive->filename : ibfd->filename, NULL);
+                                  ? bfd_get_filename (ibfd->my_archive)
+                                  : bfd_get_filename (ibfd), NULL);
          if (!newbfd)
            {
-             einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
+             einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd));
              return;
            }
          if (ibfd->my_archive)
@@ -2754,20 +2983,23 @@ pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_
              bfd *arbfd = newbfd;
              if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
                {
-                 einfo (_("%X%s(%s): can't find member in non-archive file"),
-                   ibfd->my_archive->filename, ibfd->filename);
+                 einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
+                        bfd_get_filename (ibfd->my_archive),
+                        bfd_get_filename (ibfd));
                  return;
                }
              newbfd = NULL;
              while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
                {
-                 if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
+                 if (filename_cmp (bfd_get_filename (newbfd),
+                                   bfd_get_filename (ibfd)) == 0)
                    break;
                }
              if (!newbfd)
                {
-                 einfo (_("%X%s(%s): can't find member in archive"),
-                   ibfd->my_archive->filename, ibfd->filename);
+                 einfo (_("%X%P: %s(%s): can't find member in archive"),
+                        bfd_get_filename (ibfd->my_archive),
+                        bfd_get_filename (ibfd));
                  return;
                }
            }
@@ -2785,9 +3017,45 @@ pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_
       /* Don't add PRIVATE entries to import lib.  */
       if (pe_def_file->exports[i].flag_private)
        continue;
+
       def->exports[i].internal_name = def->exports[i].name;
-      n = make_one (def->exports + i, outarch,
-                   ! (def->exports + i)->flag_data);
+
+      /* PR 19803: If a symbol has been discard due to garbage
+        collection then do not create any exports for it.  */
+      {
+       struct coff_link_hash_entry *h;
+
+       h = coff_link_hash_lookup (coff_hash_table (info), internal,
+                                  false, false, false);
+       if (h != NULL
+           /* If the symbol is hidden and undefined then it
+              has been swept up by garbage collection.  */
+           && h->symbol_class == C_HIDDEN
+           && h->root.u.def.section == bfd_und_section_ptr)
+         continue;
+
+       /* If necessary, check with an underscore prefix as well.  */
+       if (pe_details->underscored && internal[0] != '@')
+         {
+           char *name;
+
+           name = xmalloc (strlen (internal) + 2);
+           sprintf (name, "_%s", internal);
+
+           h = coff_link_hash_lookup (coff_hash_table (info), name,
+                                      false, false, false);
+           free (name);
+
+           if (h != NULL
+               /* If the symbol is hidden and undefined then it
+                  has been swept up by garbage collection.  */
+               && h->symbol_class == C_HIDDEN
+               && h->root.u.def.section == bfd_und_section_ptr)
+             continue;
+         }
+      }
+
+      n = make_one (def->exports + i, outarch, !(def->exports + i)->flag_data);
       n->archive_next = head;
       head = n;
       def->exports[i].internal_name = internal;
@@ -2804,10 +3072,10 @@ pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_
   head = ar_tail;
 
   if (! bfd_set_archive_head (outarch, head))
-    einfo ("%Xbfd_set_archive_head: %E\n");
+    einfo ("%X%P: bfd_set_archive_head: %E\n");
 
   if (! bfd_close (outarch))
-    einfo ("%Xbfd_close %s: %E\n", impfilename);
+    einfo ("%X%P: bfd_close %s: %E\n", impfilename);
 
   while (head != NULL)
     {
@@ -2825,7 +3093,7 @@ struct key_value
   const char *oname;
 };
 
-struct key_value *udef_table;
+static struct key_value *udef_table;
 
 static int undef_sort_cmp (const void *l1, const void *r1)
 {
@@ -2841,8 +3109,8 @@ pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
   struct bfd_link_hash_entry *h = NULL;
   struct key_value *kv;
   struct key_value key;
-  char *at, *lname = (char *) alloca (strlen (name) + 3);
-  
+  char *at, *lname = xmalloc (strlen (name) + 3);
+
   strcpy (lname, name);
 
   at = strchr (lname + (lname[0] == '@'), '@');
@@ -2855,42 +3123,46 @@ pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
 
   if (kv)
     {
-      h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+      h = bfd_link_hash_lookup (linfo->hash, kv->oname, false, false, false);
       if (h->type == bfd_link_hash_undefined)
-        return h;
+       goto return_h;
     }
+
   if (lname[0] == '?')
-    return NULL;
+    goto return_NULL;
+
   if (at || lname[0] == '@')
     {
       if (lname[0] == '@')
-        {
+       {
          if (pe_details->underscored)
            lname[0] = '_';
          else
-           strcpy (lname, lname + 1);
+           /* Use memmove rather than strcpy as that
+              can handle overlapping buffers.  */
+           memmove (lname, lname + 1, strlen (lname));
          key.key = lname;
          kv = bsearch (&key, udef_table, undef_count,
                        sizeof (struct key_value), undef_sort_cmp);
          if (kv)
            {
-             h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+             h = bfd_link_hash_lookup (linfo->hash, kv->oname, false, false, false);
              if (h->type == bfd_link_hash_undefined)
-               return h;
+               goto return_h;
            }
        }
       if (at)
-        *strchr (lname, '@') = 0;
+       *strchr (lname, '@') = 0;
       key.key = lname;
       kv = bsearch (&key, udef_table, undef_count,
                    sizeof (struct key_value), undef_sort_cmp);
       if (kv)
        {
-         h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+         h = bfd_link_hash_lookup (linfo->hash, kv->oname, false, false, false);
          if (h->type == bfd_link_hash_undefined)
-           return h;
+           goto return_h;
        }
-      return NULL;
+      goto return_NULL;
     }
 
   strcat (lname, "@");
@@ -2900,9 +3172,9 @@ pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
 
   if (kv)
     {
-      h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+      h = bfd_link_hash_lookup (linfo->hash, kv->oname, false, false, false);
       if (h->type == bfd_link_hash_undefined)
-       return h;
+       goto return_h;
     }
 
   if (lname[0] == '_' && pe_details->underscored)
@@ -2919,24 +3191,28 @@ pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
 
   if (kv)
     {
-      h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+      h = bfd_link_hash_lookup (linfo->hash, kv->oname, false, false, false);
       if (h->type == bfd_link_hash_undefined)
-        return h;
+       goto return_h;
     }
-  
-  return NULL;
+
+ return_NULL:
+  h = NULL;
+ return_h:
+  free (lname);
+  return h;
 }
 
-static bfd_boolean
+static bool
 pe_undef_count (struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
-                void *inf ATTRIBUTE_UNUSED)
+               void *inf ATTRIBUTE_UNUSED)
 {
   if (h->type == bfd_link_hash_undefined)
     undef_count++;
-  return TRUE;
+  return true;
 }
 
-static bfd_boolean
+static bool
 pe_undef_fill (struct bfd_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
 {
   if (h->type == bfd_link_hash_undefined)
@@ -2947,11 +3223,11 @@ pe_undef_fill (struct bfd_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
       at = strchr (udef_table[undef_count].key
                   + (udef_table[undef_count].key[0] == '@'), '@');
       if (at)
-        at[1] = 0;
+       at[1] = 0;
       udef_table[undef_count].oname = h->root.string;
       undef_count++;
     }
-  return TRUE;
+  return true;
 }
 
 static void
@@ -2985,133 +3261,149 @@ add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
   ldlang_add_file (fake_file);
 
   if (!bfd_link_add_symbols (abfd, linfo))
-    einfo ("%Xaddsym %s: %E\n", name);
+    einfo (_("%X%P: add symbols %s: %E\n"), name);
 }
 
 void
 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
 {
-  int i, j;
-  def_file_module *module;
-  def_file_import *imp;
-
   pe_dll_id_target (bfd_get_target (output_bfd));
 
-  if (!pe_def_file)
-    return;
-
-  imp = pe_def_file->imports;
-
-  pe_create_undef_table ();
-
-  for (module = pe_def_file->modules; module; module = module->next)
+  if (pe_def_file)
     {
-      int do_this_dll = 0;
+      int i, j;
+      def_file_module *module;
+      def_file_import *imp;
 
-      for (i = 0; i < pe_def_file->num_imports && imp[i].module != module; i++)
-       ;
-      if (i >= pe_def_file->num_imports)
-        continue;
+      imp = pe_def_file->imports;
 
-      dll_filename = module->name;
-      dll_symname = xstrdup (module->name);
-      for (j = 0; dll_symname[j]; j++)
-       if (!ISALNUM (dll_symname[j]))
-         dll_symname[j] = '_';
+      pe_create_undef_table ();
 
-      for (; i < pe_def_file->num_imports && imp[i].module == module; i++)
+      for (module = pe_def_file->modules; module; module = module->next)
        {
-         def_file_export exp;
-         struct bfd_link_hash_entry *blhe;
-         int lead_at = (*imp[i].internal_name == '@');
-         /* See if we need this import.  */
-         size_t len = strlen (imp[i].internal_name);
-         char *name = xmalloc (len + 2 + 6);
-         bfd_boolean include_jmp_stub = FALSE;
-         bfd_boolean is_cdecl = FALSE;
-         bfd_boolean is_undef = FALSE;
-
-         if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
-             is_cdecl = TRUE;
-
-         if (lead_at)
-           sprintf (name, "%s", imp[i].internal_name);
-         else
-           sprintf (name, "%s%s",U (""), imp[i].internal_name);
+         int do_this_dll = 0;
 
-         blhe = bfd_link_hash_lookup (linfo->hash, name,
-                                      FALSE, FALSE, FALSE);
+         for (i = 0; i < pe_def_file->num_imports; i++)
+           if (imp[i].module == module)
+             break;
+         if (i >= pe_def_file->num_imports)
+           continue;
+
+         dll_filename = module->name;
+         dll_symname = xstrdup (module->name);
+         for (j = 0; dll_symname[j]; j++)
+           if (!ISALNUM (dll_symname[j]))
+             dll_symname[j] = '_';
 
-         /* Include the jump stub for <sym> only if the <sym>
-            is undefined.  */
-         if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
+         for (; i < pe_def_file->num_imports && imp[i].module == module; i++)
            {
+             def_file_export exp;
+             struct bfd_link_hash_entry *blhe;
+             int lead_at = (*imp[i].internal_name == '@');
+             /* See if we need this import.  */
+             size_t len = strlen (imp[i].internal_name);
+             char *name = xmalloc (len + 2 + 6);
+             bool include_jmp_stub = false;
+             bool is_cdecl = false;
+             bool is_undef = false;
+
+             if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
+               is_cdecl = true;
+
              if (lead_at)
-               sprintf (name, "%s%s", "__imp_", imp[i].internal_name);
+               sprintf (name, "%s", imp[i].internal_name);
              else
-               sprintf (name, "%s%s%s", "__imp_", U (""),
-                        imp[i].internal_name);
+               sprintf (name, "%s%s",U (""), imp[i].internal_name);
 
              blhe = bfd_link_hash_lookup (linfo->hash, name,
-                                          FALSE, FALSE, FALSE);
-             if (blhe)
-               is_undef = (blhe->type == bfd_link_hash_undefined);
-           }
-         else
-           {
-             include_jmp_stub = TRUE;
-             is_undef = (blhe->type == bfd_link_hash_undefined);
-           }
+                                          false, false, false);
 
-         if (is_cdecl && (!blhe || (blhe && blhe->type != bfd_link_hash_undefined)))
-           {
-             sprintf (name, "%s%s",U (""), imp[i].internal_name);
-             blhe = pe_find_cdecl_alias_match (linfo, name);
-             include_jmp_stub = TRUE;
-             if (blhe)
-               is_undef = (blhe->type == bfd_link_hash_undefined);
-           }
+             /* Include the jump stub for <sym> only if the <sym>
+                is undefined.  */
+             if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
+               {
+                 if (lead_at)
+                   sprintf (name, "%s%s", "__imp_", imp[i].internal_name);
+                 else
+                   sprintf (name, "%s%s%s", "__imp_", U (""),
+                            imp[i].internal_name);
+
+                 blhe = bfd_link_hash_lookup (linfo->hash, name,
+                                              false, false, false);
+                 if (blhe)
+                   is_undef = (blhe->type == bfd_link_hash_undefined);
+
+                 if (is_cdecl && (!blhe || !is_undef))
+                   {
+                     blhe = pe_find_cdecl_alias_match (linfo, name + 6);
+                     include_jmp_stub = true;
+                     if (blhe)
+                       is_undef = (blhe->type == bfd_link_hash_undefined);
+                   }
+               }
+             else
+               {
+                 include_jmp_stub = true;
+                 is_undef = (blhe->type == bfd_link_hash_undefined);
+               }
 
-         free (name);
+             free (name);
 
-         if (is_undef)
-           {
-             bfd *one;
-             /* We do.  */
-             if (!do_this_dll)
+             if (is_undef)
                {
-                 bfd *ar_head = make_head (output_bfd);
-                 add_bfd_to_link (ar_head, ar_head->filename, linfo);
-                 do_this_dll = 1;
+                 bfd *one;
+                 /* We do.  */
+                 if (!do_this_dll)
+                   {
+                     bfd *ar_head = make_head (output_bfd);
+                     add_bfd_to_link (ar_head, bfd_get_filename (ar_head),
+                                      linfo);
+                     do_this_dll = 1;
+                   }
+                 exp.internal_name = imp[i].internal_name;
+                 exp.name = imp[i].name;
+                 exp.its_name = imp[i].its_name;
+                 exp.ordinal = imp[i].ordinal;
+                 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
+                 exp.flag_private = 0;
+                 exp.flag_constant = 0;
+                 exp.flag_data = imp[i].data;
+                 exp.flag_noname = exp.name ? 0 : 1;
+                 one = make_one (&exp, output_bfd,
+                                 !exp.flag_data && include_jmp_stub);
+                 add_bfd_to_link (one, bfd_get_filename (one), linfo);
                }
-             exp.internal_name = imp[i].internal_name;
-             exp.name = imp[i].name;
-             exp.its_name = imp[i].its_name;
-             exp.ordinal = imp[i].ordinal;
-             exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
-             exp.flag_private = 0;
-             exp.flag_constant = 0;
-             exp.flag_data = imp[i].data;
-             exp.flag_noname = exp.name ? 0 : 1;
-             one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
-             add_bfd_to_link (one, one->filename, linfo);
            }
+         if (do_this_dll)
+           {
+             bfd *ar_tail = make_tail (output_bfd);
+             add_bfd_to_link (ar_tail, bfd_get_filename (ar_tail), linfo);
+           }
+
+         free (dll_symname);
        }
-      if (do_this_dll)
+
+      while (undef_count)
        {
-         bfd *ar_tail = make_tail (output_bfd);
-         add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
+         --undef_count;
+         free (udef_table[undef_count].key);
        }
-
-      free (dll_symname);
+      free (udef_table);
     }
 
-  while (undef_count)
+  if (pe_def_file && pe_def_file->name)
+    dll_filename = pe_def_file->name;
+  else
     {
-      --undef_count;
-      free (udef_table[undef_count].key);
+      dll_filename = bfd_get_filename (output_bfd);
+      for (const char *p = dll_filename; *p; p++)
+       if (*p == '\\' || *p == '/' || *p == ':')
+         dll_filename = p + 1;
     }
-  free (udef_table);
+  dll_symname = xstrdup (dll_filename);
+  for (int i = 0; dll_symname[i]; i++)
+    if (!ISALNUM (dll_symname[i]))
+      dll_symname[i] = '_';
 }
 
 /* We were handed a *.DLL file.  Parse it and turn it into a set of
@@ -3119,23 +3411,31 @@ pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
    handled, FALSE if not.  */
 
 static unsigned int
-pe_get16 (bfd *abfd, int where)
+pe_get16 (bfd *abfd, int where, bool *fail)
 {
   unsigned char b[2];
 
-  bfd_seek (abfd, (file_ptr) where, SEEK_SET);
-  bfd_bread (b, (bfd_size_type) 2, abfd);
+  if (bfd_seek (abfd, where, SEEK_SET) != 0
+      || bfd_read (b, 2, abfd) != 2)
+    {
+      *fail = true;
+      return 0;
+    }
   return b[0] + (b[1] << 8);
 }
 
 static unsigned int
-pe_get32 (bfd *abfd, int where)
+pe_get32 (bfd *abfd, int where, bool *fail)
 {
   unsigned char b[4];
 
-  bfd_seek (abfd, (file_ptr) where, SEEK_SET);
-  bfd_bread (b, (bfd_size_type) 4, abfd);
-  return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
+  if (bfd_seek (abfd, where, SEEK_SET) != 0
+      || bfd_read (b, 4, abfd) != 4)
+    {
+      *fail = true;
+      return 0;
+    }
+  return b[0] + (b[1] << 8) + (b[2] << 16) + ((unsigned) b[3] << 24);
 }
 
 static unsigned int
@@ -3143,10 +3443,10 @@ pe_as32 (void *ptr)
 {
   unsigned char *b = ptr;
 
-  return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
+  return b[0] + (b[1] << 8) + (b[2] << 16) + ((unsigned) b[3] << 24);
 }
 
-bfd_boolean
+bool
 pe_implied_import_dll (const char *filename)
 {
   bfd *dll;
@@ -3165,51 +3465,65 @@ pe_implied_import_dll (const char *filename)
   bfd_vma rdata_end = 0;
   bfd_vma bss_start = 1;
   bfd_vma bss_end = 0;
+  int from;
 
   /* No, I can't use bfd here.  kernel32.dll puts its export table in
      the middle of the .rdata section.  */
   dll = bfd_openr (filename, pe_details->target_name);
   if (!dll)
     {
-      einfo ("%Xopen %s: %E\n", filename);
-      return FALSE;
+      einfo (_("%X%P: open %s: %E\n"), filename);
+      return false;
     }
 
+  track_dependency_files (filename);
+
   /* PEI dlls seem to be bfd_objects.  */
   if (!bfd_check_format (dll, bfd_object))
     {
-      einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
-      return FALSE;
+    notdll:
+      einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename);
+      return false;
     }
 
   /* Get pe_header, optional header and numbers of directory entries.  */
-  pe_header_offset = pe_get32 (dll, 0x3c);
+  bool fail = false;
+  pe_header_offset = pe_get32 (dll, 0x3c, &fail);
+  if (fail)
+    goto notdll;
   opthdr_ofs = pe_header_offset + 4 + 20;
-#ifdef pe_use_x86_64
-  num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /*  & NumberOfRvaAndSizes.  */
+#ifdef pe_use_plus
+  /* NumberOfRvaAndSizes.  */
+  num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4, &fail);
 #else
-  num_entries = pe_get32 (dll, opthdr_ofs + 92);
+  num_entries = pe_get32 (dll, opthdr_ofs + 92, &fail);
 #endif
+  if (fail)
+    goto notdll;
 
   /* No import or export directory entry.  */
   if (num_entries < 1)
-    return FALSE;
+    return false;
 
-#ifdef pe_use_x86_64
-  export_rva  = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
-  export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
+#ifdef pe_use_plus
+  export_rva  = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4, &fail);
+  export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4, &fail);
 #else
-  export_rva = pe_get32 (dll, opthdr_ofs + 96);
-  export_size = pe_get32 (dll, opthdr_ofs + 100);
+  export_rva = pe_get32 (dll, opthdr_ofs + 96, &fail);
+  export_size = pe_get32 (dll, opthdr_ofs + 100, &fail);
 #endif
+  if (fail)
+    goto notdll;
 
   /* No export table - nothing to export.  */
   if (export_size == 0)
-    return FALSE;
+    return false;
 
-  nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
+  nsections = pe_get16 (dll, pe_header_offset + 4 + 2, &fail);
   secptr = (pe_header_offset + 4 + 20 +
-           pe_get16 (dll, pe_header_offset + 4 + 16));
+           pe_get16 (dll, pe_header_offset + 4 + 16, &fail));
+  if (fail)
+    goto notdll;
   expptr = 0;
 
   /* Get the rva and size of the export section.  */
@@ -3217,12 +3531,14 @@ pe_implied_import_dll (const char *filename)
     {
       char sname[8];
       bfd_vma secptr1 = secptr + 40 * i;
-      bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
-      bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
-      bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
+      bfd_vma vaddr = pe_get32 (dll, secptr1 + 12, &fail);
+      bfd_vma vsize = pe_get32 (dll, secptr1 + 16, &fail);
+      bfd_vma fptr = pe_get32 (dll, secptr1 + 20, &fail);
 
-      bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
-      bfd_bread (sname, (bfd_size_type) 8, dll);
+      if (fail
+         || bfd_seek (dll, secptr1, SEEK_SET) != 0
+         || bfd_read (sname, 8, dll) != 8)
+       goto notdll;
 
       if (vaddr <= export_rva && vaddr + vsize > export_rva)
        {
@@ -3238,14 +3554,16 @@ pe_implied_import_dll (const char *filename)
   for (i = 0; i < nsections; i++)
     {
       bfd_vma secptr1 = secptr + 40 * i;
-      bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
-      bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
-      bfd_vma flags = pe_get32 (dll, secptr1 + 36);
+      bfd_vma vsize = pe_get32 (dll, secptr1 + 8, &fail);
+      bfd_vma vaddr = pe_get32 (dll, secptr1 + 12, &fail);
+      bfd_vma flags = pe_get32 (dll, secptr1 + 36, &fail);
       char sec_name[9];
 
       sec_name[8] = '\0';
-      bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
-      bfd_bread (sec_name, (bfd_size_type) 8, dll);
+      if (fail
+         || bfd_seek (dll, secptr1 + 0, SEEK_SET) != 0
+         || bfd_read (sec_name, 8, dll) != 8)
+       goto notdll;
 
       if (strcmp(sec_name,".data") == 0)
        {
@@ -3254,7 +3572,7 @@ pe_implied_import_dll (const char *filename)
 
          if (pe_dll_extra_pe_debug)
            printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
-                   __FUNCTION__, sec_name, (unsigned long) vaddr,
+                   __func__, sec_name, (unsigned long) vaddr,
                    (unsigned long) (vaddr + vsize), (unsigned long) flags);
        }
       else if (strcmp(sec_name,".rdata") == 0)
@@ -3264,7 +3582,7 @@ pe_implied_import_dll (const char *filename)
 
          if (pe_dll_extra_pe_debug)
            printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
-                   __FUNCTION__, sec_name, (unsigned long) vaddr,
+                   __func__, sec_name, (unsigned long) vaddr,
                    (unsigned long) (vaddr + vsize), (unsigned long) flags);
        }
       else if (strcmp (sec_name,".bss") == 0)
@@ -3274,14 +3592,15 @@ pe_implied_import_dll (const char *filename)
 
          if (pe_dll_extra_pe_debug)
            printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
-                   __FUNCTION__, sec_name, (unsigned long) vaddr,
+                   __func__, sec_name, (unsigned long) vaddr,
                    (unsigned long) (vaddr + vsize), (unsigned long) flags);
        }
     }
 
   expdata = xmalloc (export_size);
-  bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
-  bfd_bread (expdata, (bfd_size_type) export_size, dll);
+  if (bfd_seek (dll, expptr, SEEK_SET) != 0
+      || bfd_read (expdata, export_size, dll) != export_size)
+    goto notdll;
   erva = (char *) expdata - export_rva;
 
   if (pe_def_file == 0)
@@ -3302,7 +3621,41 @@ pe_implied_import_dll (const char *filename)
     {
       if (pe_dll_extra_pe_debug)
        printf ("%s is already loaded\n", dllname);
-      return TRUE;
+      return true;
+    }
+
+  /* This is an optimized version of the insertion loop, which avoids lots of
+     calls to realloc and memmove from def_file_add_import.  */
+  if ((from = def_file_add_import_from (pe_def_file, nexp,
+                                       erva + pe_as32 (erva + name_rvas),
+                                       dllname, 0, NULL, NULL)) >= 0)
+    {
+      for (i = 0; i < nexp; i++)
+       {
+         /* Pointer to the names vector.  */
+         bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
+         def_file_import *imp;
+         /* Pointer to the function address vector.  */
+         bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
+         /* is_data is true if the address is in the data, rdata or bss
+            segment.  */
+         const int is_data =
+           (func_rva >= data_start && func_rva < data_end)
+           || (func_rva >= rdata_start && func_rva < rdata_end)
+           || (func_rva >= bss_start && func_rva < bss_end);
+
+         imp = def_file_add_import_at (pe_def_file, from + i, erva + name_rva,
+                                       dllname, i, NULL, NULL);
+         /* Mark symbol type.  */
+         imp->data = is_data;
+
+         if (pe_dll_extra_pe_debug)
+           printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
+                   __func__, dllname, erva + name_rva,
+                   (unsigned long) func_rva, is_data ? "(data)" : "");
+       }
+
+      return true;
     }
 
   /* Iterate through the list of symbols.  */
@@ -3317,30 +3670,30 @@ pe_implied_import_dll (const char *filename)
 
       /* Skip unwanted symbols, which are
         exported in buggy auto-import releases.  */
-      if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
-       {
-         int is_dup = 0;
-         /* is_data is true if the address is in the data, rdata or bss
+      if (! startswith (erva + name_rva, "__nm_"))
+       {
+         bool is_dup = false;
+         /* is_data is true if the address is in the data, rdata or bss
             segment.  */
-         is_data =
+         is_data =
            (func_rva >= data_start && func_rva < data_end)
            || (func_rva >= rdata_start && func_rva < rdata_end)
            || (func_rva >= bss_start && func_rva < bss_end);
 
          imp = def_file_add_import (pe_def_file, erva + name_rva,
                                     dllname, i, NULL, NULL, &is_dup);
-         /* Mark symbol type.  */
-         if (!is_dup)
-           imp->data = is_data;
+         /* Mark symbol type.  */
+         if (!is_dup)
+           imp->data = is_data;
 
-         if (pe_dll_extra_pe_debug)
+         if (pe_dll_extra_pe_debug)
            printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
-                   __FUNCTION__, dllname, erva + name_rva,
+                   __func__, dllname, erva + name_rva,
                    (unsigned long) func_rva, is_data ? "(data)" : "");
-       }
+       }
     }
 
-  return TRUE;
+  return true;
 }
 
 void
@@ -3349,7 +3702,7 @@ pe_output_file_set_long_section_names (bfd *abfd)
   if (pe_use_coff_long_section_names < 0)
     return;
   if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
-    einfo (_("%XError: can't use long section names on this arch\n"));
+    einfo (_("%X%P: error: can't use long section names on this arch\n"));
 }
 
 /* These are the main functions, called from the emulation.  The first
@@ -3364,11 +3717,19 @@ pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
   pe_output_file_set_long_section_names (abfd);
   process_def_file_and_drectve (abfd, info);
 
-  if (pe_def_file->num_exports == 0 && !info->shared)
-    return;
+  if (pe_def_file->num_exports == 0
+      && (!bfd_link_pic (info) || pe_dll_exclude_all_symbols))
+    {
+      if (pe_dll_enable_reloc_section)
+       {
+         build_filler_bfd (false /* edata not needed.  */);
+         pe_output_file_set_long_section_names (filler_bfd);
+       }
+      return;
+    }
 
-  generate_edata (abfd, info);
-  build_filler_bfd (1);
+  generate_edata ();
+  build_filler_bfd (true /* edata is needed.  */);
   pe_output_file_set_long_section_names (filler_bfd);
 }
 
@@ -3384,33 +3745,16 @@ pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
 void
 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
 {
-  pe_dll_id_target (bfd_get_target (abfd));
-  pe_output_file_set_long_section_names (abfd);
-  image_base = pe_data (abfd)->pe_opthdr.ImageBase;
+  pe_exe_fill_sections (abfd, info);
 
-  generate_reloc (abfd, info);
-  if (reloc_sz > 0)
+  if (edata_s)
     {
-      bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
-
-      /* Resize the sections.  */
-      lang_reset_memory_regions ();
-      lang_size_sections (NULL, TRUE);
-
-      /* Redo special stuff.  */
-      ldemul_after_allocation ();
-
-      /* Do the assignments again.  */
-      lang_do_assignments (lang_final_phase_enum);
+      fill_edata (abfd, info);
+      edata_s->contents = edata_d;
     }
 
-  fill_edata (abfd, info);
-
-  if (info->shared && !info->pie)
+  if (bfd_link_dll (info))
     pe_data (abfd)->dll = 1;
-
-  edata_s->contents = edata_d;
-  reloc_s->contents = reloc_d;
 }
 
 void
@@ -3421,27 +3765,35 @@ pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
 
   generate_reloc (abfd, info);
+
   if (reloc_sz > 0)
     {
-      bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
+      bfd_set_section_size (reloc_s, reloc_sz);
 
       /* Resize the sections.  */
       lang_reset_memory_regions ();
-      lang_size_sections (NULL, TRUE);
+      lang_size_sections (NULL, true);
 
       /* Redo special stuff.  */
       ldemul_after_allocation ();
 
       /* Do the assignments again.  */
       lang_do_assignments (lang_final_phase_enum);
+
+      reloc_s->contents = reloc_d;
+    }
+  else if (reloc_s)
+    {
+      /* Do not emit an empty reloc section.  */
+      bfd_set_section_flags (reloc_s, SEC_IN_MEMORY | SEC_EXCLUDE);
+      reloc_s->output_section = bfd_abs_section_ptr;
     }
-  reloc_s->contents = reloc_d;
 }
 
-bfd_boolean
+bool
 pe_bfd_is_dll (bfd *abfd)
 {
   return (bfd_get_format (abfd) == bfd_object
-          && obj_pe (abfd)
-          && pe_data (abfd)->dll);
+         && obj_pe (abfd)
+         && pe_data (abfd)->dll);
 }