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