ld/pe-dll.c

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