ld/pe-dll.c

   1 /* Routines to help build PEI-format DLLs (Win32 etc)
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3    Written by DJ Delorie <dj@cygnus.com>
   4
   5    This file is part of the GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "libiberty.h"
  26 #include "filenames.h"
  27 #include "safe-ctype.h"
  28
  29 #include <time.h>
  30
  31 #include "ld.h"
  32 #include "ldexp.h"
  33 #include "ldlang.h"
  34 #include "ldwrite.h"
  35 #include "ldmisc.h"
  36 #include <ldgram.h>
  37 #include "ldmain.h"
  38 #include "ldfile.h"
  39 #include "ldemul.h"
  40 #include "coff/internal.h"
  41 #include "../bfd/libcoff.h"
  42 #include "deffile.h"
  43
  44 #ifdef pe_use_x86_64
  45
  46 #define PE_IDATA4_SIZE  8
  47 #define PE_IDATA5_SIZE  8
  48 #include "pep-dll.h"
  49 #undef  AOUTSZ
  50 #define AOUTSZ          PEPAOUTSZ
  51 #define PEAOUTHDR       PEPAOUTHDR
  52
  53 #else
  54
  55 #include "pe-dll.h"
  56
  57 #endif
  58
  59 #ifndef PE_IDATA4_SIZE
  60 #define PE_IDATA4_SIZE  4
  61 #endif
  62
  63 #ifndef PE_IDATA5_SIZE
  64 #define PE_IDATA5_SIZE  4
  65 #endif
  66
  67 /*  This file turns a regular Windows PE image into a DLL.  Because of
  68     the complexity of this operation, it has been broken down into a
  69     number of separate modules which are all called by the main function
  70     at the end of this file.  This function is not re-entrant and is
  71     normally only called once, so static variables are used to reduce
  72     the number of parameters and return values required.
  73
  74     See also: ld/emultempl/pe.em and ld/emultempl/pep.em.  */
  75
  76 /*  Auto-import feature by Paul Sokolovsky
  77
  78     Quick facts:
  79
  80     1. With this feature on, DLL clients can import variables from DLL
  81     without any concern from their side (for example, without any source
  82     code modifications).
  83
  84     2. This is done completely in bounds of the PE specification (to be fair,
  85     there's a place where it pokes nose out of, but in practice it works).
  86     So, resulting module can be used with any other PE compiler/linker.
  87
  88     3. Auto-import is fully compatible with standard import method and they
  89     can be mixed together.
  90
  91     4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
  92     reference to it; load time: negligible; virtual/physical memory: should be
  93     less than effect of DLL relocation, and I sincerely hope it doesn't affect
  94     DLL sharability (too much).
  95
  96     Idea
  97
  98     The obvious and only way to get rid of dllimport insanity is to make client
  99     access variable directly in the DLL, bypassing extra dereference. I.e.,
 100     whenever client contains something like
 101
 102     mov dll_var,%eax,
 103
 104     address of dll_var in the command should be relocated to point into loaded
 105     DLL. The aim is to make OS loader do so, and than make ld help with that.
 106     Import section of PE made following way: there's a vector of structures
 107     each describing imports from particular DLL. Each such structure points
 108     to two other parallel vectors: one holding imported names, and one which
 109     will hold address of corresponding imported name. So, the solution is
 110     de-vectorize these structures, making import locations be sparse and
 111     pointing directly into code. Before continuing, it is worth a note that,
 112     while authors strives to make PE act ELF-like, there're some other people
 113     make ELF act PE-like: elfvector, ;-) .
 114
 115     Implementation
 116
 117     For each reference of data symbol to be imported from DLL (to set of which
 118     belong symbols with name <sym>, if __imp_<sym> is found in implib), the
 119     import fixup entry is generated. That entry is of type
 120     IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
 121     fixup entry contains pointer to symbol's address within .text section
 122     (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
 123     (so, DLL name is referenced by multiple entries), and pointer to symbol
 124     name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
 125     pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
 126     containing imported name. Here comes that "on the edge" problem mentioned
 127     above: PE specification rambles that name vector (OriginalFirstThunk)
 128     should run in parallel with addresses vector (FirstThunk), i.e. that they
 129     should have same number of elements and terminated with zero. We violate
 130     this, since FirstThunk points directly into machine code. But in practice,
 131     OS loader implemented the sane way: it goes through OriginalFirstThunk and
 132     puts addresses to FirstThunk, not something else. It once again should be
 133     noted that dll and symbol name structures are reused across fixup entries
 134     and should be there anyway to support standard import stuff, so sustained
 135     overhead is 20 bytes per reference. Other question is whether having several
 136     IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
 137     done even by native compiler/linker (libth32's functions are in fact reside
 138     in windows9x kernel32.dll, so if you use it, you have two
 139     IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
 140     referencing the same PE structures several times is valid. The answer is why
 141     not, prohibiting that (detecting violation) would require more work on
 142     behalf of loader than not doing it.
 143
 144     See also: ld/emultempl/pe.em and ld/emultempl/pep.em.  */
 145
 146 static void add_bfd_to_link (bfd *, const char *, struct bfd_link_info *);
 147
 148 /* For emultempl/pe.em.  */
 149
 150 def_file * pe_def_file = 0;
 151 int pe_dll_export_everything = 0;
 152 int pe_dll_exclude_all_symbols = 0;
 153 int pe_dll_do_default_excludes = 1;
 154 int pe_dll_kill_ats = 0;
 155 int pe_dll_stdcall_aliases = 0;
 156 int pe_dll_warn_dup_exports = 0;
 157 int pe_dll_compat_implib = 0;
 158 int pe_dll_extra_pe_debug = 0;
 159 int pe_use_nul_prefixed_import_tables = 0;
 160 int pe_use_coff_long_section_names = -1;
 161 int pe_leading_underscore = -1;
 162
 163 /* Static variables and types.  */
 164
 165 static bfd_vma image_base;
 166 static bfd *filler_bfd;
 167 static struct bfd_section *edata_s, *reloc_s;
 168 static unsigned char *edata_d, *reloc_d;
 169 static size_t edata_sz, reloc_sz;
 170 static int runtime_pseudo_relocs_created = 0;
 171 static bfd_boolean runtime_pseudp_reloc_v2_init = FALSE;
 172
 173 typedef struct
 174 {
 175   const char *name;
 176   int len;
 177 }
 178 autofilter_entry_type;
 179
 180 typedef struct
 181 {
 182   const char *target_name;
 183   const char *object_target;
 184   unsigned int imagebase_reloc;
 185   int pe_arch;
 186   int bfd_arch;
 187   bfd_boolean underscored;
 188   const autofilter_entry_type* autofilter_symbollist;
 189 }
 190 pe_details_type;
 191
 192 static const autofilter_entry_type autofilter_symbollist_generic[] =
 193 {
 194   { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
 195   /* Entry point symbols.  */
 196   { STRING_COMMA_LEN ("DllMain") },
 197   { STRING_COMMA_LEN ("DllMainCRTStartup") },
 198   { STRING_COMMA_LEN ("_DllMainCRTStartup") },
 199   /* Runtime pseudo-reloc.  */
 200   { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
 201   { STRING_COMMA_LEN ("do_pseudo_reloc") },
 202   { NULL, 0 }
 203 };
 204
 205 static const autofilter_entry_type autofilter_symbollist_i386[] =
 206 {
 207   { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
 208   /* Entry point symbols, and entry hooks.  */
 209   { STRING_COMMA_LEN ("cygwin_crt0") },
 210 #ifdef pe_use_x86_64
 211   { STRING_COMMA_LEN ("DllMain") },
 212   { STRING_COMMA_LEN ("DllEntryPoint") },
 213   { STRING_COMMA_LEN ("DllMainCRTStartup") },
 214   { STRING_COMMA_LEN ("_cygwin_dll_entry") },
 215   { STRING_COMMA_LEN ("_cygwin_crt0_common") },
 216   { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
 217 #else
 218   { STRING_COMMA_LEN ("DllMain@12") },
 219   { STRING_COMMA_LEN ("DllEntryPoint@0") },
 220   { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
 221   { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
 222   { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
 223   { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
 224   { STRING_COMMA_LEN ("cygwin_attach_dll") },
 225 #endif
 226   { STRING_COMMA_LEN ("cygwin_premain0") },
 227   { STRING_COMMA_LEN ("cygwin_premain1") },
 228   { STRING_COMMA_LEN ("cygwin_premain2") },
 229   { STRING_COMMA_LEN ("cygwin_premain3") },
 230   /* Runtime pseudo-reloc.  */
 231   { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
 232   { STRING_COMMA_LEN ("do_pseudo_reloc") },
 233   /* Global vars that should not be exported.  */
 234   { STRING_COMMA_LEN ("impure_ptr") },
 235   { STRING_COMMA_LEN ("_impure_ptr") },
 236   { STRING_COMMA_LEN ("_fmode") },
 237   { STRING_COMMA_LEN ("environ") },
 238   { STRING_COMMA_LEN ("__dso_handle") },
 239   { NULL, 0 }
 240 };
 241
 242 #define PE_ARCH_i386     1
 243 #define PE_ARCH_sh       2
 244 #define PE_ARCH_mips     3
 245 #define PE_ARCH_arm      4
 246 #define PE_ARCH_arm_wince 5
 247
 248 /* Don't make it constant as underscore mode gets possibly overriden
 249    by target or -(no-)leading-underscore option.  */
 250 static pe_details_type pe_detail_list[] =
 251 {
 252   {
 253 #ifdef pe_use_x86_64
 254     "pei-x86-64",
 255     "pe-x86-64",
 256     3 /* R_IMAGEBASE */,
 257 #else
 258     "pei-i386",
 259     "pe-i386",
 260     7 /* R_IMAGEBASE */,
 261 #endif
 262     PE_ARCH_i386,
 263     bfd_arch_i386,
 264 #ifdef pe_use_x86_64
 265     FALSE,
 266 #else
 267     TRUE,
 268 #endif
 269     autofilter_symbollist_i386
 270   },
 271 #ifdef pe_use_x86_64
 272   {
 273     "pei-x86-64",
 274     "pe-bigobj-x86-64",
 275     3 /* R_IMAGEBASE */,
 276     PE_ARCH_i386,
 277     bfd_arch_i386,
 278     FALSE,
 279     autofilter_symbollist_i386
 280   },
 281 #endif
 282   {
 283     "pei-shl",
 284     "pe-shl",
 285     16 /* R_SH_IMAGEBASE */,
 286     PE_ARCH_sh,
 287     bfd_arch_sh,
 288     TRUE,
 289     autofilter_symbollist_generic
 290   },
 291   {
 292     "pei-mips",
 293     "pe-mips",
 294     34 /* MIPS_R_RVA */,
 295     PE_ARCH_mips,
 296     bfd_arch_mips,
 297     FALSE,
 298     autofilter_symbollist_generic
 299   },
 300   {
 301     "pei-arm-little",
 302     "pe-arm-little",
 303     11 /* ARM_RVA32 */,
 304     PE_ARCH_arm,
 305     bfd_arch_arm,
 306     TRUE,
 307     autofilter_symbollist_generic
 308   },
 309   {
 310     "pei-arm-wince-little",
 311     "pe-arm-wince-little",
 312     2,  /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c.  */
 313     PE_ARCH_arm_wince,
 314     bfd_arch_arm,
 315     FALSE,
 316     autofilter_symbollist_generic
 317   },
 318   { NULL, NULL, 0, 0, 0, FALSE, NULL }
 319 };
 320
 321 static const pe_details_type *pe_details;
 322
 323 /* Do not specify library suffix explicitly, to allow for dllized versions.  */
 324 static const autofilter_entry_type autofilter_liblist[] =
 325 {
 326   { STRING_COMMA_LEN ("libcegcc") },
 327   { STRING_COMMA_LEN ("libcygwin") },
 328   { STRING_COMMA_LEN ("libgcc") },
 329   { STRING_COMMA_LEN ("libgcc_s") },
 330   { STRING_COMMA_LEN ("libstdc++") },
 331   { STRING_COMMA_LEN ("libmingw32") },
 332   { STRING_COMMA_LEN ("libmingwex") },
 333   { STRING_COMMA_LEN ("libg2c") },
 334   { STRING_COMMA_LEN ("libsupc++") },
 335   { STRING_COMMA_LEN ("libobjc") },
 336   { STRING_COMMA_LEN ("libgcj") },
 337   { STRING_COMMA_LEN ("libmsvcrt") },
 338   { STRING_COMMA_LEN ("libmsvcrt-os") },
 339   { STRING_COMMA_LEN ("libucrtbase") },
 340   { NULL, 0 }
 341 };
 342
 343 /* Regardless of the suffix issue mentioned above, we must ensure that
 344   we do not falsely match on a leading substring, such as when libtool
 345   builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
 346   This routine ensures that the leading part of the name matches and that
 347   it is followed by only an optional version suffix and a file extension,
 348   returning zero if so or -1 if not.  */
 349 static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
 350 {
 351   if (filename_ncmp (libname, afptr->name, afptr->len))
 352     return -1;
 353
 354   libname += afptr->len;
 355
 356   /* Be liberal in interpreting what counts as a version suffix; we
 357     accept anything that has a dash to separate it from the name and
 358     begins with a digit.  */
 359   if (libname[0] == '-')
 360     {
 361       if (!ISDIGIT (*++libname))
 362         return -1;
 363       /* Ensure the filename has an extension.  */
 364       while (*++libname != '.')
 365         if (!*libname)
 366           return -1;
 367     }
 368   else if (libname[0] != '.')
 369     return -1;
 370
 371   return 0;
 372 }
 373
 374 static const autofilter_entry_type autofilter_objlist[] =
 375 {
 376   { STRING_COMMA_LEN ("crt0.o") },
 377   { STRING_COMMA_LEN ("crt1.o") },
 378   { STRING_COMMA_LEN ("crt2.o") },
 379   { STRING_COMMA_LEN ("dllcrt1.o") },
 380   { STRING_COMMA_LEN ("dllcrt2.o") },
 381   { STRING_COMMA_LEN ("gcrt0.o") },
 382   { STRING_COMMA_LEN ("gcrt1.o") },
 383   { STRING_COMMA_LEN ("gcrt2.o") },
 384   { STRING_COMMA_LEN ("crtbegin.o") },
 385   { STRING_COMMA_LEN ("crtend.o") },
 386   { NULL, 0 }
 387 };
 388
 389 static const autofilter_entry_type autofilter_symbolprefixlist[] =
 390 {
 391   /* _imp_ is treated specially, as it is always underscored.  */
 392   /* { STRING_COMMA_LEN ("_imp_") },  */
 393   /* Don't export some c++ symbols.  */
 394   { STRING_COMMA_LEN ("__rtti_") },
 395   { STRING_COMMA_LEN ("__builtin_") },
 396   /* Don't re-export auto-imported symbols.  */
 397   { STRING_COMMA_LEN ("__nm_") },
 398   /* Don't export symbols specifying internal DLL layout.  */
 399   { STRING_COMMA_LEN ("_head_") },
 400   { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
 401   /* Don't export section labels or artificial symbols
 402   (eg ".weak.foo".  */
 403   { STRING_COMMA_LEN (".") },
 404   { NULL, 0 }
 405 };
 406
 407 static const autofilter_entry_type autofilter_symbolsuffixlist[] =
 408 {
 409   { STRING_COMMA_LEN ("_iname") },
 410   { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
 411   { NULL, 0 }
 412 };
 413
 414 #define U(str) (pe_details->underscored ? "_" str : str)
 415
 416 void
 417 pe_dll_id_target (const char *target)
 418 {
 419   int i;
 420
 421   for (i = 0; pe_detail_list[i].target_name; i++)
 422     if (strcmp (pe_detail_list[i].target_name, target) == 0
 423         || strcmp (pe_detail_list[i].object_target, target) == 0)
 424       {
 425         int u = pe_leading_underscore; /* Underscoring mode. -1 for use default.  */
 426         if (u == -1)
 427           bfd_get_target_info (target, NULL, NULL, &u, NULL);
 428         if (u == -1)
 429           abort ();
 430         pe_detail_list[i].underscored = (u != 0 ? TRUE : FALSE);
 431         pe_details = pe_detail_list + i;
 432         pe_leading_underscore = (u != 0 ? 1 : 0);
 433         return;
 434       }
 435   einfo (_("%X%P: unsupported PEI architecture: %s\n"), target);
 436   exit (1);
 437 }
 438
 439 /* Helper functions for qsort.  Relocs must be sorted so that we can write
 440    them out by pages.  */
 441
 442 typedef struct
 443   {
 444     bfd_vma vma;
 445     char type;
 446     short extra;
 447   }
 448 reloc_data_type;
 449
 450 static int
 451 reloc_sort (const void *va, const void *vb)
 452 {
 453   bfd_vma a = ((const reloc_data_type *) va)->vma;
 454   bfd_vma b = ((const reloc_data_type *) vb)->vma;
 455
 456   return (a > b) ? 1 : ((a < b) ? -1 : 0);
 457 }
 458
 459 static int
 460 pe_export_sort (const void *va, const void *vb)
 461 {
 462   const def_file_export *a = va;
 463   const def_file_export *b = vb;
 464   char *an = a->name;
 465   char *bn = b->name;
 466   if (a->its_name)
 467     an = a->its_name;
 468   if (b->its_name)
 469     bn = b->its_name;
 470
 471   return strcmp (an, bn);
 472 }
 473
 474 /* Read and process the .DEF file.  */
 475
 476 /* These correspond to the entries in pe_def_file->exports[].  I use
 477    exported_symbol_sections[i] to tag whether or not the symbol was
 478    defined, since we can't export symbols we don't have.  */
 479
 480 static bfd_vma *exported_symbol_offsets;
 481 static struct bfd_section **exported_symbol_sections;
 482 static int export_table_size;
 483 static int count_exported;
 484 static int count_exported_byname;
 485 static int count_with_ordinals;
 486 static const char *dll_name;
 487 static int min_ordinal, max_ordinal;
 488 static int *exported_symbols;
 489
 490 typedef struct exclude_list_struct
 491   {
 492     char *string;
 493     struct exclude_list_struct *next;
 494     exclude_type type;
 495   }
 496 exclude_list_struct;
 497
 498 static struct exclude_list_struct *excludes = 0;
 499
 500 void
 501 pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
 502 {
 503   char *local_copy;
 504   char *exclude_string;
 505
 506   local_copy = xstrdup (new_excludes);
 507
 508   exclude_string = strtok (local_copy, ",:");
 509   for (; exclude_string; exclude_string = strtok (NULL, ",:"))
 510     {
 511       struct exclude_list_struct *new_exclude;
 512
 513       new_exclude = xmalloc (sizeof (struct exclude_list_struct));
 514       new_exclude->string = xmalloc (strlen (exclude_string) + 1);
 515       strcpy (new_exclude->string, exclude_string);
 516       new_exclude->type = type;
 517       new_exclude->next = excludes;
 518       excludes = new_exclude;
 519     }
 520
 521   free (local_copy);
 522 }
 523
 524 static bfd_boolean
 525 is_import (const char* n)
 526 {
 527   return (CONST_STRNEQ (n, "__imp_"));
 528 }
 529
 530 /* abfd is a bfd containing n (or NULL)
 531    It can be used for contextual checks.  */
 532
 533 static int
 534 auto_export (bfd *abfd, def_file *d, const char *n)
 535 {
 536   def_file_export key;
 537   struct exclude_list_struct *ex;
 538   const autofilter_entry_type *afptr;
 539   const char * libname = NULL;
 540
 541   if (abfd && abfd->my_archive)
 542     libname = lbasename (abfd->my_archive->filename);
 543
 544   key.name = key.its_name = (char *) n;
 545
 546   /* Return false if n is in the d->exports table.  */
 547   if (bsearch (&key, d->exports, d->num_exports,
 548                sizeof (pe_def_file->exports[0]), pe_export_sort))
 549     return 0;
 550
 551   if (pe_dll_do_default_excludes)
 552     {
 553       const char * p;
 554       int    len;
 555
 556       if (pe_dll_extra_pe_debug)
 557         printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
 558                 n, abfd, abfd->my_archive);
 559
 560       /* First of all, make context checks:
 561          Don't export anything from standard libs.  */
 562       if (libname)
 563         {
 564           afptr = autofilter_liblist;
 565
 566           while (afptr->name)
 567             {
 568               if (libnamencmp (libname, afptr) == 0 )
 569                 return 0;
 570               afptr++;
 571             }
 572         }
 573
 574       /* Next, exclude symbols from certain startup objects.  */
 575
 576       if (abfd && (p = lbasename (abfd->filename)))
 577         {
 578           afptr = autofilter_objlist;
 579           while (afptr->name)
 580             {
 581               if (strcmp (p, afptr->name) == 0)
 582                 return 0;
 583               afptr++;
 584             }
 585         }
 586
 587       /* Don't try to blindly exclude all symbols
 588          that begin with '__'; this was tried and
 589          it is too restrictive.  Instead we have
 590          a target specific list to use:  */
 591       afptr = pe_details->autofilter_symbollist;
 592
 593       while (afptr->name)
 594         {
 595           if (strcmp (n, afptr->name) == 0)
 596             return 0;
 597
 598           afptr++;
 599         }
 600
 601       /* Next, exclude symbols starting with ...  */
 602       afptr = autofilter_symbolprefixlist;
 603       while (afptr->name)
 604         {
 605           if (strncmp (n, afptr->name, afptr->len) == 0)
 606             return 0;
 607
 608           afptr++;
 609         }
 610
 611       /* Finally, exclude symbols ending with ...  */
 612       len = strlen (n);
 613       afptr = autofilter_symbolsuffixlist;
 614       while (afptr->name)
 615         {
 616           if ((len >= afptr->len)
 617               /* Add 1 to insure match with trailing '\0'.  */
 618               && strncmp (n + len - afptr->len, afptr->name,
 619                           afptr->len + 1) == 0)
 620             return 0;
 621
 622           afptr++;
 623         }
 624     }
 625
 626   for (ex = excludes; ex; ex = ex->next)
 627     {
 628       if (ex->type == EXCLUDELIBS)
 629         {
 630           if (libname
 631               && ((filename_cmp (libname, ex->string) == 0)
 632                    || (strcasecmp ("ALL", ex->string) == 0)))
 633             return 0;
 634         }
 635       else if (ex->type == EXCLUDEFORIMPLIB)
 636         {
 637           if (filename_cmp (abfd->filename, ex->string) == 0)
 638             return 0;
 639         }
 640       else if (strcmp (n, ex->string) == 0)
 641         return 0;
 642     }
 643
 644   return 1;
 645 }
 646
 647 static void
 648 process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
 649 {
 650   int i, j;
 651   struct bfd_link_hash_entry *blhe;
 652   bfd *b;
 653   struct bfd_section *s;
 654   def_file_export *e = 0;
 655   bfd_boolean resort_needed;
 656
 657   if (!pe_def_file)
 658     pe_def_file = def_file_empty ();
 659
 660   /* First, run around to all the objects looking for the .drectve
 661      sections, and push those into the def file too.  */
 662   for (b = info->input_bfds; b; b = b->link.next)
 663     {
 664       s = bfd_get_section_by_name (b, ".drectve");
 665       if (s)
 666         {
 667           long size = s->size;
 668           char *buf = xmalloc (size);
 669
 670           bfd_get_section_contents (b, s, buf, 0, size);
 671           def_file_add_directive (pe_def_file, buf, size);
 672           free (buf);
 673         }
 674     }
 675
 676   /* Process aligned common symbol information from the
 677      .drectve sections now; common symbol allocation is
 678      done before final link, so it will be too late to
 679      process them in process_embedded_commands() called
 680      from _bfd_coff_link_input_bfd().  */
 681   if (pe_def_file->aligncomms)
 682     {
 683       def_file_aligncomm *ac = pe_def_file->aligncomms;
 684       while (ac)
 685         {
 686           struct coff_link_hash_entry *sym_hash;
 687           sym_hash = coff_link_hash_lookup (coff_hash_table (info),
 688                                             ac->symbol_name, FALSE, FALSE, FALSE);
 689           if (sym_hash && sym_hash->root.type == bfd_link_hash_common
 690               && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
 691             {
 692               sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
 693             }
 694           ac = ac->next;
 695         }
 696     }
 697
 698   /* If we are building an executable and there is nothing
 699      to export, we do not build an export table at all.  */
 700   if (bfd_link_executable (info) && pe_def_file->num_exports == 0
 701       && (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
 702     return;
 703
 704   /* Now, maybe export everything else the default way.  */
 705   if ((pe_dll_export_everything || pe_def_file->num_exports == 0)
 706       && !pe_dll_exclude_all_symbols)
 707     {
 708       for (b = info->input_bfds; b; b = b->link.next)
 709         {
 710           asymbol **symbols;
 711           int nsyms;
 712
 713           if (!bfd_generic_link_read_symbols (b))
 714             {
 715               einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
 716               return;
 717             }
 718
 719           symbols = bfd_get_outsymbols (b);
 720           nsyms = bfd_get_symcount (b);
 721
 722           for (j = 0; j < nsyms; j++)
 723             {
 724               /* We should export symbols which are either global or not
 725                  anything at all.  (.bss data is the latter)
 726                  We should not export undefined symbols.  */
 727               bfd_boolean would_export
 728                 = (symbols[j]->section != bfd_und_section_ptr
 729                    && ((symbols[j]->flags & BSF_GLOBAL)
 730                        || (symbols[j]->flags == 0)));
 731               if (link_info.version_info && would_export)
 732                 would_export
 733                   = !bfd_hide_sym_by_version (link_info.version_info,
 734                                               symbols[j]->name);
 735               if (would_export)
 736                 {
 737                   const char *sn = symbols[j]->name;
 738
 739                   /* We should not re-export imported stuff.  */
 740                   {
 741                     char *name;
 742                     if (is_import (sn))
 743                       continue;
 744
 745                     name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
 746                     sprintf (name, "%s%s", "__imp_", sn);
 747
 748                     blhe = bfd_link_hash_lookup (info->hash, name,
 749                                                  FALSE, FALSE, FALSE);
 750                     free (name);
 751
 752                     if (blhe && blhe->type == bfd_link_hash_defined)
 753                       continue;
 754                   }
 755
 756                   if (pe_details->underscored && *sn == '_')
 757                     sn++;
 758
 759                   if (auto_export (b, pe_def_file, sn))
 760                     {
 761                       int is_dup = 0;
 762                       def_file_export *p;
 763
 764                       p = def_file_add_export (pe_def_file, sn, 0, -1,
 765                                                NULL, &is_dup);
 766                       /* Fill data flag properly, from dlltool.c.  */
 767                       if (!is_dup)
 768                         p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
 769                     }
 770                 }
 771             }
 772         }
 773     }
 774
 775 #undef NE
 776 #define NE pe_def_file->num_exports
 777
 778   /* Don't create an empty export table.  */
 779   if (NE == 0)
 780     return;
 781
 782   resort_needed = FALSE;
 783
 784   /* Canonicalize the export list.  */
 785   if (pe_dll_kill_ats)
 786     {
 787       for (i = 0; i < NE; i++)
 788         {
 789           /* Check for fastcall/stdcall-decoration, but ignore
 790              C++ mangled names.  */
 791           if (pe_def_file->exports[i].name[0] != '?'
 792               && strchr (pe_def_file->exports[i].name, '@'))
 793             {
 794               /* This will preserve internal_name, which may have been
 795                  pointing to the same memory as name, or might not
 796                  have.  */
 797               int lead_at = (*pe_def_file->exports[i].name == '@');
 798               char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
 799               char *tmp_at = strrchr (tmp, '@');
 800
 801               if (tmp_at)
 802                 *tmp_at = 0;
 803               else
 804                 einfo (_("%X%P: cannot export %s: invalid export name\n"),
 805                        pe_def_file->exports[i].name);
 806               pe_def_file->exports[i].name = tmp;
 807               resort_needed = TRUE;
 808             }
 809         }
 810     }
 811
 812   /* Re-sort the exports table as we have possibly changed the order
 813      by removing leading @.  */
 814   if (resort_needed)
 815     qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
 816            pe_export_sort);
 817
 818   if (pe_dll_stdcall_aliases)
 819     {
 820       for (i = 0; i < NE; i++)
 821         {
 822           if (is_import (pe_def_file->exports[i].name))
 823             continue;
 824
 825           if (strchr (pe_def_file->exports[i].name, '@'))
 826             {
 827               int is_dup = 1;
 828               int lead_at = (*pe_def_file->exports[i].name == '@');
 829               char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
 830
 831               *(strchr (tmp, '@')) = 0;
 832               if (auto_export (NULL, pe_def_file, tmp))
 833                 def_file_add_export (pe_def_file, tmp,
 834                                      pe_def_file->exports[i].internal_name,
 835                                      -1, NULL, &is_dup);
 836               if (is_dup)
 837                 free (tmp);
 838             }
 839         }
 840     }
 841
 842   /* Convenience, but watch out for it changing.  */
 843   e = pe_def_file->exports;
 844
 845   for (i = 0, j = 0; i < NE; i++)
 846     {
 847       if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
 848         {
 849           /* This is a duplicate.  */
 850           if (e[j - 1].ordinal != -1
 851               && e[i].ordinal != -1
 852               && e[j - 1].ordinal != e[i].ordinal)
 853             {
 854               if (pe_dll_warn_dup_exports)
 855                 /* xgettext:c-format */
 856                 einfo (_("%X%P: error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
 857                        e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
 858             }
 859           else
 860             {
 861               if (pe_dll_warn_dup_exports)
 862                 /* xgettext:c-format */
 863                 einfo (_("%P: warning, duplicate EXPORT: %s\n"),
 864                        e[j - 1].name);
 865             }
 866
 867           if (e[i].ordinal != -1)
 868             e[j - 1].ordinal = e[i].ordinal;
 869           e[j - 1].flag_private |= e[i].flag_private;
 870           e[j - 1].flag_constant |= e[i].flag_constant;
 871           e[j - 1].flag_noname |= e[i].flag_noname;
 872           e[j - 1].flag_data |= e[i].flag_data;
 873           if (e[i].name)
 874             free (e[i].name);
 875           if (e[i].internal_name)
 876             free (e[i].internal_name);
 877           if (e[i].its_name)
 878             free (e[i].its_name);
 879         }
 880       else
 881         {
 882           if (i != j)
 883             e[j] = e[i];
 884           j++;
 885         }
 886     }
 887   pe_def_file->num_exports = j; /* == NE */
 888
 889   exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
 890   exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
 891
 892   memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
 893   max_ordinal = 0;
 894   min_ordinal = 65536;
 895   count_exported = 0;
 896   count_exported_byname = 0;
 897   count_with_ordinals = 0;
 898
 899   for (i = 0; i < NE; i++)
 900     {
 901       char *int_name = pe_def_file->exports[i].internal_name;
 902       char *name;
 903
 904       /* PR 19803: Make sure that any exported symbol does not get garbage collected.  */
 905       lang_add_gc_name (int_name);
 906
 907       name = xmalloc (strlen (int_name) + 2);
 908       if (pe_details->underscored && int_name[0] != '@')
 909         {
 910           *name = '_';
 911           strcpy (name + 1, int_name);
 912
 913           /* PR 19803: The alias must be preserved as well.  */
 914           lang_add_gc_name (xstrdup (name));
 915         }
 916       else
 917         strcpy (name, int_name);
 918
 919       blhe = bfd_link_hash_lookup (info->hash,
 920                                    name,
 921                                    FALSE, FALSE, TRUE);
 922
 923       if (blhe
 924           && (blhe->type == bfd_link_hash_defined
 925               || (blhe->type == bfd_link_hash_common)))
 926         {
 927           count_exported++;
 928           if (!pe_def_file->exports[i].flag_noname)
 929             count_exported_byname++;
 930
 931           /* Only fill in the sections. The actual offsets are computed
 932              in fill_exported_offsets() after common symbols are laid
 933              out.  */
 934           if (blhe->type == bfd_link_hash_defined)
 935             exported_symbol_sections[i] = blhe->u.def.section;
 936           else
 937             exported_symbol_sections[i] = blhe->u.c.p->section;
 938
 939           if (pe_def_file->exports[i].ordinal != -1)
 940             {
 941               if (max_ordinal < pe_def_file->exports[i].ordinal)
 942                 max_ordinal = pe_def_file->exports[i].ordinal;
 943               if (min_ordinal > pe_def_file->exports[i].ordinal)
 944                 min_ordinal = pe_def_file->exports[i].ordinal;
 945               count_with_ordinals++;
 946             }
 947         }
 948       /* Check for forward exports.  These are indicated in DEF files by an
 949          export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
 950          but we must take care not to be fooled when the user wants to export
 951          a symbol that actually really has a dot in it, so we only check
 952          for them here, after real defined symbols have already been matched.  */
 953       else if (strchr (int_name, '.'))
 954         {
 955           count_exported++;
 956           if (!pe_def_file->exports[i].flag_noname)
 957             count_exported_byname++;
 958
 959           pe_def_file->exports[i].flag_forward = 1;
 960
 961           if (pe_def_file->exports[i].ordinal != -1)
 962             {
 963               if (max_ordinal < pe_def_file->exports[i].ordinal)
 964                 max_ordinal = pe_def_file->exports[i].ordinal;
 965               if (min_ordinal > pe_def_file->exports[i].ordinal)
 966                 min_ordinal = pe_def_file->exports[i].ordinal;
 967               count_with_ordinals++;
 968             }
 969         }
 970       else if (blhe && blhe->type == bfd_link_hash_undefined)
 971         {
 972           /* xgettext:c-format */
 973           einfo (_("%X%P: cannot export %s: symbol not defined\n"),
 974                  int_name);
 975         }
 976       else if (blhe)
 977         {
 978           /* xgettext:c-format */
 979           einfo (_("%X%P: cannot export %s: symbol wrong type (%d vs %d)\n"),
 980                  int_name,
 981                  blhe->type, bfd_link_hash_defined);
 982         }
 983       else
 984         {
 985           /* xgettext:c-format */
 986           einfo (_("%X%P: cannot export %s: symbol not found\n"),
 987                  int_name);
 988         }
 989       free (name);
 990     }
 991 }
 992
 993 /* Build the bfd that will contain .edata and .reloc sections.  */
 994
 995 static void
 996 build_filler_bfd (int include_edata)
 997 {
 998   lang_input_statement_type *filler_file;
 999   filler_file = lang_add_input_file ("dll stuff",
1000                                      lang_input_file_is_fake_enum,
1001                                      NULL);
1002   filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff",
1003                                                   link_info.output_bfd);
1004   if (filler_bfd == NULL
1005       || !bfd_set_arch_mach (filler_bfd,
1006                              bfd_get_arch (link_info.output_bfd),
1007                              bfd_get_mach (link_info.output_bfd)))
1008     {
1009       einfo (_("%F%P: can not create BFD: %E\n"));
1010       return;
1011     }
1012
1013   if (include_edata)
1014     {
1015       edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
1016       if (edata_s == NULL
1017           || !bfd_set_section_flags (filler_bfd, edata_s,
1018                                      (SEC_HAS_CONTENTS
1019                                       | SEC_ALLOC
1020                                       | SEC_LOAD
1021                                       | SEC_KEEP
1022                                       | SEC_IN_MEMORY)))
1023         {
1024           einfo (_("%X%P: can not create .edata section: %E\n"));
1025           return;
1026         }
1027       bfd_set_section_size (filler_bfd, edata_s, edata_sz);
1028     }
1029
1030   reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
1031   if (reloc_s == NULL
1032       || !bfd_set_section_flags (filler_bfd, reloc_s,
1033                                  (SEC_HAS_CONTENTS
1034                                   | SEC_ALLOC
1035                                   | SEC_LOAD
1036                                   | SEC_KEEP
1037                                   | SEC_IN_MEMORY)))
1038     {
1039       einfo (_("%X%P: can not create .reloc section: %E\n"));
1040       return;
1041     }
1042
1043   bfd_set_section_size (filler_bfd, reloc_s, 0);
1044
1045   ldlang_add_file (filler_file);
1046 }
1047
1048 /* Gather all the exported symbols and build the .edata section.  */
1049
1050 static void
1051 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1052 {
1053   int i, next_ordinal;
1054   int name_table_size = 0;
1055   const char *dlnp;
1056
1057   /* First, we need to know how many exported symbols there are,
1058      and what the range of ordinals is.  */
1059   if (pe_def_file->name)
1060     dll_name = pe_def_file->name;
1061   else
1062     {
1063       dll_name = abfd->filename;
1064
1065       for (dlnp = dll_name; *dlnp; dlnp++)
1066         if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
1067           dll_name = dlnp + 1;
1068     }
1069
1070   if (count_with_ordinals && max_ordinal > count_exported)
1071     {
1072       if (min_ordinal > max_ordinal - count_exported + 1)
1073         min_ordinal = max_ordinal - count_exported + 1;
1074     }
1075   else
1076     {
1077       min_ordinal = 1;
1078       max_ordinal = count_exported;
1079     }
1080
1081   export_table_size = max_ordinal - min_ordinal + 1;
1082   exported_symbols = xmalloc (export_table_size * sizeof (int));
1083   for (i = 0; i < export_table_size; i++)
1084     exported_symbols[i] = -1;
1085
1086   /* Now we need to assign ordinals to those that don't have them.  */
1087   for (i = 0; i < NE; i++)
1088     {
1089       if (exported_symbol_sections[i]
1090           || pe_def_file->exports[i].flag_forward)
1091         {
1092           if (pe_def_file->exports[i].ordinal != -1)
1093             {
1094               int ei = pe_def_file->exports[i].ordinal - min_ordinal;
1095               int pi = exported_symbols[ei];
1096
1097               if (pi != -1)
1098                 {
1099                   /* xgettext:c-format */
1100                   einfo (_("%X%P: error: ordinal used twice: %d (%s vs %s)\n"),
1101                          pe_def_file->exports[i].ordinal,
1102                          pe_def_file->exports[i].name,
1103                          pe_def_file->exports[pi].name);
1104                 }
1105               exported_symbols[ei] = i;
1106             }
1107           if (pe_def_file->exports[i].its_name)
1108             name_table_size += strlen (pe_def_file->exports[i].its_name) + 1;
1109           else
1110             name_table_size += strlen (pe_def_file->exports[i].name) + 1;
1111         }
1112
1113       /* Reserve space for the forward name. */
1114       if (pe_def_file->exports[i].flag_forward)
1115         {
1116           name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
1117         }
1118     }
1119
1120   next_ordinal = min_ordinal;
1121   for (i = 0; i < NE; i++)
1122     if ((exported_symbol_sections[i]
1123          || pe_def_file->exports[i].flag_forward)
1124         && pe_def_file->exports[i].ordinal == -1)
1125       {
1126         while (exported_symbols[next_ordinal - min_ordinal] != -1)
1127           next_ordinal++;
1128
1129         exported_symbols[next_ordinal - min_ordinal] = i;
1130         pe_def_file->exports[i].ordinal = next_ordinal;
1131       }
1132
1133   /* PR 12969: Check for more than 1^16 ordinals.  */
1134   if (max_ordinal > 65535 || next_ordinal > 65535)
1135     /* xgettext:c-format */
1136     einfo(_("%X%P: error: export ordinal too large: %d\n"),
1137           max_ordinal > next_ordinal ? max_ordinal : next_ordinal);
1138
1139   /* OK, now we can allocate some memory.  */
1140   edata_sz = (40                                /* directory */
1141               + 4 * export_table_size           /* addresses */
1142               + 4 * count_exported_byname       /* name ptrs */
1143               + 2 * count_exported_byname       /* ordinals */
1144               + name_table_size + strlen (dll_name) + 1);
1145 }
1146
1147 /* Fill the exported symbol offsets. The preliminary work has already
1148    been done in process_def_file_and_drectve().  */
1149
1150 static void
1151 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
1152 {
1153   int i;
1154   struct bfd_link_hash_entry *blhe;
1155
1156   for (i = 0; i < pe_def_file->num_exports; i++)
1157     {
1158       char *name;
1159
1160       name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
1161       if (pe_details->underscored
1162           && *pe_def_file->exports[i].internal_name != '@')
1163         {
1164           *name = '_';
1165           strcpy (name + 1, pe_def_file->exports[i].internal_name);
1166         }
1167       else
1168         strcpy (name, pe_def_file->exports[i].internal_name);
1169
1170       blhe = bfd_link_hash_lookup (info->hash,
1171                                    name,
1172                                    FALSE, FALSE, TRUE);
1173
1174       if (blhe && blhe->type == bfd_link_hash_defined)
1175         exported_symbol_offsets[i] = blhe->u.def.value;
1176
1177       free (name);
1178     }
1179 }
1180
1181 static void
1182 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1183 {
1184   int s, hint;
1185   unsigned char *edirectory;
1186   unsigned char *eaddresses;
1187   unsigned char *enameptrs;
1188   unsigned char *eordinals;
1189   char *enamestr;
1190
1191   edata_d = xmalloc (edata_sz);
1192
1193   /* Note use of array pointer math here.  */
1194   edirectory = edata_d;
1195   eaddresses = edirectory + 40;
1196   enameptrs = eaddresses + 4 * export_table_size;
1197   eordinals = enameptrs + 4 * count_exported_byname;
1198   enamestr = (char *) eordinals + 2 * count_exported_byname;
1199
1200 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1201                    + edata_s->output_section->vma - image_base)
1202
1203   memset (edata_d, 0, edata_sz);
1204
1205   if (pe_data (abfd)->insert_timestamp)
1206     H_PUT_32 (abfd, time (0), edata_d + 4);
1207
1208   if (pe_def_file->version_major != -1)
1209     {
1210       bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1211       bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1212     }
1213
1214   bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1215   strcpy (enamestr, dll_name);
1216   enamestr += strlen (enamestr) + 1;
1217   bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1218   bfd_put_32 (abfd, export_table_size, edata_d + 20);
1219   bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1220   bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1221   bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1222   bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1223
1224   fill_exported_offsets (abfd, info);
1225
1226   /* Ok, now for the filling in part.
1227      Scan alphabetically - ie the ordering in the exports[] table,
1228      rather than by ordinal - the ordering in the exported_symbol[]
1229      table.  See dlltool.c and:
1230         http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1231      for more information.  */
1232   hint = 0;
1233   for (s = 0; s < NE; s++)
1234     {
1235       struct bfd_section *ssec = exported_symbol_sections[s];
1236       if (pe_def_file->exports[s].ordinal != -1
1237           && (pe_def_file->exports[s].flag_forward || ssec != NULL))
1238         {
1239           int ord = pe_def_file->exports[s].ordinal;
1240
1241           if (pe_def_file->exports[s].flag_forward)
1242             {
1243               bfd_put_32 (abfd, ERVA (enamestr),
1244                           eaddresses + 4 * (ord - min_ordinal));
1245
1246               strcpy (enamestr, pe_def_file->exports[s].internal_name);
1247               enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1248             }
1249           else
1250             {
1251               bfd_vma srva = (exported_symbol_offsets[s]
1252                                     + ssec->output_section->vma
1253                                     + ssec->output_offset);
1254
1255               bfd_put_32 (abfd, srva - image_base,
1256                           eaddresses + 4 * (ord - min_ordinal));
1257             }
1258
1259           if (!pe_def_file->exports[s].flag_noname)
1260             {
1261               char *ename = pe_def_file->exports[s].name;
1262               if (pe_def_file->exports[s].its_name)
1263                 ename = pe_def_file->exports[s].its_name;
1264
1265               bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1266               enameptrs += 4;
1267               strcpy (enamestr, ename);
1268               enamestr += strlen (enamestr) + 1;
1269               bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1270               eordinals += 2;
1271               pe_def_file->exports[s].hint = hint++;
1272             }
1273         }
1274     }
1275 }
1276
1277
1278 static struct bfd_section *current_sec;
1279
1280 static void
1281 pe_walk_relocs (struct bfd_link_info *info,
1282                 char *name,
1283                 const char *symname,
1284                 struct bfd_hash_table *import_hash,
1285                 void (*cb) (arelent *, asection *, char *, const char *))
1286 {
1287   bfd *b;
1288   asection *s;
1289
1290   for (b = info->input_bfds; b; b = b->link.next)
1291     {
1292       asymbol **symbols;
1293
1294       if (!bfd_generic_link_read_symbols (b))
1295         {
1296           einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
1297           return;
1298         }
1299
1300       symbols = bfd_get_outsymbols (b);
1301
1302       for (s = b->sections; s; s = s->next)
1303         {
1304           arelent **relocs;
1305           int relsize, nrelocs, i;
1306           int flags = bfd_get_section_flags (b, s);
1307
1308           /* Skip discarded linkonce sections.  */
1309           if (flags & SEC_LINK_ONCE
1310               && s->output_section == bfd_abs_section_ptr)
1311             continue;
1312
1313           current_sec = s;
1314
1315           relsize = bfd_get_reloc_upper_bound (b, s);
1316           relocs = xmalloc (relsize);
1317           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1318
1319           for (i = 0; i < nrelocs; i++)
1320             {
1321               struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1322
1323               /* Warning: the callback needs to be passed NAME directly.  */
1324               if (import_hash)
1325                 {
1326                   if (bfd_hash_lookup (import_hash, sym->name, FALSE, FALSE))
1327                     {
1328                       strcpy (name, sym->name);
1329                       cb (relocs[i], s, name, symname);
1330                     }
1331                 }
1332               else
1333                 {
1334                   if (strcmp (name, sym->name) == 0)
1335                     cb (relocs[i], s, name, symname);
1336                 }
1337             }
1338
1339           free (relocs);
1340
1341           /* Warning: the allocated symbols are remembered in BFD and reused
1342              later, so don't free them! */
1343           /* free (symbols); */
1344         }
1345     }
1346 }
1347
1348 void
1349 pe_find_data_imports (const char *symhead,
1350                       void (*cb) (arelent *, asection *, char *, const char *))
1351 {
1352   struct bfd_link_hash_entry *undef;
1353   const size_t headlen = strlen (symhead);
1354   size_t namelen = 0;
1355   char *buf, *name;
1356   struct bfd_hash_table *import_hash;
1357
1358   for (undef = link_info.hash->undefs; undef; undef = undef->u.undef.next)
1359     if (undef->type == bfd_link_hash_undefined)
1360       {
1361         size_t len = strlen (undef->root.string);
1362         if (namelen < len)
1363           namelen = len;
1364       }
1365   if (namelen == 0)
1366     return;
1367
1368   /* For the pseudo-relocation support version 2, we can collect the symbols
1369      that are subject to auto-import and adjust the relocations en masse.  */
1370   if (link_info.pei386_runtime_pseudo_reloc == 2)
1371     {
1372       import_hash
1373         = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
1374       if (!bfd_hash_table_init (import_hash,
1375                                 bfd_hash_newfunc,
1376                                 sizeof (struct bfd_hash_entry)))
1377         einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1378     }
1379   else
1380     import_hash = NULL;
1381
1382   /* We are being a bit cunning here.  The buffer will have space for
1383      prefixes at the beginning.  The prefix is modified here and in a
1384      number of functions called from this function.  */
1385 #define PREFIX_LEN 32
1386   buf = xmalloc (PREFIX_LEN + namelen + 1);
1387   name = buf + PREFIX_LEN;
1388
1389   for (undef = link_info.hash->undefs; undef; undef = undef->u.undef.next)
1390     if (undef->type == bfd_link_hash_undefined)
1391       {
1392         struct bfd_link_hash_entry *sym;
1393         char *impname;
1394
1395         if (pe_dll_extra_pe_debug)
1396           printf ("%s:%s\n", __FUNCTION__, undef->root.string);
1397
1398         strcpy (name, undef->root.string);
1399         impname = name - (sizeof "__imp_" - 1);
1400         memcpy (impname, "__imp_", sizeof "__imp_" - 1);
1401
1402         sym = bfd_link_hash_lookup (link_info.hash, impname, 0, 0, 1);
1403
1404         if (sym && sym->type == bfd_link_hash_defined)
1405           {
1406             if (import_hash)
1407               bfd_hash_lookup (import_hash, undef->root.string, TRUE, FALSE);
1408             else
1409               {
1410                 bfd *b = sym->u.def.section->owner;
1411                 const char *symname = NULL;
1412                 asymbol **symbols;
1413                 int nsyms, i;
1414
1415                 if (!bfd_generic_link_read_symbols (b))
1416                   {
1417                     einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
1418                     return;
1419                   }
1420
1421                 symbols = bfd_get_outsymbols (b);
1422                 nsyms = bfd_get_symcount (b);
1423
1424                 for (i = 0; i < nsyms; i++)
1425                   if (strncmp (symbols[i]->name, symhead, headlen) == 0)
1426                     {
1427                       if (pe_dll_extra_pe_debug)
1428                         printf ("->%s\n", symbols[i]->name);
1429
1430                       symname = symbols[i]->name + headlen;
1431                       break;
1432                     }
1433
1434                 /* If the symobl isn't part of an import table, there is no
1435                    point in building a fixup, this would give rise to link
1436                    errors for mangled symbols instead of the original one.  */
1437                 if (symname)
1438                   pe_walk_relocs (&link_info, name, symname, NULL, cb);
1439                 else
1440                   continue;
1441               }
1442
1443             /* Let's differentiate it somehow from defined.  */
1444             undef->type = bfd_link_hash_defweak;
1445             undef->u.def.value = sym->u.def.value;
1446             undef->u.def.section = sym->u.def.section;
1447
1448             if (link_info.pei386_auto_import == -1)
1449               {
1450                 static bfd_boolean warned = FALSE;
1451
1452                 info_msg (_("Info: resolving %s by linking to %s "
1453                             "(auto-import)\n"), name, impname);
1454
1455                 /* PR linker/4844.  */
1456                 if (!warned)
1457                   {
1458                     einfo (_("%P: warning: auto-importing has been activated "
1459                              "without --enable-auto-import specified on the "
1460                              "command line; this should work unless it "
1461                              "involves constant data structures referencing "
1462                              "symbols from auto-imported DLLs\n"));
1463                     warned = TRUE;
1464                   }
1465               }
1466           }
1467       }
1468
1469   /* If we have the import hash table, walk the relocations only once.  */
1470   if (import_hash)
1471     {
1472       pe_walk_relocs (&link_info, name, NULL, import_hash, cb);
1473       bfd_hash_table_free (import_hash);
1474       free (import_hash);
1475     }
1476
1477   free (buf);
1478 }
1479
1480 /* Gather all the relocations and build the .reloc section.  */
1481
1482 static void
1483 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1484 {
1485
1486   /* For .reloc stuff.  */
1487   reloc_data_type *reloc_data;
1488   int total_relocs = 0;
1489   int i;
1490   bfd_vma sec_page = (bfd_vma) -1;
1491   bfd_vma page_ptr, page_count;
1492   int bi;
1493   bfd *b;
1494   struct bfd_section *s;
1495
1496   total_relocs = 0;
1497   for (b = info->input_bfds; b; b = b->link.next)
1498     for (s = b->sections; s; s = s->next)
1499       total_relocs += s->reloc_count;
1500
1501   reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1502
1503   total_relocs = 0;
1504   bi = 0;
1505   for (bi = 0, b = info->input_bfds; b; bi++, b = b->link.next)
1506     {
1507       arelent **relocs;
1508       int relsize, nrelocs;
1509
1510       for (s = b->sections; s; s = s->next)
1511         {
1512           bfd_vma sec_vma = s->output_section->vma + s->output_offset;
1513           asymbol **symbols;
1514
1515           /* If it's not loaded, we don't need to relocate it this way.  */
1516           if (!(s->output_section->flags & SEC_LOAD))
1517             continue;
1518
1519           /* I don't know why there would be a reloc for these, but I've
1520              seen it happen - DJ  */
1521           if (s->output_section == bfd_abs_section_ptr)
1522             continue;
1523
1524           if (s->output_section->vma == 0)
1525             {
1526               /* Huh?  Shouldn't happen, but punt if it does.  */
1527               einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
1528                      s->output_section->name, s->output_section->index,
1529                      s->output_section->flags);
1530               continue;
1531             }
1532
1533           if (!bfd_generic_link_read_symbols (b))
1534             {
1535               einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
1536               return;
1537             }
1538
1539           symbols = bfd_get_outsymbols (b);
1540           relsize = bfd_get_reloc_upper_bound (b, s);
1541           relocs = xmalloc (relsize);
1542           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1543
1544           for (i = 0; i < nrelocs; i++)
1545             {
1546               if (pe_dll_extra_pe_debug)
1547                 {
1548                   struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1549                   printf ("rel: %s\n", sym->name);
1550                 }
1551               if (!relocs[i]->howto->pc_relative
1552                   && relocs[i]->howto->type != pe_details->imagebase_reloc)
1553                 {
1554                   struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1555
1556                   /* Don't create relocs for undefined weak symbols.  */
1557                   if (sym->flags == BSF_WEAK)
1558                     {
1559                       struct bfd_link_hash_entry *blhe
1560                         = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
1561                                                 FALSE, FALSE, FALSE);
1562                       if (blhe && blhe->type == bfd_link_hash_undefweak)
1563                         {
1564                           /* Check aux sym and see if it is defined or not. */
1565                           struct coff_link_hash_entry *h, *h2;
1566                           h = (struct coff_link_hash_entry *)blhe;
1567                           if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
1568                             continue;
1569                           h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
1570                                                 [h->aux->x_sym.x_tagndx.l];
1571                           /* We don't want a base reloc if the aux sym is not
1572                              found, undefined, or if it is the constant ABS
1573                              zero default value.  (We broaden that slightly by
1574                              not testing the value, just the section; there's
1575                              no reason we'd want a reference to any absolute
1576                              address to get relocated during rebasing).  */
1577                           if (!h2 || h2->root.type == bfd_link_hash_undefined
1578                                 || h2->root.u.def.section == bfd_abs_section_ptr)
1579                             continue;
1580                         }
1581                       else if (!blhe || blhe->type != bfd_link_hash_defined)
1582                         continue;
1583                     }
1584                   /* Nor for Dwarf FDE references to discarded sections.  */
1585                   else if (bfd_is_abs_section (sym->section->output_section))
1586                     {
1587                       /* We only ignore relocs from .eh_frame sections, as
1588                          they are discarded by the final link rather than
1589                          resolved against the kept section.  */
1590                       if (!strcmp (s->name, ".eh_frame"))
1591                         continue;
1592                     }
1593
1594                   reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1595
1596 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1597
1598                   switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1599                                          relocs[i]->howto->rightshift)
1600                     {
1601 #ifdef pe_use_x86_64
1602                     case BITS_AND_SHIFT (64, 0):
1603                       reloc_data[total_relocs].type = 10;
1604                       total_relocs++;
1605                       break;
1606 #endif
1607                     case BITS_AND_SHIFT (32, 0):
1608                       reloc_data[total_relocs].type = 3;
1609                       total_relocs++;
1610                       break;
1611                     case BITS_AND_SHIFT (16, 0):
1612                       reloc_data[total_relocs].type = 2;
1613                       total_relocs++;
1614                       break;
1615                     case BITS_AND_SHIFT (16, 16):
1616                       reloc_data[total_relocs].type = 4;
1617                       /* FIXME: we can't know the symbol's right value
1618                          yet, but we probably can safely assume that
1619                          CE will relocate us in 64k blocks, so leaving
1620                          it zero is safe.  */
1621                       reloc_data[total_relocs].extra = 0;
1622                       total_relocs++;
1623                       break;
1624                     case BITS_AND_SHIFT (26, 2):
1625                       reloc_data[total_relocs].type = 5;
1626                       total_relocs++;
1627                       break;
1628                     case BITS_AND_SHIFT (24, 2):
1629                       /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1630                          Those ARM_xxx definitions should go in proper
1631                          header someday.  */
1632                       if (relocs[i]->howto->type == 0
1633                           /* Older GNU linkers used 5 instead of 0 for this reloc.  */
1634                           || relocs[i]->howto->type == 5)
1635                         /* This is an ARM_26D reloc, which is an ARM_26 reloc
1636                            that has already been fully processed during a
1637                            previous link stage, so ignore it here.  */
1638                         break;
1639                       /* Fall through.  */
1640                     default:
1641                       /* xgettext:c-format */
1642                       einfo (_("%X%P: error: %d-bit reloc in dll\n"),
1643                              relocs[i]->howto->bitsize);
1644                       break;
1645                     }
1646                 }
1647             }
1648           free (relocs);
1649           /* Warning: the allocated symbols are remembered in BFD and
1650              reused later, so don't free them!  */
1651         }
1652     }
1653
1654   /* At this point, we have total_relocs relocation addresses in
1655      reloc_addresses, which are all suitable for the .reloc section.
1656      We must now create the new sections.  */
1657   qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1658
1659   for (i = 0; i < total_relocs; i++)
1660     {
1661       bfd_vma this_page = (reloc_data[i].vma >> 12);
1662
1663       if (this_page != sec_page)
1664         {
1665           reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align.  */
1666           reloc_sz += 8;
1667           sec_page = this_page;
1668         }
1669
1670       reloc_sz += 2;
1671
1672       if (reloc_data[i].type == 4)
1673         reloc_sz += 2;
1674     }
1675
1676   reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align.  */
1677   reloc_d = xmalloc (reloc_sz);
1678   sec_page = (bfd_vma) -1;
1679   reloc_sz = 0;
1680   page_ptr = (bfd_vma) -1;
1681   page_count = 0;
1682
1683   for (i = 0; i < total_relocs; i++)
1684     {
1685       bfd_vma rva = reloc_data[i].vma - image_base;
1686       bfd_vma this_page = (rva & ~0xfff);
1687
1688       if (this_page != sec_page)
1689         {
1690           while (reloc_sz & 3)
1691             reloc_d[reloc_sz++] = 0;
1692
1693           if (page_ptr != (bfd_vma) -1)
1694             bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1695
1696           bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1697           page_ptr = reloc_sz;
1698           reloc_sz += 8;
1699           sec_page = this_page;
1700           page_count = 0;
1701         }
1702
1703       bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1704                   reloc_d + reloc_sz);
1705       reloc_sz += 2;
1706
1707       if (reloc_data[i].type == 4)
1708         {
1709           bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1710           reloc_sz += 2;
1711         }
1712
1713       page_count++;
1714     }
1715
1716   while (reloc_sz & 3)
1717     reloc_d[reloc_sz++] = 0;
1718
1719   if (page_ptr != (bfd_vma) -1)
1720     bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1721
1722   while (reloc_sz < reloc_s->size)
1723     reloc_d[reloc_sz++] = 0;
1724 }
1725
1726 /* Given the exiting def_file structure, print out a .DEF file that
1727    corresponds to it.  */
1728
1729 static void
1730 quoteput (char *s, FILE *f, int needs_quotes)
1731 {
1732   char *cp;
1733
1734   for (cp = s; *cp; cp++)
1735     if (*cp == '\''
1736         || *cp == '"'
1737         || *cp == '\\'
1738         || ISSPACE (*cp)
1739         || *cp == ','
1740         || *cp == ';')
1741       needs_quotes = 1;
1742
1743   if (needs_quotes)
1744     {
1745       putc ('"', f);
1746
1747       while (*s)
1748         {
1749           if (*s == '"' || *s == '\\')
1750             putc ('\\', f);
1751
1752           putc (*s, f);
1753           s++;
1754         }
1755
1756       putc ('"', f);
1757     }
1758   else
1759     fputs (s, f);
1760 }
1761
1762 void
1763 pe_dll_generate_def_file (const char *pe_out_def_filename)
1764 {
1765   int i;
1766   FILE *out = fopen (pe_out_def_filename, "w");
1767
1768   if (out == NULL)
1769     /* xgettext:c-format */
1770     einfo (_("%P: can't open output def file %s\n"),
1771            pe_out_def_filename);
1772
1773   if (pe_def_file)
1774     {
1775       if (pe_def_file->name)
1776         {
1777           if (pe_def_file->is_dll)
1778             fprintf (out, "LIBRARY ");
1779           else
1780             fprintf (out, "NAME ");
1781
1782           quoteput (pe_def_file->name, out, 1);
1783
1784           if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
1785             {
1786               fprintf (out, " BASE=0x");
1787               fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
1788             }
1789           fprintf (out, "\n");
1790         }
1791
1792       if (pe_def_file->description)
1793         {
1794           fprintf (out, "DESCRIPTION ");
1795           quoteput (pe_def_file->description, out, 1);
1796           fprintf (out, "\n");
1797         }
1798
1799       if (pe_def_file->version_minor != -1)
1800         fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1801                  pe_def_file->version_minor);
1802       else if (pe_def_file->version_major != -1)
1803         fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1804
1805       if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1806         fprintf (out, "\n");
1807
1808       if (pe_def_file->stack_commit != -1)
1809         fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1810                  pe_def_file->stack_reserve, pe_def_file->stack_commit);
1811       else if (pe_def_file->stack_reserve != -1)
1812         fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1813
1814       if (pe_def_file->heap_commit != -1)
1815         fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1816                  pe_def_file->heap_reserve, pe_def_file->heap_commit);
1817       else if (pe_def_file->heap_reserve != -1)
1818         fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1819
1820       if (pe_def_file->num_section_defs > 0)
1821         {
1822           fprintf (out, "\nSECTIONS\n\n");
1823
1824           for (i = 0; i < pe_def_file->num_section_defs; i++)
1825             {
1826               fprintf (out, "    ");
1827               quoteput (pe_def_file->section_defs[i].name, out, 0);
1828
1829               if (pe_def_file->section_defs[i].class)
1830                 {
1831                   fprintf (out, " CLASS ");
1832                   quoteput (pe_def_file->section_defs[i].class, out, 0);
1833                 }
1834
1835               if (pe_def_file->section_defs[i].flag_read)
1836                 fprintf (out, " READ");
1837
1838               if (pe_def_file->section_defs[i].flag_write)
1839                 fprintf (out, " WRITE");
1840
1841               if (pe_def_file->section_defs[i].flag_execute)
1842                 fprintf (out, " EXECUTE");
1843
1844               if (pe_def_file->section_defs[i].flag_shared)
1845                 fprintf (out, " SHARED");
1846
1847               fprintf (out, "\n");
1848             }
1849         }
1850
1851       if (pe_def_file->num_exports > 0)
1852         {
1853           fprintf (out, "EXPORTS\n");
1854
1855           for (i = 0; i < pe_def_file->num_exports; i++)
1856             {
1857               def_file_export *e = pe_def_file->exports + i;
1858               fprintf (out, "    ");
1859               quoteput (e->name, out, 0);
1860
1861               if (e->internal_name && strcmp (e->internal_name, e->name))
1862                 {
1863                   fprintf (out, " = ");
1864                   quoteput (e->internal_name, out, 0);
1865                 }
1866
1867               if (e->ordinal != -1)
1868                 fprintf (out, " @%d", e->ordinal);
1869
1870               if (e->flag_private)
1871                 fprintf (out, " PRIVATE");
1872
1873               if (e->flag_constant)
1874                 fprintf (out, " CONSTANT");
1875
1876               if (e->flag_noname)
1877                 fprintf (out, " NONAME");
1878
1879               if (e->flag_data)
1880                 fprintf (out, " DATA");
1881
1882               fprintf (out, "\n");
1883             }
1884         }
1885
1886       if (pe_def_file->num_imports > 0)
1887         {
1888           fprintf (out, "\nIMPORTS\n\n");
1889
1890           for (i = 0; i < pe_def_file->num_imports; i++)
1891             {
1892               def_file_import *im = pe_def_file->imports + i;
1893               fprintf (out, "    ");
1894
1895               if (im->internal_name
1896                   && (!im->name || strcmp (im->internal_name, im->name)))
1897                 {
1898                   quoteput (im->internal_name, out, 0);
1899                   fprintf (out, " = ");
1900                 }
1901
1902               quoteput (im->module->name, out, 0);
1903               fprintf (out, ".");
1904
1905               if (im->name)
1906                 quoteput (im->name, out, 0);
1907               else
1908                 fprintf (out, "%d", im->ordinal);
1909
1910               if (im->its_name)
1911                 {
1912                   fprintf (out, " == ");
1913                   quoteput (im->its_name, out, 0);
1914                 }
1915
1916               fprintf (out, "\n");
1917             }
1918         }
1919     }
1920   else
1921     fprintf (out, _("; no contents available\n"));
1922
1923   if (fclose (out) == EOF)
1924     /* xgettext:c-format */
1925     einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename);
1926 }
1927
1928 /* Generate the import library.  */
1929
1930 static asymbol **symtab;
1931 static int symptr;
1932 static int tmp_seq;
1933 static const char *dll_filename;
1934 static char *dll_symname;
1935
1936 #define UNDSEC bfd_und_section_ptr
1937
1938 static asection *
1939 quick_section (bfd *abfd, const char *name, int flags, int align)
1940 {
1941   asection *sec;
1942   asymbol *sym;
1943
1944   sec = bfd_make_section_old_way (abfd, name);
1945   bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1946   bfd_set_section_alignment (abfd, sec, align);
1947   /* Remember to undo this before trying to link internally!  */
1948   sec->output_section = sec;
1949
1950   sym = bfd_make_empty_symbol (abfd);
1951   symtab[symptr++] = sym;
1952   sym->name = sec->name;
1953   sym->section = sec;
1954   sym->flags = BSF_LOCAL;
1955   sym->value = 0;
1956
1957   return sec;
1958 }
1959
1960 static void
1961 quick_symbol (bfd *abfd,
1962               const char *n1,
1963               const char *n2,
1964               const char *n3,
1965               asection *sec,
1966               int flags,
1967               int addr)
1968 {
1969   asymbol *sym;
1970   char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1971
1972   strcpy (name, n1);
1973   strcat (name, n2);
1974   strcat (name, n3);
1975   sym = bfd_make_empty_symbol (abfd);
1976   sym->name = name;
1977   sym->section = sec;
1978   sym->flags = flags;
1979   sym->value = addr;
1980   symtab[symptr++] = sym;
1981 }
1982
1983 static arelent *reltab = 0;
1984 static int relcount = 0, relsize = 0;
1985
1986 static void
1987 quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
1988 {
1989   if (relcount >= relsize - 1)
1990     {
1991       relsize += 10;
1992       if (reltab)
1993         reltab = xrealloc (reltab, relsize * sizeof (arelent));
1994       else
1995         reltab = xmalloc (relsize * sizeof (arelent));
1996     }
1997   reltab[relcount].address = address;
1998   reltab[relcount].addend = 0;
1999   reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
2000   reltab[relcount].sym_ptr_ptr = symtab + symidx;
2001   relcount++;
2002 }
2003
2004 static void
2005 save_relocs (asection *sec)
2006 {
2007   int i;
2008
2009   sec->relocation = reltab;
2010   sec->reloc_count = relcount;
2011   sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
2012   for (i = 0; i < relcount; i++)
2013     sec->orelocation[i] = sec->relocation + i;
2014   sec->orelocation[relcount] = 0;
2015   sec->flags |= SEC_RELOC;
2016   reltab = 0;
2017   relcount = relsize = 0;
2018 }
2019
2020 /*      .section        .idata$2
2021         .global         __head_my_dll
2022    __head_my_dll:
2023         .rva            hname
2024         .long           0
2025         .long           0
2026         .rva            __my_dll_iname
2027         .rva            fthunk
2028
2029         .section        .idata$5
2030         .long           0
2031    fthunk:
2032
2033         .section        .idata$4
2034         .long           0
2035    hname:                              */
2036
2037 static bfd *
2038 make_head (bfd *parent)
2039 {
2040   asection *id2, *id5, *id4;
2041   unsigned char *d2, *d5, *d4;
2042   char *oname;
2043   bfd *abfd;
2044
2045   oname = xmalloc (20);
2046   sprintf (oname, "d%06d.o", tmp_seq);
2047   tmp_seq++;
2048
2049   abfd = bfd_create (oname, parent);
2050   bfd_find_target (pe_details->object_target, abfd);
2051   bfd_make_writable (abfd);
2052
2053   bfd_set_format (abfd, bfd_object);
2054   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2055
2056   symptr = 0;
2057   symtab = xmalloc (6 * sizeof (asymbol *));
2058   id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2059   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2060   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2061   quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
2062   quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2063
2064   /* OK, pay attention here.  I got confused myself looking back at
2065      it.  We create a four-byte section to mark the beginning of the
2066      list, and we include an offset of 4 in the section, so that the
2067      pointer to the list points to the *end* of this section, which is
2068      the start of the list of sections from other objects.  */
2069
2070   bfd_set_section_size (abfd, id2, 20);
2071   d2 = xmalloc (20);
2072   id2->contents = d2;
2073   memset (d2, 0, 20);
2074   if (pe_use_nul_prefixed_import_tables)
2075     d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend.  */
2076   quick_reloc (abfd,  0, BFD_RELOC_RVA, 2);
2077   quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
2078   quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
2079   save_relocs (id2);
2080
2081   if (pe_use_nul_prefixed_import_tables)
2082     bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2083   else
2084     bfd_set_section_size (abfd, id5, 0);
2085   d5 = xmalloc (PE_IDATA5_SIZE);
2086   id5->contents = d5;
2087   memset (d5, 0, PE_IDATA5_SIZE);
2088   if (pe_use_nul_prefixed_import_tables)
2089     bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2090   else
2091     bfd_set_section_size (abfd, id4, 0);
2092   d4 = xmalloc (PE_IDATA4_SIZE);
2093   id4->contents = d4;
2094   memset (d4, 0, PE_IDATA4_SIZE);
2095
2096   bfd_set_symtab (abfd, symtab, symptr);
2097
2098   bfd_set_section_contents (abfd, id2, d2, 0, 20);
2099   if (pe_use_nul_prefixed_import_tables)
2100     {
2101       bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2102       bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2103     }
2104   else
2105     {
2106       bfd_set_section_contents (abfd, id5, d5, 0, 0);
2107       bfd_set_section_contents (abfd, id4, d4, 0, 0);
2108     }
2109
2110   bfd_make_readable (abfd);
2111   return abfd;
2112 }
2113
2114 /*      .section        .idata$4
2115         .long           0
2116         [.long          0] for PE+
2117         .section        .idata$5
2118         .long           0
2119         [.long          0] for PE+
2120         .section        idata$7
2121         .global         __my_dll_iname
2122   __my_dll_iname:
2123         .asciz          "my.dll"       */
2124
2125 static bfd *
2126 make_tail (bfd *parent)
2127 {
2128   asection *id4, *id5, *id7;
2129   unsigned char *d4, *d5, *d7;
2130   int len;
2131   char *oname;
2132   bfd *abfd;
2133
2134   oname = xmalloc (20);
2135   sprintf (oname, "d%06d.o", tmp_seq);
2136   tmp_seq++;
2137
2138   abfd = bfd_create (oname, parent);
2139   bfd_find_target (pe_details->object_target, abfd);
2140   bfd_make_writable (abfd);
2141
2142   bfd_set_format (abfd, bfd_object);
2143   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2144
2145   symptr = 0;
2146   symtab = xmalloc (5 * sizeof (asymbol *));
2147   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2148   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2149   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2150   quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
2151
2152   bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2153   d4 = xmalloc (PE_IDATA4_SIZE);
2154   id4->contents = d4;
2155   memset (d4, 0, PE_IDATA4_SIZE);
2156
2157   bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2158   d5 = xmalloc (PE_IDATA5_SIZE);
2159   id5->contents = d5;
2160   memset (d5, 0, PE_IDATA5_SIZE);
2161
2162   len = strlen (dll_filename) + 1;
2163   if (len & 1)
2164     len++;
2165   bfd_set_section_size (abfd, id7, len);
2166   d7 = xmalloc (len);
2167   id7->contents = d7;
2168   strcpy ((char *) d7, dll_filename);
2169   /* If len was odd, the above
2170      strcpy leaves behind an undefined byte. That is harmless,
2171      but we set it to 0 just so the binary dumps are pretty.  */
2172   d7[len - 1] = 0;
2173
2174   bfd_set_symtab (abfd, symtab, symptr);
2175
2176   bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2177   bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2178   bfd_set_section_contents (abfd, id7, d7, 0, len);
2179
2180   bfd_make_readable (abfd);
2181   return abfd;
2182 }
2183
2184 /*      .text
2185         .global         _function
2186         .global         ___imp_function
2187         .global         __imp__function
2188   _function:
2189         jmp             *__imp__function:
2190
2191         .section        idata$7
2192         .long           __head_my_dll
2193
2194         .section        .idata$5
2195   ___imp_function:
2196   __imp__function:
2197   iat?
2198         .section        .idata$4
2199   iat?
2200         .section        .idata$6
2201   ID<ordinal>:
2202         .short          <hint>
2203         .asciz          "function" xlate? (add underscore, kill at)  */
2204
2205 static const unsigned char jmp_ix86_bytes[] =
2206 {
2207   0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2208 };
2209
2210 /* _function:
2211         mov.l   ip+8,r0
2212         mov.l   @r0,r0
2213         jmp     @r0
2214         nop
2215         .dw     __imp_function   */
2216
2217 static const unsigned char jmp_sh_bytes[] =
2218 {
2219   0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2220 };
2221
2222 /* _function:
2223         lui     $t0,<high:__imp_function>
2224         lw      $t0,<low:__imp_function>
2225         jr      $t0
2226         nop                              */
2227
2228 static const unsigned char jmp_mips_bytes[] =
2229 {
2230   0x00, 0x00, 0x08, 0x3c,  0x00, 0x00, 0x08, 0x8d,
2231   0x08, 0x00, 0x00, 0x01,  0x00, 0x00, 0x00, 0x00
2232 };
2233
2234 static const unsigned char jmp_arm_bytes[] =
2235 {
2236   0x00, 0xc0, 0x9f, 0xe5,       /* ldr  ip, [pc] */
2237   0x00, 0xf0, 0x9c, 0xe5,       /* ldr  pc, [ip] */
2238   0,    0,    0,    0
2239 };
2240
2241
2242 static bfd *
2243 make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
2244 {
2245   asection *tx, *id7, *id5, *id4, *id6;
2246   unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
2247   int len;
2248   char *oname;
2249   bfd *abfd;
2250   const unsigned char *jmp_bytes = NULL;
2251   int jmp_byte_count = 0;
2252
2253   /* Include the jump stub section only if it is needed. A jump
2254      stub is needed if the symbol being imported <sym> is a function
2255      symbol and there is at least one undefined reference to that
2256      symbol. In other words, if all the import references to <sym> are
2257      explicitly through _declspec(dllimport) then the jump stub is not
2258      needed.  */
2259   if (include_jmp_stub)
2260     {
2261       switch (pe_details->pe_arch)
2262         {
2263         case PE_ARCH_i386:
2264           jmp_bytes = jmp_ix86_bytes;
2265           jmp_byte_count = sizeof (jmp_ix86_bytes);
2266           break;
2267         case PE_ARCH_sh:
2268           jmp_bytes = jmp_sh_bytes;
2269           jmp_byte_count = sizeof (jmp_sh_bytes);
2270           break;
2271         case PE_ARCH_mips:
2272           jmp_bytes = jmp_mips_bytes;
2273           jmp_byte_count = sizeof (jmp_mips_bytes);
2274           break;
2275         case PE_ARCH_arm:
2276         case PE_ARCH_arm_wince:
2277           jmp_bytes = jmp_arm_bytes;
2278           jmp_byte_count = sizeof (jmp_arm_bytes);
2279           break;
2280         default:
2281           abort ();
2282         }
2283     }
2284
2285   oname = xmalloc (20);
2286   sprintf (oname, "d%06d.o", tmp_seq);
2287   tmp_seq++;
2288
2289   abfd = bfd_create (oname, parent);
2290   bfd_find_target (pe_details->object_target, abfd);
2291   bfd_make_writable (abfd);
2292
2293   bfd_set_format (abfd, bfd_object);
2294   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2295
2296   symptr = 0;
2297   symtab = xmalloc (12 * sizeof (asymbol *));
2298
2299   tx  = quick_section (abfd, ".text", SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY, 2);
2300   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2301   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2302   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2303   id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
2304
2305   if  (*exp->internal_name == '@')
2306     {
2307       quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2308                     BSF_GLOBAL, 0);
2309       if (include_jmp_stub)
2310         quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
2311       quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
2312                     BSF_GLOBAL, 0);
2313       /* Fastcall applies only to functions,
2314          so no need for auto-import symbol.  */
2315     }
2316   else
2317     {
2318       quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2319                     BSF_GLOBAL, 0);
2320       if (include_jmp_stub)
2321         quick_symbol (abfd, U (""), exp->internal_name, "", tx,
2322                       BSF_GLOBAL, 0);
2323       quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
2324                     BSF_GLOBAL, 0);
2325       /* Symbol to reference ord/name of imported
2326          data symbol, used to implement auto-import.  */
2327       if (exp->flag_data)
2328         quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
2329                       BSF_GLOBAL,0);
2330     }
2331   if (pe_dll_compat_implib)
2332     quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
2333                   BSF_GLOBAL, 0);
2334
2335   if (include_jmp_stub)
2336     {
2337       bfd_set_section_size (abfd, tx, jmp_byte_count);
2338       td = xmalloc (jmp_byte_count);
2339       tx->contents = td;
2340       memcpy (td, jmp_bytes, jmp_byte_count);
2341
2342       switch (pe_details->pe_arch)
2343         {
2344         case PE_ARCH_i386:
2345 #ifdef pe_use_x86_64
2346           quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
2347 #else
2348           /* Mark this object as SAFESEH compatible.  */
2349           quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
2350                         BSF_LOCAL, 1);
2351           quick_reloc (abfd, 2, BFD_RELOC_32, 2);
2352 #endif
2353           break;
2354         case PE_ARCH_sh:
2355           quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2356           break;
2357         case PE_ARCH_mips:
2358           quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
2359           quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
2360           quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2361           break;
2362         case PE_ARCH_arm:
2363         case PE_ARCH_arm_wince:
2364           quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2365           break;
2366         default:
2367           abort ();
2368         }
2369       save_relocs (tx);
2370     }
2371   else
2372     bfd_set_section_size (abfd, tx, 0);
2373
2374   bfd_set_section_size (abfd, id7, 4);
2375   d7 = xmalloc (4);
2376   id7->contents = d7;
2377   memset (d7, 0, 4);
2378   quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2379   save_relocs (id7);
2380
2381   bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2382   d5 = xmalloc (PE_IDATA5_SIZE);
2383   id5->contents = d5;
2384   memset (d5, 0, PE_IDATA5_SIZE);
2385
2386   if (exp->flag_noname)
2387     {
2388       d5[0] = exp->ordinal;
2389       d5[1] = exp->ordinal >> 8;
2390       d5[PE_IDATA5_SIZE - 1] = 0x80;
2391     }
2392   else
2393     {
2394       quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2395       save_relocs (id5);
2396     }
2397
2398   bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2399   d4 = xmalloc (PE_IDATA4_SIZE);
2400   id4->contents = d4;
2401   memset (d4, 0, PE_IDATA4_SIZE);
2402
2403   if (exp->flag_noname)
2404     {
2405       d4[0] = exp->ordinal;
2406       d4[1] = exp->ordinal >> 8;
2407       d4[PE_IDATA4_SIZE - 1] = 0x80;
2408     }
2409   else
2410     {
2411       quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2412       save_relocs (id4);
2413     }
2414
2415   if (exp->flag_noname)
2416     {
2417       len = 0;
2418       bfd_set_section_size (abfd, id6, 0);
2419     }
2420   else
2421     {
2422       int ord;
2423
2424       /* { short, asciz }  */
2425       if (exp->its_name)
2426         len = 2 + strlen (exp->its_name) + 1;
2427       else
2428         len = 2 + strlen (exp->name) + 1;
2429       if (len & 1)
2430         len++;
2431       bfd_set_section_size (abfd, id6, len);
2432       d6 = xmalloc (len);
2433       id6->contents = d6;
2434       memset (d6, 0, len);
2435
2436       /* PR 20880:  Use exp->hint as a backup, just in case exp->ordinal
2437          contains an invalid value (-1).  */
2438       ord = (exp->ordinal >= 0) ? exp->ordinal : exp->hint;
2439       d6[0] = ord;
2440       d6[1] = ord >> 8;
2441
2442       if (exp->its_name)
2443         strcpy ((char*) d6 + 2, exp->its_name);
2444       else
2445         strcpy ((char *) d6 + 2, exp->name);
2446     }
2447
2448   bfd_set_symtab (abfd, symtab, symptr);
2449
2450   if (include_jmp_stub)
2451     bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2452   bfd_set_section_contents (abfd, id7, d7, 0, 4);
2453   bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2454   bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2455   if (!exp->flag_noname)
2456     bfd_set_section_contents (abfd, id6, d6, 0, len);
2457
2458   bfd_make_readable (abfd);
2459   return abfd;
2460 }
2461
2462 static bfd *
2463 make_singleton_name_thunk (const char *import, bfd *parent)
2464 {
2465   /* Name thunks go to idata$4.  */
2466   asection *id4;
2467   unsigned char *d4;
2468   char *oname;
2469   bfd *abfd;
2470
2471   oname = xmalloc (20);
2472   sprintf (oname, "nmth%06d.o", tmp_seq);
2473   tmp_seq++;
2474
2475   abfd = bfd_create (oname, parent);
2476   bfd_find_target (pe_details->object_target, abfd);
2477   bfd_make_writable (abfd);
2478
2479   bfd_set_format (abfd, bfd_object);
2480   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2481
2482   symptr = 0;
2483   symtab = xmalloc (3 * sizeof (asymbol *));
2484   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2485   quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
2486   quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
2487
2488   /* We need space for the real thunk and for the null terminator.  */
2489   bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2490   d4 = xmalloc (PE_IDATA4_SIZE * 2);
2491   id4->contents = d4;
2492   memset (d4, 0, PE_IDATA4_SIZE * 2);
2493   quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2494   save_relocs (id4);
2495
2496   bfd_set_symtab (abfd, symtab, symptr);
2497
2498   bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2499
2500   bfd_make_readable (abfd);
2501   return abfd;
2502 }
2503
2504 static const char *
2505 make_import_fixup_mark (arelent *rel, char *name)
2506 {
2507   /* We convert reloc to symbol, for later reference.  */
2508   static unsigned int counter;
2509   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2510   bfd *abfd = bfd_asymbol_bfd (sym);
2511   struct bfd_link_hash_entry *bh;
2512   char *fixup_name, buf[26];
2513   size_t prefix_len;
2514
2515   /* "name" buffer has space before the symbol name for prefixes.  */
2516   sprintf (buf, "__fu%d_", counter++);
2517   prefix_len = strlen (buf);
2518   fixup_name = name - prefix_len;
2519   memcpy (fixup_name, buf, prefix_len);
2520
2521   bh = NULL;
2522   bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2523                                 current_sec, /* sym->section, */
2524                                 rel->address, NULL, TRUE, FALSE, &bh);
2525
2526   return bh->root.string;
2527 }
2528
2529 /*      .section        .idata$2
2530         .rva            __nm_thnk_SYM (singleton thunk with name of func)
2531         .long           0
2532         .long           0
2533         .rva            __my_dll_iname (name of dll)
2534         .rva            __fuNN_SYM (pointer to reference (address) in text)  */
2535
2536 static bfd *
2537 make_import_fixup_entry (const char *name,
2538                          const char *fixup_name,
2539                          const char *symname,
2540                          bfd *parent)
2541 {
2542   asection *id2;
2543   unsigned char *d2;
2544   char *oname;
2545   bfd *abfd;
2546
2547   oname = xmalloc (20);
2548   sprintf (oname, "fu%06d.o", tmp_seq);
2549   tmp_seq++;
2550
2551   abfd = bfd_create (oname, parent);
2552   bfd_find_target (pe_details->object_target, abfd);
2553   bfd_make_writable (abfd);
2554
2555   bfd_set_format (abfd, bfd_object);
2556   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2557
2558   symptr = 0;
2559   symtab = xmalloc (6 * sizeof (asymbol *));
2560   id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2561
2562   quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
2563   quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2564   quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2565
2566   bfd_set_section_size (abfd, id2, 20);
2567   d2 = xmalloc (20);
2568   id2->contents = d2;
2569   memset (d2, 0, 20);
2570
2571   quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2572   quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2573   quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2574   save_relocs (id2);
2575
2576   bfd_set_symtab (abfd, symtab, symptr);
2577
2578   bfd_set_section_contents (abfd, id2, d2, 0, 20);
2579
2580   bfd_make_readable (abfd);
2581   return abfd;
2582 }
2583
2584 /*      .section        .rdata_runtime_pseudo_reloc
2585         .long           addend
2586         .rva            __fuNN_SYM (pointer to reference (address) in text)  */
2587
2588 static bfd *
2589 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2590                            const char *fixup_name,
2591                            bfd_vma addend ATTRIBUTE_UNUSED,
2592                            bfd_vma bitsize,
2593                            bfd *parent)
2594 {
2595   asection *rt_rel;
2596   unsigned char *rt_rel_d;
2597   char *oname;
2598   bfd *abfd;
2599   bfd_size_type size;
2600
2601   oname = xmalloc (20);
2602   sprintf (oname, "rtr%06d.o", tmp_seq);
2603   tmp_seq++;
2604
2605   abfd = bfd_create (oname, parent);
2606   bfd_find_target (pe_details->object_target, abfd);
2607   bfd_make_writable (abfd);
2608
2609   bfd_set_format (abfd, bfd_object);
2610   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2611
2612   if (link_info.pei386_runtime_pseudo_reloc == 2)
2613     {
2614       if (runtime_pseudp_reloc_v2_init)
2615         size = 3 * sizeof (asymbol *);
2616       else
2617         size = 6 * sizeof (asymbol *);
2618     }
2619   else
2620     size = 2 * sizeof (asymbol *);
2621
2622   symptr = 0;
2623   symtab = xmalloc (size);
2624
2625   rt_rel
2626     = quick_section (abfd, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS, 2);
2627
2628   quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2629
2630   if (link_info.pei386_runtime_pseudo_reloc == 2)
2631     {
2632       size = 12;
2633       if (!runtime_pseudp_reloc_v2_init)
2634         {
2635           size += 12;
2636           runtime_pseudp_reloc_v2_init = TRUE;
2637         }
2638
2639       quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2640
2641       bfd_set_section_size (abfd, rt_rel, size);
2642       rt_rel_d = xmalloc (size);
2643       rt_rel->contents = rt_rel_d;
2644       memset (rt_rel_d, 0, size);
2645       quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
2646       quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
2647       bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
2648       if (size != 12)
2649         bfd_put_32 (abfd, 1, rt_rel_d + 8);
2650       save_relocs (rt_rel);
2651
2652       bfd_set_symtab (abfd, symtab, symptr);
2653
2654       bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
2655     }
2656   else
2657     {
2658       bfd_set_section_size (abfd, rt_rel, 8);
2659       rt_rel_d = xmalloc (8);
2660       rt_rel->contents = rt_rel_d;
2661       memset (rt_rel_d, 0, 8);
2662
2663       bfd_put_32 (abfd, addend, rt_rel_d);
2664       quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2665
2666       save_relocs (rt_rel);
2667
2668       bfd_set_symtab (abfd, symtab, symptr);
2669
2670       bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2671    }
2672
2673   bfd_make_readable (abfd);
2674   return abfd;
2675 }
2676
2677 /*      .section        .rdata
2678         .rva            __pei386_runtime_relocator  */
2679
2680 static bfd *
2681 pe_create_runtime_relocator_reference (bfd *parent)
2682 {
2683   asection *extern_rt_rel;
2684   unsigned char *extern_rt_rel_d;
2685   char *oname;
2686   bfd *abfd;
2687
2688   oname = xmalloc (20);
2689   sprintf (oname, "ertr%06d.o", tmp_seq);
2690   tmp_seq++;
2691
2692   abfd = bfd_create (oname, parent);
2693   bfd_find_target (pe_details->object_target, abfd);
2694   bfd_make_writable (abfd);
2695
2696   bfd_set_format (abfd, bfd_object);
2697   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2698
2699   symptr = 0;
2700   symtab = xmalloc (2 * sizeof (asymbol *));
2701   extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2702
2703   quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2704                 BSF_NO_FLAGS, 0);
2705
2706   bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
2707   extern_rt_rel_d = xcalloc (1, PE_IDATA5_SIZE);
2708   extern_rt_rel->contents = extern_rt_rel_d;
2709
2710   quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2711   save_relocs (extern_rt_rel);
2712
2713   bfd_set_symtab (abfd, symtab, symptr);
2714
2715   bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
2716
2717   bfd_make_readable (abfd);
2718   return abfd;
2719 }
2720
2721 void
2722 pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend, char *name,
2723                         const char *symname)
2724 {
2725   const char *fixup_name = make_import_fixup_mark (rel, name);
2726   bfd *b;
2727
2728   /* This is the original implementation of the auto-import feature, which
2729      primarily relied on the OS loader to patch things up with some help
2730      from the pseudo-relocator to overcome the main limitation.  See the
2731      comment at the beginning of the file for an overview of the feature.  */
2732   if (link_info.pei386_runtime_pseudo_reloc != 2)
2733     {
2734       struct bfd_link_hash_entry *name_thunk_sym;
2735       /* name buffer is allocated with space at beginning for prefixes.  */
2736       char *thname = name - (sizeof "__nm_thnk_" - 1);
2737       memcpy (thname, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
2738       name_thunk_sym = bfd_link_hash_lookup (link_info.hash, thname, 0, 0, 1);
2739
2740       if (!(name_thunk_sym && name_thunk_sym->type == bfd_link_hash_defined))
2741         {
2742           b = make_singleton_name_thunk (name, link_info.output_bfd);
2743           add_bfd_to_link (b, b->filename, &link_info);
2744
2745           /* If we ever use autoimport, we have to cast text section writable.  */
2746           config.text_read_only = FALSE;
2747           link_info.output_bfd->flags &= ~WP_TEXT;
2748         }
2749
2750       if (addend == 0 || link_info.pei386_runtime_pseudo_reloc == 1)
2751         {
2752           b = make_import_fixup_entry (name, fixup_name, symname,
2753                                        link_info.output_bfd);
2754           add_bfd_to_link (b, b->filename, &link_info);
2755         }
2756     }
2757
2758   /* In the original implementation, the pseudo-relocator was only used when
2759      the addend was not null.  In the new implementation, the OS loader is
2760      completely bypassed and the pseudo-relocator does the entire work.  */
2761   if ((addend != 0 && link_info.pei386_runtime_pseudo_reloc == 1)
2762       || link_info.pei386_runtime_pseudo_reloc == 2)
2763     {
2764       if (pe_dll_extra_pe_debug)
2765         printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2766                 fixup_name, (int) addend);
2767
2768       b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
2769                                      link_info.output_bfd);
2770       add_bfd_to_link (b, b->filename, &link_info);
2771
2772       if (runtime_pseudo_relocs_created++ == 0)
2773         {
2774           b = pe_create_runtime_relocator_reference (link_info.output_bfd);
2775           add_bfd_to_link (b, b->filename, &link_info);
2776         }
2777     }
2778
2779   else if (addend != 0)
2780     einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
2781            s->owner, s, rel->address, (*rel->sym_ptr_ptr)->name);
2782 }
2783
2784 void
2785 pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
2786 {
2787   int i;
2788   bfd *ar_head;
2789   bfd *ar_tail;
2790   bfd *outarch;
2791   bfd *ibfd;
2792   bfd *head = 0;
2793
2794   dll_filename = (def->name) ? def->name : dll_name;
2795   dll_symname = xstrdup (dll_filename);
2796   for (i = 0; dll_symname[i]; i++)
2797     if (!ISALNUM (dll_symname[i]))
2798       dll_symname[i] = '_';
2799
2800   unlink_if_ordinary (impfilename);
2801
2802   outarch = bfd_openw (impfilename, 0);
2803
2804   if (!outarch)
2805     {
2806       /* xgettext:c-format */
2807       einfo (_("%X%P: can't open .lib file: %s\n"), impfilename);
2808       return;
2809     }
2810
2811   if (verbose)
2812     /* xgettext:c-format */
2813     info_msg (_("Creating library file: %s\n"), impfilename);
2814
2815   bfd_set_format (outarch, bfd_archive);
2816   outarch->has_armap = 1;
2817
2818   /* Work out a reasonable size of things to put onto one line.  */
2819   ar_head = make_head (outarch);
2820
2821   /* Iterate the input BFDs, looking for exclude-modules-for-implib.  */
2822   for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
2823     {
2824       /* Iterate the exclude list.  */
2825       struct exclude_list_struct *ex;
2826       char found;
2827       for (ex = excludes, found = 0; ex && !found; ex = ex->next)
2828         {
2829           if (ex->type != EXCLUDEFORIMPLIB)
2830             continue;
2831           found = (filename_cmp (ex->string, ibfd->filename) == 0);
2832         }
2833       /* If it matched, we must open a fresh BFD for it (the original
2834          input BFD is still needed for the DLL's final link) and add
2835          it into the archive member chain.  */
2836       if (found)
2837         {
2838           bfd *newbfd = bfd_openr (ibfd->my_archive
2839                 ? ibfd->my_archive->filename : ibfd->filename, NULL);
2840           if (!newbfd)
2841             {
2842               einfo (_("%X%P: bfd_openr %s: %E\n"), ibfd->filename);
2843               return;
2844             }
2845           if (ibfd->my_archive)
2846             {
2847               /* Must now iterate through archive until we find the
2848                 required member.  A minor shame that we'll open the
2849                 archive once per member that we require from it, and
2850                 leak those archive bfds rather than reuse them.  */
2851               bfd *arbfd = newbfd;
2852               if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
2853                 {
2854                   einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
2855                     ibfd->my_archive->filename, ibfd->filename);
2856                   return;
2857                 }
2858               newbfd = NULL;
2859               while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
2860                 {
2861                   if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
2862                     break;
2863                 }
2864               if (!newbfd)
2865                 {
2866                   einfo (_("%X%P: %s(%s): can't find member in archive"),
2867                     ibfd->my_archive->filename, ibfd->filename);
2868                   return;
2869                 }
2870             }
2871           newbfd->archive_next = head;
2872           head = newbfd;
2873         }
2874     }
2875
2876   for (i = 0; i < def->num_exports; i++)
2877     {
2878       /* The import library doesn't know about the internal name.  */
2879       char *internal = def->exports[i].internal_name;
2880       bfd *n;
2881
2882       /* Don't add PRIVATE entries to import lib.  */
2883       if (pe_def_file->exports[i].flag_private)
2884         continue;
2885
2886       def->exports[i].internal_name = def->exports[i].name;
2887
2888       /* PR 19803: If a symbol has been discard due to garbage
2889          collection then do not create any exports for it.  */
2890       {
2891         struct coff_link_hash_entry *h;
2892
2893         h = coff_link_hash_lookup (coff_hash_table (info), internal,
2894                                    FALSE, FALSE, FALSE);
2895         if (h != NULL
2896             /* If the symbol is hidden and undefined then it
2897                has been swept up by garbage collection.  */
2898             && h->symbol_class == C_HIDDEN
2899             && h->root.u.def.section == bfd_und_section_ptr)
2900           continue;
2901
2902         /* If necessary, check with an underscore prefix as well.  */
2903         if (pe_details->underscored && internal[0] != '@')
2904           {
2905             char *name;
2906
2907             name = xmalloc (strlen (internal) + 2);
2908             sprintf (name, "_%s", internal);
2909
2910             h = coff_link_hash_lookup (coff_hash_table (info), name,
2911                                        FALSE, FALSE, FALSE);
2912             free (name);
2913
2914             if (h != NULL
2915                 /* If the symbol is hidden and undefined then it
2916                    has been swept up by garbage collection.  */
2917                 && h->symbol_class == C_HIDDEN
2918                 && h->root.u.def.section == bfd_und_section_ptr)
2919               continue;
2920           }
2921       }
2922
2923       n = make_one (def->exports + i, outarch,
2924                     ! (def->exports + i)->flag_data);
2925       n->archive_next = head;
2926       head = n;
2927       def->exports[i].internal_name = internal;
2928     }
2929
2930   ar_tail = make_tail (outarch);
2931
2932   if (ar_head == NULL || ar_tail == NULL)
2933     return;
2934
2935   /* Now stick them all into the archive.  */
2936   ar_head->archive_next = head;
2937   ar_tail->archive_next = ar_head;
2938   head = ar_tail;
2939
2940   if (! bfd_set_archive_head (outarch, head))
2941     einfo ("%X%P: bfd_set_archive_head: %E\n");
2942
2943   if (! bfd_close (outarch))
2944     einfo ("%X%P: bfd_close %s: %E\n", impfilename);
2945
2946   while (head != NULL)
2947     {
2948       bfd *n = head->archive_next;
2949       bfd_close (head);
2950       head = n;
2951     }
2952 }
2953
2954 static int undef_count = 0;
2955
2956 struct key_value
2957 {
2958   char *key;
2959   const char *oname;
2960 };
2961
2962 static struct key_value *udef_table;
2963
2964 static int undef_sort_cmp (const void *l1, const void *r1)
2965 {
2966   const struct key_value *l = l1;
2967   const struct key_value *r = r1;
2968
2969   return strcmp (l->key, r->key);
2970 }
2971
2972 static struct bfd_link_hash_entry *
2973 pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
2974 {
2975   struct bfd_link_hash_entry *h = NULL;
2976   struct key_value *kv;
2977   struct key_value key;
2978   char *at, *lname = xmalloc (strlen (name) + 3);
2979
2980   strcpy (lname, name);
2981
2982   at = strchr (lname + (lname[0] == '@'), '@');
2983   if (at)
2984     at[1] = 0;
2985
2986   key.key = lname;
2987   kv = bsearch (&key, udef_table, undef_count, sizeof (struct key_value),
2988                 undef_sort_cmp);
2989
2990   if (kv)
2991     {
2992       h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
2993       if (h->type == bfd_link_hash_undefined)
2994         goto return_h;
2995     }
2996
2997   if (lname[0] == '?')
2998     goto return_NULL;
2999
3000   if (at || lname[0] == '@')
3001     {
3002       if (lname[0] == '@')
3003         {
3004           if (pe_details->underscored)
3005             lname[0] = '_';
3006           else
3007             strcpy (lname, lname + 1);
3008           key.key = lname;
3009           kv = bsearch (&key, udef_table, undef_count,
3010                         sizeof (struct key_value), undef_sort_cmp);
3011           if (kv)
3012             {
3013               h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3014               if (h->type == bfd_link_hash_undefined)
3015                 goto return_h;
3016             }
3017         }
3018       if (at)
3019         *strchr (lname, '@') = 0;
3020       key.key = lname;
3021       kv = bsearch (&key, udef_table, undef_count,
3022                     sizeof (struct key_value), undef_sort_cmp);
3023       if (kv)
3024         {
3025           h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3026           if (h->type == bfd_link_hash_undefined)
3027             goto return_h;
3028         }
3029       goto return_NULL;
3030     }
3031
3032   strcat (lname, "@");
3033   key.key = lname;
3034   kv = bsearch (&key, udef_table, undef_count,
3035                 sizeof (struct key_value), undef_sort_cmp);
3036
3037   if (kv)
3038     {
3039       h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3040       if (h->type == bfd_link_hash_undefined)
3041         goto return_h;
3042     }
3043
3044   if (lname[0] == '_' && pe_details->underscored)
3045     lname[0] = '@';
3046   else
3047     {
3048       memmove (lname + 1, lname, strlen (lname) + 1);
3049       lname[0] = '@';
3050     }
3051   key.key = lname;
3052
3053   kv = bsearch (&key, udef_table, undef_count,
3054                 sizeof (struct key_value), undef_sort_cmp);
3055
3056   if (kv)
3057     {
3058       h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
3059       if (h->type == bfd_link_hash_undefined)
3060         goto return_h;
3061     }
3062
3063  return_NULL:
3064   h = NULL;
3065  return_h:
3066   free (lname);
3067   return h;
3068 }
3069
3070 static bfd_boolean
3071 pe_undef_count (struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
3072                 void *inf ATTRIBUTE_UNUSED)
3073 {
3074   if (h->type == bfd_link_hash_undefined)
3075     undef_count++;
3076   return TRUE;
3077 }
3078
3079 static bfd_boolean
3080 pe_undef_fill (struct bfd_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
3081 {
3082   if (h->type == bfd_link_hash_undefined)
3083     {
3084       char *at;
3085
3086       udef_table[undef_count].key = xstrdup (h->root.string);
3087       at = strchr (udef_table[undef_count].key
3088                    + (udef_table[undef_count].key[0] == '@'), '@');
3089       if (at)
3090         at[1] = 0;
3091       udef_table[undef_count].oname = h->root.string;
3092       undef_count++;
3093     }
3094   return TRUE;
3095 }
3096
3097 static void
3098 pe_create_undef_table (void)
3099 {
3100   undef_count = 0;
3101
3102   /* count undefined symbols */
3103
3104   bfd_link_hash_traverse (link_info.hash, pe_undef_count, "");
3105
3106   /* create and fill the corresponding table */
3107   udef_table = xmalloc (undef_count * sizeof (struct key_value));
3108
3109   undef_count = 0;
3110   bfd_link_hash_traverse (link_info.hash, pe_undef_fill, "");
3111
3112   /* sort items */
3113   qsort (udef_table, undef_count, sizeof (struct key_value), undef_sort_cmp);
3114 }
3115
3116 static void
3117 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
3118 {
3119   lang_input_statement_type *fake_file;
3120
3121   fake_file = lang_add_input_file (name,
3122                                    lang_input_file_is_fake_enum,
3123                                    NULL);
3124   fake_file->the_bfd = abfd;
3125   ldlang_add_file (fake_file);
3126
3127   if (!bfd_link_add_symbols (abfd, linfo))
3128     einfo (_("%X%P: add symbols %s: %E\n"), name);
3129 }
3130
3131 void
3132 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
3133 {
3134   int i, j;
3135   def_file_module *module;
3136   def_file_import *imp;
3137
3138   pe_dll_id_target (bfd_get_target (output_bfd));
3139
3140   if (!pe_def_file)
3141     return;
3142
3143   imp = pe_def_file->imports;
3144
3145   pe_create_undef_table ();
3146
3147   for (module = pe_def_file->modules; module; module = module->next)
3148     {
3149       int do_this_dll = 0;
3150
3151       for (i = 0; i < pe_def_file->num_imports && imp[i].module != module; i++)
3152         ;
3153       if (i >= pe_def_file->num_imports)
3154         continue;
3155
3156       dll_filename = module->name;
3157       dll_symname = xstrdup (module->name);
3158       for (j = 0; dll_symname[j]; j++)
3159         if (!ISALNUM (dll_symname[j]))
3160           dll_symname[j] = '_';
3161
3162       for (; i < pe_def_file->num_imports && imp[i].module == module; i++)
3163         {
3164           def_file_export exp;
3165           struct bfd_link_hash_entry *blhe;
3166           int lead_at = (*imp[i].internal_name == '@');
3167           /* See if we need this import.  */
3168           size_t len = strlen (imp[i].internal_name);
3169           char *name = xmalloc (len + 2 + 6);
3170           bfd_boolean include_jmp_stub = FALSE;
3171           bfd_boolean is_cdecl = FALSE;
3172           bfd_boolean is_undef = FALSE;
3173
3174           if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
3175               is_cdecl = TRUE;
3176
3177           if (lead_at)
3178             sprintf (name, "%s", imp[i].internal_name);
3179           else
3180             sprintf (name, "%s%s",U (""), imp[i].internal_name);
3181
3182           blhe = bfd_link_hash_lookup (linfo->hash, name,
3183                                        FALSE, FALSE, FALSE);
3184
3185           /* Include the jump stub for <sym> only if the <sym>
3186              is undefined.  */
3187           if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
3188             {
3189               if (lead_at)
3190                 sprintf (name, "%s%s", "__imp_", imp[i].internal_name);
3191               else
3192                 sprintf (name, "%s%s%s", "__imp_", U (""),
3193                          imp[i].internal_name);
3194
3195               blhe = bfd_link_hash_lookup (linfo->hash, name,
3196                                            FALSE, FALSE, FALSE);
3197               if (blhe)
3198                 is_undef = (blhe->type == bfd_link_hash_undefined);
3199             }
3200           else
3201             {
3202               include_jmp_stub = TRUE;
3203               is_undef = (blhe->type == bfd_link_hash_undefined);
3204             }
3205
3206           if (is_cdecl && (!blhe || (blhe && blhe->type != bfd_link_hash_undefined)))
3207             {
3208               sprintf (name, "%s%s",U (""), imp[i].internal_name);
3209               blhe = pe_find_cdecl_alias_match (linfo, name);
3210               include_jmp_stub = TRUE;
3211               if (blhe)
3212                 is_undef = (blhe->type == bfd_link_hash_undefined);
3213             }
3214
3215           free (name);
3216
3217           if (is_undef)
3218             {
3219               bfd *one;
3220               /* We do.  */
3221               if (!do_this_dll)
3222                 {
3223                   bfd *ar_head = make_head (output_bfd);
3224                   add_bfd_to_link (ar_head, ar_head->filename, linfo);
3225                   do_this_dll = 1;
3226                 }
3227               exp.internal_name = imp[i].internal_name;
3228               exp.name = imp[i].name;
3229               exp.its_name = imp[i].its_name;
3230               exp.ordinal = imp[i].ordinal;
3231               exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
3232               exp.flag_private = 0;
3233               exp.flag_constant = 0;
3234               exp.flag_data = imp[i].data;
3235               exp.flag_noname = exp.name ? 0 : 1;
3236               one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
3237               add_bfd_to_link (one, one->filename, linfo);
3238             }
3239         }
3240       if (do_this_dll)
3241         {
3242           bfd *ar_tail = make_tail (output_bfd);
3243           add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
3244         }
3245
3246       free (dll_symname);
3247     }
3248
3249   while (undef_count)
3250     {
3251       --undef_count;
3252       free (udef_table[undef_count].key);
3253     }
3254   free (udef_table);
3255 }
3256
3257 /* We were handed a *.DLL file.  Parse it and turn it into a set of
3258    IMPORTS directives in the def file.  Return TRUE if the file was
3259    handled, FALSE if not.  */
3260
3261 static unsigned int
3262 pe_get16 (bfd *abfd, int where)
3263 {
3264   unsigned char b[2];
3265
3266   bfd_seek (abfd, (file_ptr) where, SEEK_SET);
3267   bfd_bread (b, (bfd_size_type) 2, abfd);
3268   return b[0] + (b[1] << 8);
3269 }
3270
3271 static unsigned int
3272 pe_get32 (bfd *abfd, int where)
3273 {
3274   unsigned char b[4];
3275
3276   bfd_seek (abfd, (file_ptr) where, SEEK_SET);
3277   bfd_bread (b, (bfd_size_type) 4, abfd);
3278   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
3279 }
3280
3281 static unsigned int
3282 pe_as32 (void *ptr)
3283 {
3284   unsigned char *b = ptr;
3285
3286   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
3287 }
3288
3289 bfd_boolean
3290 pe_implied_import_dll (const char *filename)
3291 {
3292   bfd *dll;
3293   bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
3294   bfd_vma export_rva, export_size, nsections, secptr, expptr;
3295   bfd_vma exp_funcbase;
3296   unsigned char *expdata;
3297   char *erva;
3298   bfd_vma name_rvas, nexp;
3299   const char *dllname;
3300   /* Initialization with start > end guarantees that is_data
3301      will not be set by mistake, and avoids compiler warning.  */
3302   bfd_vma data_start = 1;
3303   bfd_vma data_end = 0;
3304   bfd_vma rdata_start = 1;
3305   bfd_vma rdata_end = 0;
3306   bfd_vma bss_start = 1;
3307   bfd_vma bss_end = 0;
3308   int from;
3309
3310   /* No, I can't use bfd here.  kernel32.dll puts its export table in
3311      the middle of the .rdata section.  */
3312   dll = bfd_openr (filename, pe_details->target_name);
3313   if (!dll)
3314     {
3315       einfo (_("%X%P: open %s: %E\n"), filename);
3316       return FALSE;
3317     }
3318
3319   /* PEI dlls seem to be bfd_objects.  */
3320   if (!bfd_check_format (dll, bfd_object))
3321     {
3322       einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename);
3323       return FALSE;
3324     }
3325
3326   /* Get pe_header, optional header and numbers of directory entries.  */
3327   pe_header_offset = pe_get32 (dll, 0x3c);
3328   opthdr_ofs = pe_header_offset + 4 + 20;
3329 #ifdef pe_use_x86_64
3330   num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /*  & NumberOfRvaAndSizes.  */
3331 #else
3332   num_entries = pe_get32 (dll, opthdr_ofs + 92);
3333 #endif
3334
3335   /* No import or export directory entry.  */
3336   if (num_entries < 1)
3337     return FALSE;
3338
3339 #ifdef pe_use_x86_64
3340   export_rva  = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
3341   export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
3342 #else
3343   export_rva = pe_get32 (dll, opthdr_ofs + 96);
3344   export_size = pe_get32 (dll, opthdr_ofs + 100);
3345 #endif
3346
3347   /* No export table - nothing to export.  */
3348   if (export_size == 0)
3349     return FALSE;
3350
3351   nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
3352   secptr = (pe_header_offset + 4 + 20 +
3353             pe_get16 (dll, pe_header_offset + 4 + 16));
3354   expptr = 0;
3355
3356   /* Get the rva and size of the export section.  */
3357   for (i = 0; i < nsections; i++)
3358     {
3359       char sname[8];
3360       bfd_vma secptr1 = secptr + 40 * i;
3361       bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3362       bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
3363       bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
3364
3365       bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
3366       bfd_bread (sname, (bfd_size_type) 8, dll);
3367
3368       if (vaddr <= export_rva && vaddr + vsize > export_rva)
3369         {
3370           expptr = fptr + (export_rva - vaddr);
3371           if (export_rva + export_size > vaddr + vsize)
3372             export_size = vsize - (export_rva - vaddr);
3373           break;
3374         }
3375     }
3376
3377   /* Scan sections and store the base and size of the
3378      data and bss segments in data/base_start/end.  */
3379   for (i = 0; i < nsections; i++)
3380     {
3381       bfd_vma secptr1 = secptr + 40 * i;
3382       bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
3383       bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3384       bfd_vma flags = pe_get32 (dll, secptr1 + 36);
3385       char sec_name[9];
3386
3387       sec_name[8] = '\0';
3388       bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
3389       bfd_bread (sec_name, (bfd_size_type) 8, dll);
3390
3391       if (strcmp(sec_name,".data") == 0)
3392         {
3393           data_start = vaddr;
3394           data_end = vaddr + vsize;
3395
3396           if (pe_dll_extra_pe_debug)
3397             printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3398                     __FUNCTION__, sec_name, (unsigned long) vaddr,
3399                     (unsigned long) (vaddr + vsize), (unsigned long) flags);
3400         }
3401       else if (strcmp(sec_name,".rdata") == 0)
3402         {
3403           rdata_start = vaddr;
3404           rdata_end = vaddr + vsize;
3405
3406           if (pe_dll_extra_pe_debug)
3407             printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3408                     __FUNCTION__, sec_name, (unsigned long) vaddr,
3409                     (unsigned long) (vaddr + vsize), (unsigned long) flags);
3410         }
3411       else if (strcmp (sec_name,".bss") == 0)
3412         {
3413           bss_start = vaddr;
3414           bss_end = vaddr + vsize;
3415
3416           if (pe_dll_extra_pe_debug)
3417             printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3418                     __FUNCTION__, sec_name, (unsigned long) vaddr,
3419                     (unsigned long) (vaddr + vsize), (unsigned long) flags);
3420         }
3421     }
3422
3423   expdata = xmalloc (export_size);
3424   bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
3425   bfd_bread (expdata, (bfd_size_type) export_size, dll);
3426   erva = (char *) expdata - export_rva;
3427
3428   if (pe_def_file == 0)
3429     pe_def_file = def_file_empty ();
3430
3431   nexp = pe_as32 (expdata + 24);
3432   name_rvas = pe_as32 (expdata + 32);
3433   exp_funcbase = pe_as32 (expdata + 28);
3434
3435   /* Use internal dll name instead of filename
3436      to enable symbolic dll linking.  */
3437   dllname = erva + pe_as32 (expdata + 12);
3438
3439   /* Check to see if the dll has already been added to
3440      the definition list and if so return without error.
3441      This avoids multiple symbol definitions.  */
3442   if (def_get_module (pe_def_file, dllname))
3443     {
3444       if (pe_dll_extra_pe_debug)
3445         printf ("%s is already loaded\n", dllname);
3446       return TRUE;
3447     }
3448
3449   /* This is an optimized version of the insertion loop, which avoids lots of
3450      calls to realloc and memmove from def_file_add_import.  */
3451   if ((from = def_file_add_import_from (pe_def_file, nexp,
3452                                         erva + pe_as32 (erva + name_rvas),
3453                                         dllname, 0, NULL, NULL)) >= 0)
3454     {
3455       for (i = 0; i < nexp; i++)
3456         {
3457           /* Pointer to the names vector.  */
3458           bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3459           def_file_import *imp;
3460           /* Pointer to the function address vector.  */
3461           bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3462           /* is_data is true if the address is in the data, rdata or bss
3463              segment.  */
3464           const int is_data =
3465             (func_rva >= data_start && func_rva < data_end)
3466             || (func_rva >= rdata_start && func_rva < rdata_end)
3467             || (func_rva >= bss_start && func_rva < bss_end);
3468
3469           imp = def_file_add_import_at (pe_def_file, from + i, erva + name_rva,
3470                                         dllname, i, NULL, NULL);
3471           /* Mark symbol type.  */
3472           imp->data = is_data;
3473
3474           if (pe_dll_extra_pe_debug)
3475             printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3476                     __FUNCTION__, dllname, erva + name_rva,
3477                     (unsigned long) func_rva, is_data ? "(data)" : "");
3478         }
3479
3480       return TRUE;
3481     }
3482
3483   /* Iterate through the list of symbols.  */
3484   for (i = 0; i < nexp; i++)
3485     {
3486       /* Pointer to the names vector.  */
3487       bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3488       def_file_import *imp;
3489       /* Pointer to the function address vector.  */
3490       bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3491       int is_data = 0;
3492
3493       /* Skip unwanted symbols, which are
3494          exported in buggy auto-import releases.  */
3495       if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
3496         {
3497           int is_dup = 0;
3498           /* is_data is true if the address is in the data, rdata or bss
3499              segment.  */
3500           is_data =
3501             (func_rva >= data_start && func_rva < data_end)
3502             || (func_rva >= rdata_start && func_rva < rdata_end)
3503             || (func_rva >= bss_start && func_rva < bss_end);
3504
3505           imp = def_file_add_import (pe_def_file, erva + name_rva,
3506                                      dllname, i, NULL, NULL, &is_dup);
3507           /* Mark symbol type.  */
3508           if (!is_dup)
3509             imp->data = is_data;
3510
3511           if (pe_dll_extra_pe_debug)
3512             printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3513                     __FUNCTION__, dllname, erva + name_rva,
3514                     (unsigned long) func_rva, is_data ? "(data)" : "");
3515         }
3516     }
3517
3518   return TRUE;
3519 }
3520
3521 void
3522 pe_output_file_set_long_section_names (bfd *abfd)
3523 {
3524   if (pe_use_coff_long_section_names < 0)
3525     return;
3526   if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
3527     einfo (_("%X%P: error: can't use long section names on this arch\n"));
3528 }
3529
3530 /* These are the main functions, called from the emulation.  The first
3531    is called after the bfds are read, so we can guess at how much space
3532    we need.  The second is called after everything is placed, so we
3533    can put the right values in place.  */
3534
3535 void
3536 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
3537 {
3538   pe_dll_id_target (bfd_get_target (abfd));
3539   pe_output_file_set_long_section_names (abfd);
3540   process_def_file_and_drectve (abfd, info);
3541
3542   if (pe_def_file->num_exports == 0 && !bfd_link_pic (info))
3543     return;
3544
3545   generate_edata (abfd, info);
3546   build_filler_bfd (1);
3547   pe_output_file_set_long_section_names (filler_bfd);
3548 }
3549
3550 void
3551 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3552 {
3553   pe_dll_id_target (bfd_get_target (abfd));
3554   pe_output_file_set_long_section_names (abfd);
3555   build_filler_bfd (0);
3556   pe_output_file_set_long_section_names (filler_bfd);
3557 }
3558
3559 void
3560 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
3561 {
3562   pe_dll_id_target (bfd_get_target (abfd));
3563   pe_output_file_set_long_section_names (abfd);
3564   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3565
3566   generate_reloc (abfd, info);
3567   if (reloc_sz > 0)
3568     {
3569       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3570
3571       /* Resize the sections.  */
3572       lang_reset_memory_regions ();
3573       lang_size_sections (NULL, TRUE);
3574
3575       /* Redo special stuff.  */
3576       ldemul_after_allocation ();
3577
3578       /* Do the assignments again.  */
3579       lang_do_assignments (lang_final_phase_enum);
3580     }
3581
3582   fill_edata (abfd, info);
3583
3584   if (bfd_link_dll (info))
3585     pe_data (abfd)->dll = 1;
3586
3587   edata_s->contents = edata_d;
3588   reloc_s->contents = reloc_d;
3589 }
3590
3591 void
3592 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
3593 {
3594   pe_dll_id_target (bfd_get_target (abfd));
3595   pe_output_file_set_long_section_names (abfd);
3596   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3597
3598   generate_reloc (abfd, info);
3599   if (reloc_sz > 0)
3600     {
3601       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3602
3603       /* Resize the sections.  */
3604       lang_reset_memory_regions ();
3605       lang_size_sections (NULL, TRUE);
3606
3607       /* Redo special stuff.  */
3608       ldemul_after_allocation ();
3609
3610       /* Do the assignments again.  */
3611       lang_do_assignments (lang_final_phase_enum);
3612     }
3613   reloc_s->contents = reloc_d;
3614 }
3615
3616 bfd_boolean
3617 pe_bfd_is_dll (bfd *abfd)
3618 {
3619   return (bfd_get_format (abfd) == bfd_object
3620           && obj_pe (abfd)
3621           && pe_data (abfd)->dll);
3622 }