ld/pe-dll.c

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