ld/pe-dll.c

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