ld/pe-dll.c

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