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