ld/pe-dll.c

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