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