ld/pe-dll.c

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