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     1
 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   /* If we are not building a DLL, when there are no exports
 568      we do not build an export table at all.  */
 569   if (!pe_dll_export_everything && pe_def_file->num_exports == 0
 570       && !(info->shared))
 571     return;
 572
 573   /* Now, maybe export everything else the default way.  */
 574   if (pe_dll_export_everything || pe_def_file->num_exports == 0)
 575     {
 576       for (b = info->input_bfds; b; b = b->link_next)
 577         {
 578           asymbol **symbols;
 579           int nsyms, symsize;
 580
 581           symsize = bfd_get_symtab_upper_bound (b);
 582           symbols = (asymbol **) xmalloc (symsize);
 583           nsyms = bfd_canonicalize_symtab (b, symbols);
 584
 585           for (j = 0; j < nsyms; j++)
 586             {
 587               /* We should export symbols which are either global or not
 588                  anything at all.  (.bss data is the latter)
 589                  We should not export undefined symbols.  */
 590               if (symbols[j]->section != &bfd_und_section
 591                   && ((symbols[j]->flags & BSF_GLOBAL)
 592                       || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
 593                 {
 594                   const char *sn = symbols[j]->name;
 595
 596                   /* We should not re-export imported stuff.  */
 597                   {
 598                     char *name = (char *) xmalloc (strlen (sn) + 2 + 6);
 599                     sprintf (name, "%s%s", U("_imp_"), sn);
 600
 601                     blhe = bfd_link_hash_lookup (info->hash, name,
 602                                                  FALSE, FALSE, FALSE);
 603                     free (name);
 604
 605                     if (blhe && blhe->type == bfd_link_hash_defined)
 606                       continue;
 607                   }
 608
 609                   if (*sn == '_')
 610                     sn++;
 611
 612                   if (auto_export (b, pe_def_file, sn))
 613                     {
 614                       def_file_export *p;
 615                       p=def_file_add_export (pe_def_file, sn, 0, -1);
 616                       /* Fill data flag properly, from dlltool.c.  */
 617                       p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
 618                     }
 619                 }
 620             }
 621         }
 622     }
 623
 624 #undef NE
 625 #define NE pe_def_file->num_exports
 626
 627   /* Canonicalize the export list.  */
 628   if (pe_dll_kill_ats)
 629     {
 630       for (i = 0; i < NE; i++)
 631         {
 632           if (strchr (pe_def_file->exports[i].name, '@'))
 633             {
 634               /* This will preserve internal_name, which may have been
 635                  pointing to the same memory as name, or might not
 636                  have.  */
 637               int lead_at = (*pe_def_file->exports[i].name =='@');
 638               char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
 639
 640               *(strchr (tmp, '@')) = 0;
 641               pe_def_file->exports[i].name = tmp;
 642             }
 643         }
 644     }
 645
 646   if (pe_dll_stdcall_aliases)
 647     {
 648       for (i = 0; i < NE; i++)
 649         {
 650           if (strchr (pe_def_file->exports[i].name, '@'))
 651             {
 652               int lead_at = (*pe_def_file->exports[i].name == '@' ) ;
 653               char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
 654
 655               *(strchr (tmp, '@')) = 0;
 656               if (auto_export (NULL, pe_def_file, tmp))
 657                 def_file_add_export (pe_def_file, tmp,
 658                                      pe_def_file->exports[i].internal_name,
 659                                      -1);
 660               else
 661                 free (tmp);
 662             }
 663         }
 664     }
 665
 666   /* Convenience, but watch out for it changing.  */
 667   e = pe_def_file->exports;
 668
 669   exported_symbol_offsets = (bfd_vma *) xmalloc (NE * sizeof (bfd_vma));
 670   exported_symbol_sections = (struct sec **) xmalloc (NE * sizeof (struct sec *));
 671
 672   memset (exported_symbol_sections, 0, NE * sizeof (struct sec *));
 673   max_ordinal = 0;
 674   min_ordinal = 65536;
 675   count_exported = 0;
 676   count_exported_byname = 0;
 677   count_with_ordinals = 0;
 678
 679   qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]), pe_export_sort);
 680   for (i = 0, j = 0; i < NE; i++)
 681     {
 682       if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
 683         {
 684           /* This is a duplicate.  */
 685           if (e[j - 1].ordinal != -1
 686               && e[i].ordinal != -1
 687               && e[j - 1].ordinal != e[i].ordinal)
 688             {
 689               if (pe_dll_warn_dup_exports)
 690                 /* xgettext:c-format */
 691                 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
 692                        e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
 693             }
 694           else
 695             {
 696               if (pe_dll_warn_dup_exports)
 697                 /* xgettext:c-format */
 698                 einfo (_("Warning, duplicate EXPORT: %s\n"),
 699                        e[j - 1].name);
 700             }
 701
 702           if (e[i].ordinal != -1)
 703             e[j - 1].ordinal = e[i].ordinal;
 704           e[j - 1].flag_private |= e[i].flag_private;
 705           e[j - 1].flag_constant |= e[i].flag_constant;
 706           e[j - 1].flag_noname |= e[i].flag_noname;
 707           e[j - 1].flag_data |= e[i].flag_data;
 708         }
 709       else
 710         {
 711           if (i != j)
 712             e[j] = e[i];
 713           j++;
 714         }
 715     }
 716   pe_def_file->num_exports = j; /* == NE */
 717
 718   for (i = 0; i < NE; i++)
 719     {
 720       char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
 721
 722       if (pe_details->underscored
 723           && (*pe_def_file->exports[i].internal_name != '@'))
 724         {
 725           *name = '_';
 726           strcpy (name + 1, pe_def_file->exports[i].internal_name);
 727         }
 728       else
 729         strcpy (name, pe_def_file->exports[i].internal_name);
 730
 731       blhe = bfd_link_hash_lookup (info->hash,
 732                                    name,
 733                                    FALSE, FALSE, TRUE);
 734
 735       if (blhe
 736           && (blhe->type == bfd_link_hash_defined
 737               || (blhe->type == bfd_link_hash_common)))
 738         {
 739           count_exported++;
 740           if (!pe_def_file->exports[i].flag_noname)
 741             count_exported_byname++;
 742
 743           /* Only fill in the sections. The actual offsets are computed
 744              in fill_exported_offsets() after common symbols are laid
 745              out.  */
 746           if (blhe->type == bfd_link_hash_defined)
 747             exported_symbol_sections[i] = blhe->u.def.section;
 748           else
 749             exported_symbol_sections[i] = blhe->u.c.p->section;
 750
 751           if (pe_def_file->exports[i].ordinal != -1)
 752             {
 753               if (max_ordinal < pe_def_file->exports[i].ordinal)
 754                 max_ordinal = pe_def_file->exports[i].ordinal;
 755               if (min_ordinal > pe_def_file->exports[i].ordinal)
 756                 min_ordinal = pe_def_file->exports[i].ordinal;
 757               count_with_ordinals++;
 758             }
 759         }
 760       else if (blhe && blhe->type == bfd_link_hash_undefined)
 761         {
 762           /* xgettext:c-format */
 763           einfo (_("%XCannot export %s: symbol not defined\n"),
 764                  pe_def_file->exports[i].internal_name);
 765         }
 766       else if (blhe)
 767         {
 768           /* xgettext:c-format */
 769           einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
 770                  pe_def_file->exports[i].internal_name,
 771                  blhe->type, bfd_link_hash_defined);
 772         }
 773       else
 774         {
 775           /* xgettext:c-format */
 776           einfo (_("%XCannot export %s: symbol not found\n"),
 777                  pe_def_file->exports[i].internal_name);
 778         }
 779       free (name);
 780     }
 781 }
 782
 783 /* Build the bfd that will contain .edata and .reloc sections.  */
 784
 785 static void
 786 build_filler_bfd (include_edata)
 787      int include_edata;
 788 {
 789   lang_input_statement_type *filler_file;
 790   filler_file = lang_add_input_file ("dll stuff",
 791                                      lang_input_file_is_fake_enum,
 792                                      NULL);
 793   filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
 794   if (filler_bfd == NULL
 795       || !bfd_set_arch_mach (filler_bfd,
 796                              bfd_get_arch (output_bfd),
 797                              bfd_get_mach (output_bfd)))
 798     {
 799       einfo ("%X%P: can not create BFD %E\n");
 800       return;
 801     }
 802
 803   if (include_edata)
 804     {
 805       edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
 806       if (edata_s == NULL
 807           || !bfd_set_section_flags (filler_bfd, edata_s,
 808                                      (SEC_HAS_CONTENTS
 809                                       | SEC_ALLOC
 810                                       | SEC_LOAD
 811                                       | SEC_KEEP
 812                                       | SEC_IN_MEMORY)))
 813         {
 814           einfo ("%X%P: can not create .edata section: %E\n");
 815           return;
 816         }
 817       bfd_set_section_size (filler_bfd, edata_s, edata_sz);
 818     }
 819
 820   reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
 821   if (reloc_s == NULL
 822       || !bfd_set_section_flags (filler_bfd, reloc_s,
 823                                  (SEC_HAS_CONTENTS
 824                                   | SEC_ALLOC
 825                                   | SEC_LOAD
 826                                   | SEC_KEEP
 827                                   | SEC_IN_MEMORY)))
 828     {
 829       einfo ("%X%P: can not create .reloc section: %E\n");
 830       return;
 831     }
 832
 833   bfd_set_section_size (filler_bfd, reloc_s, 0);
 834
 835   ldlang_add_file (filler_file);
 836 }
 837
 838 /* Gather all the exported symbols and build the .edata section.  */
 839
 840 static void
 841 generate_edata (abfd, info)
 842      bfd *abfd;
 843      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 844 {
 845   int i, next_ordinal;
 846   int name_table_size = 0;
 847   const char *dlnp;
 848
 849   /* First, we need to know how many exported symbols there are,
 850      and what the range of ordinals is.  */
 851   if (pe_def_file->name)
 852     dll_name = pe_def_file->name;
 853   else
 854     {
 855       dll_name = abfd->filename;
 856
 857       for (dlnp = dll_name; *dlnp; dlnp++)
 858         if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
 859           dll_name = dlnp + 1;
 860     }
 861
 862   if (count_with_ordinals && max_ordinal > count_exported)
 863     {
 864       if (min_ordinal > max_ordinal - count_exported + 1)
 865         min_ordinal = max_ordinal - count_exported + 1;
 866     }
 867   else
 868     {
 869       min_ordinal = 1;
 870       max_ordinal = count_exported;
 871     }
 872
 873   export_table_size = max_ordinal - min_ordinal + 1;
 874   exported_symbols = (int *) xmalloc (export_table_size * sizeof (int));
 875   for (i = 0; i < export_table_size; i++)
 876     exported_symbols[i] = -1;
 877
 878   /* Now we need to assign ordinals to those that don't have them.  */
 879   for (i = 0; i < NE; i++)
 880     {
 881       if (exported_symbol_sections[i])
 882         {
 883           if (pe_def_file->exports[i].ordinal != -1)
 884             {
 885               int ei = pe_def_file->exports[i].ordinal - min_ordinal;
 886               int pi = exported_symbols[ei];
 887
 888               if (pi != -1)
 889                 {
 890                   /* xgettext:c-format */
 891                   einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
 892                          pe_def_file->exports[i].ordinal,
 893                          pe_def_file->exports[i].name,
 894                          pe_def_file->exports[pi].name);
 895                 }
 896               exported_symbols[ei] = i;
 897             }
 898           name_table_size += strlen (pe_def_file->exports[i].name) + 1;
 899         }
 900     }
 901
 902   next_ordinal = min_ordinal;
 903   for (i = 0; i < NE; i++)
 904     if (exported_symbol_sections[i])
 905       if (pe_def_file->exports[i].ordinal == -1)
 906         {
 907           while (exported_symbols[next_ordinal - min_ordinal] != -1)
 908             next_ordinal++;
 909
 910           exported_symbols[next_ordinal - min_ordinal] = i;
 911           pe_def_file->exports[i].ordinal = next_ordinal;
 912         }
 913
 914   /* OK, now we can allocate some memory.  */
 915   edata_sz = (40                                /* directory */
 916               + 4 * export_table_size           /* addresses */
 917               + 4 * count_exported_byname       /* name ptrs */
 918               + 2 * count_exported_byname       /* ordinals */
 919               + name_table_size + strlen (dll_name) + 1);
 920 }
 921
 922 /* Fill the exported symbol offsets. The preliminary work has already
 923    been done in process_def_file().  */
 924
 925 static void
 926 fill_exported_offsets (abfd, info)
 927      bfd *abfd ATTRIBUTE_UNUSED;
 928      struct bfd_link_info *info;
 929 {
 930   int i;
 931   struct bfd_link_hash_entry *blhe;
 932
 933   for (i = 0; i < pe_def_file->num_exports; i++)
 934     {
 935       char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
 936
 937       if (pe_details->underscored
 938           && (*pe_def_file->exports[i].internal_name != '@'))
 939         {
 940           *name = '_';
 941           strcpy (name + 1, pe_def_file->exports[i].internal_name);
 942         }
 943       else
 944         strcpy (name, pe_def_file->exports[i].internal_name);
 945
 946       blhe = bfd_link_hash_lookup (info->hash,
 947                                    name,
 948                                    FALSE, FALSE, TRUE);
 949
 950       if (blhe && (blhe->type == bfd_link_hash_defined))
 951         exported_symbol_offsets[i] = blhe->u.def.value;
 952
 953       free (name);
 954     }
 955 }
 956
 957 static void
 958 fill_edata (abfd, info)
 959      bfd *abfd;
 960      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 961 {
 962   int i, hint;
 963   unsigned char *edirectory;
 964   unsigned long *eaddresses;
 965   unsigned long *enameptrs;
 966   unsigned short *eordinals;
 967   unsigned char *enamestr;
 968   time_t now;
 969
 970   time (&now);
 971
 972   edata_d = (unsigned char *) xmalloc (edata_sz);
 973
 974   /* Note use of array pointer math here.  */
 975   edirectory = edata_d;
 976   eaddresses = (unsigned long *) (edata_d + 40);
 977   enameptrs = eaddresses + export_table_size;
 978   eordinals = (unsigned short *) (enameptrs + count_exported_byname);
 979   enamestr = (char *) (eordinals + count_exported_byname);
 980
 981 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
 982
 983   memset (edata_d, 0, edata_sz);
 984   bfd_put_32 (abfd, now, edata_d + 4);
 985   if (pe_def_file->version_major != -1)
 986     {
 987       bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
 988       bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
 989     }
 990
 991   bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
 992   strcpy (enamestr, dll_name);
 993   enamestr += strlen (enamestr) + 1;
 994   bfd_put_32 (abfd, min_ordinal, edata_d + 16);
 995   bfd_put_32 (abfd, export_table_size, edata_d + 20);
 996   bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
 997   bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
 998   bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
 999   bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1000
1001   fill_exported_offsets (abfd, info);
1002
1003   /* Ok, now for the filling in part.  */
1004   hint = 0;
1005   for (i = 0; i < export_table_size; i++)
1006     {
1007       int s = exported_symbols[i];
1008
1009       if (s != -1)
1010         {
1011           struct sec *ssec = exported_symbol_sections[s];
1012           unsigned long srva = (exported_symbol_offsets[s]
1013                                 + ssec->output_section->vma
1014                                 + ssec->output_offset);
1015           int ord = pe_def_file->exports[s].ordinal;
1016
1017           bfd_put_32 (abfd, srva - image_base,
1018                       (void *) (eaddresses + ord - min_ordinal));
1019
1020           if (!pe_def_file->exports[s].flag_noname)
1021             {
1022               char *ename = pe_def_file->exports[s].name;
1023               bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs);
1024               enameptrs++;
1025               strcpy (enamestr, ename);
1026               enamestr += strlen (enamestr) + 1;
1027               bfd_put_16 (abfd, ord - min_ordinal, (void *) eordinals);
1028               eordinals++;
1029               pe_def_file->exports[s].hint = hint++;
1030             }
1031         }
1032     }
1033 }
1034
1035
1036 static struct sec *current_sec;
1037
1038 void
1039 pe_walk_relocs_of_symbol (info, name, cb)
1040      struct bfd_link_info *info;
1041      const char *name;
1042      int (*cb) (arelent *, asection *);
1043 {
1044   bfd *b;
1045   asection *s;
1046
1047   for (b = info->input_bfds; b; b = b->link_next)
1048     {
1049       asymbol **symbols;
1050       int nsyms, symsize;
1051
1052       symsize = bfd_get_symtab_upper_bound (b);
1053       symbols = (asymbol **) xmalloc (symsize);
1054       nsyms   = bfd_canonicalize_symtab (b, symbols);
1055
1056       for (s = b->sections; s; s = s->next)
1057         {
1058           arelent **relocs;
1059           int relsize, nrelocs, i;
1060           int flags = bfd_get_section_flags (b, s);
1061
1062           /* Skip discarded linkonce sections.  */
1063           if (flags & SEC_LINK_ONCE
1064               && s->output_section == bfd_abs_section_ptr)
1065             continue;
1066
1067           current_sec = s;
1068
1069           relsize = bfd_get_reloc_upper_bound (b, s);
1070           relocs = (arelent **) xmalloc ((size_t) relsize);
1071           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1072
1073           for (i = 0; i < nrelocs; i++)
1074             {
1075               struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1076
1077               if (!strcmp (name, sym->name))
1078                 cb (relocs[i], s);
1079             }
1080
1081           free (relocs);
1082
1083           /* Warning: the allocated symbols are remembered in BFD and reused
1084              later, so don't free them! */
1085           /* free (symbols); */
1086         }
1087     }
1088 }
1089
1090 /* Gather all the relocations and build the .reloc section.  */
1091
1092 static void
1093 generate_reloc (abfd, info)
1094      bfd *abfd;
1095      struct bfd_link_info *info;
1096 {
1097
1098   /* For .reloc stuff.  */
1099   reloc_data_type *reloc_data;
1100   int total_relocs = 0;
1101   int i;
1102   unsigned long sec_page = (unsigned long) (-1);
1103   unsigned long page_ptr, page_count;
1104   int bi;
1105   bfd *b;
1106   struct sec *s;
1107
1108   total_relocs = 0;
1109   for (b = info->input_bfds; b; b = b->link_next)
1110     for (s = b->sections; s; s = s->next)
1111       total_relocs += s->reloc_count;
1112
1113   reloc_data =
1114     (reloc_data_type *) xmalloc (total_relocs * sizeof (reloc_data_type));
1115
1116   total_relocs = 0;
1117   bi = 0;
1118   for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1119     {
1120       arelent **relocs;
1121       int relsize, nrelocs, i;
1122
1123       for (s = b->sections; s; s = s->next)
1124         {
1125           unsigned long sec_vma = s->output_section->vma + s->output_offset;
1126           asymbol **symbols;
1127           int nsyms, symsize;
1128
1129           /* If it's not loaded, we don't need to relocate it this way.  */
1130           if (!(s->output_section->flags & SEC_LOAD))
1131             continue;
1132
1133           /* I don't know why there would be a reloc for these, but I've
1134              seen it happen - DJ  */
1135           if (s->output_section == &bfd_abs_section)
1136             continue;
1137
1138           if (s->output_section->vma == 0)
1139             {
1140               /* Huh?  Shouldn't happen, but punt if it does.  */
1141               einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1142                      s->output_section->name, s->output_section->index,
1143                      s->output_section->flags);
1144               continue;
1145             }
1146
1147           symsize = bfd_get_symtab_upper_bound (b);
1148           symbols = (asymbol **) xmalloc (symsize);
1149           nsyms = bfd_canonicalize_symtab (b, symbols);
1150
1151           relsize = bfd_get_reloc_upper_bound (b, s);
1152           relocs = (arelent **) xmalloc ((size_t) relsize);
1153           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1154
1155           for (i = 0; i < nrelocs; i++)
1156             {
1157               if (pe_dll_extra_pe_debug)
1158                 {
1159                   struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1160                   printf ("rel: %s\n", sym->name);
1161                 }
1162               if (!relocs[i]->howto->pc_relative
1163                   && relocs[i]->howto->type != pe_details->imagebase_reloc)
1164                 {
1165                   bfd_vma sym_vma;
1166                   struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
1167
1168                   sym_vma = (relocs[i]->addend
1169                              + sym->value
1170                              + sym->section->vma
1171                              + sym->section->output_offset
1172                              + sym->section->output_section->vma);
1173                   reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1174
1175 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1176
1177                   switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1178                                          relocs[i]->howto->rightshift)
1179                     {
1180                     case BITS_AND_SHIFT (32, 0):
1181                       reloc_data[total_relocs].type = 3;
1182                       total_relocs++;
1183                       break;
1184                     case BITS_AND_SHIFT (16, 0):
1185                       reloc_data[total_relocs].type = 2;
1186                       total_relocs++;
1187                       break;
1188                     case BITS_AND_SHIFT (16, 16):
1189                       reloc_data[total_relocs].type = 4;
1190                       /* FIXME: we can't know the symbol's right value
1191                          yet, but we probably can safely assume that
1192                          CE will relocate us in 64k blocks, so leaving
1193                          it zero is safe.  */
1194                       reloc_data[total_relocs].extra = 0;
1195                       total_relocs++;
1196                       break;
1197                     case BITS_AND_SHIFT (26, 2):
1198                       reloc_data[total_relocs].type = 5;
1199                       total_relocs++;
1200                       break;
1201                     default:
1202                       /* xgettext:c-format */
1203                       einfo (_("%XError: %d-bit reloc in dll\n"),
1204                              relocs[i]->howto->bitsize);
1205                       break;
1206                     }
1207                 }
1208             }
1209           free (relocs);
1210           /* Warning: the allocated symbols are remembered in BFD and
1211              reused later, so don't free them!  */
1212 #if 0
1213           free (symbol);
1214 #endif
1215         }
1216     }
1217
1218   /* At this point, we have total_relocs relocation addresses in
1219      reloc_addresses, which are all suitable for the .reloc section.
1220      We must now create the new sections.  */
1221   qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1222
1223   for (i = 0; i < total_relocs; i++)
1224     {
1225       unsigned long this_page = (reloc_data[i].vma >> 12);
1226
1227       if (this_page != sec_page)
1228         {
1229           reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align.  */
1230           reloc_sz += 8;
1231           sec_page = this_page;
1232         }
1233
1234       reloc_sz += 2;
1235
1236       if (reloc_data[i].type == 4)
1237         reloc_sz += 2;
1238     }
1239
1240   reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align.  */
1241   reloc_d = (unsigned char *) xmalloc (reloc_sz);
1242   sec_page = (unsigned long) (-1);
1243   reloc_sz = 0;
1244   page_ptr = (unsigned long) (-1);
1245   page_count = 0;
1246
1247   for (i = 0; i < total_relocs; i++)
1248     {
1249       unsigned long rva = reloc_data[i].vma - image_base;
1250       unsigned long this_page = (rva & ~0xfff);
1251
1252       if (this_page != sec_page)
1253         {
1254           while (reloc_sz & 3)
1255             reloc_d[reloc_sz++] = 0;
1256
1257           if (page_ptr != (unsigned long) (-1))
1258             bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1259
1260           bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1261           page_ptr = reloc_sz;
1262           reloc_sz += 8;
1263           sec_page = this_page;
1264           page_count = 0;
1265         }
1266
1267       bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1268                   reloc_d + reloc_sz);
1269       reloc_sz += 2;
1270
1271       if (reloc_data[i].type == 4)
1272         {
1273           bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1274           reloc_sz += 2;
1275         }
1276
1277       page_count++;
1278     }
1279
1280   while (reloc_sz & 3)
1281     reloc_d[reloc_sz++] = 0;
1282
1283   if (page_ptr != (unsigned long) (-1))
1284     bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1285
1286   while (reloc_sz < reloc_s->_raw_size)
1287     reloc_d[reloc_sz++] = 0;
1288 }
1289
1290 /* Given the exiting def_file structure, print out a .DEF file that
1291    corresponds to it.  */
1292
1293 static void
1294 quoteput (s, f, needs_quotes)
1295      char *s;
1296      FILE *f;
1297      int needs_quotes;
1298 {
1299   char *cp;
1300
1301   for (cp = s; *cp; cp++)
1302     if (*cp == '\''
1303         || *cp == '"'
1304         || *cp == '\\'
1305         || ISSPACE (*cp)
1306         || *cp == ','
1307         || *cp == ';')
1308       needs_quotes = 1;
1309
1310   if (needs_quotes)
1311     {
1312       putc ('"', f);
1313
1314       while (*s)
1315         {
1316           if (*s == '"' || *s == '\\')
1317             putc ('\\', f);
1318
1319           putc (*s, f);
1320           s++;
1321         }
1322
1323       putc ('"', f);
1324     }
1325   else
1326     fputs (s, f);
1327 }
1328
1329 void
1330 pe_dll_generate_def_file (pe_out_def_filename)
1331      const char *pe_out_def_filename;
1332 {
1333   int i;
1334   FILE *out = fopen (pe_out_def_filename, "w");
1335
1336   if (out == NULL)
1337     /* xgettext:c-format */
1338     einfo (_("%s: Can't open output def file %s\n"),
1339            program_name, pe_out_def_filename);
1340
1341   if (pe_def_file)
1342     {
1343       if (pe_def_file->name)
1344         {
1345           if (pe_def_file->is_dll)
1346             fprintf (out, "LIBRARY ");
1347           else
1348             fprintf (out, "NAME ");
1349
1350           quoteput (pe_def_file->name, out, 1);
1351
1352           if (pe_data (output_bfd)->pe_opthdr.ImageBase)
1353             fprintf (out, " BASE=0x%lx",
1354                      (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
1355           fprintf (out, "\n");
1356         }
1357
1358       if (pe_def_file->description)
1359         {
1360           fprintf (out, "DESCRIPTION ");
1361           quoteput (pe_def_file->description, out, 1);
1362           fprintf (out, "\n");
1363         }
1364
1365       if (pe_def_file->version_minor != -1)
1366         fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1367                  pe_def_file->version_minor);
1368       else if (pe_def_file->version_major != -1)
1369         fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1370
1371       if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1372         fprintf (out, "\n");
1373
1374       if (pe_def_file->stack_commit != -1)
1375         fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1376                  pe_def_file->stack_reserve, pe_def_file->stack_commit);
1377       else if (pe_def_file->stack_reserve != -1)
1378         fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1379
1380       if (pe_def_file->heap_commit != -1)
1381         fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1382                  pe_def_file->heap_reserve, pe_def_file->heap_commit);
1383       else if (pe_def_file->heap_reserve != -1)
1384         fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1385
1386       if (pe_def_file->num_section_defs > 0)
1387         {
1388           fprintf (out, "\nSECTIONS\n\n");
1389
1390           for (i = 0; i < pe_def_file->num_section_defs; i++)
1391             {
1392               fprintf (out, "    ");
1393               quoteput (pe_def_file->section_defs[i].name, out, 0);
1394
1395               if (pe_def_file->section_defs[i].class)
1396                 {
1397                   fprintf (out, " CLASS ");
1398                   quoteput (pe_def_file->section_defs[i].class, out, 0);
1399                 }
1400
1401               if (pe_def_file->section_defs[i].flag_read)
1402                 fprintf (out, " READ");
1403
1404               if (pe_def_file->section_defs[i].flag_write)
1405                 fprintf (out, " WRITE");
1406
1407               if (pe_def_file->section_defs[i].flag_execute)
1408                 fprintf (out, " EXECUTE");
1409
1410               if (pe_def_file->section_defs[i].flag_shared)
1411                 fprintf (out, " SHARED");
1412
1413               fprintf (out, "\n");
1414             }
1415         }
1416
1417       if (pe_def_file->num_exports > 0)
1418         {
1419           fprintf (out, "EXPORTS\n");
1420
1421           for (i = 0; i < pe_def_file->num_exports; i++)
1422             {
1423               def_file_export *e = pe_def_file->exports + i;
1424               fprintf (out, "    ");
1425               quoteput (e->name, out, 0);
1426
1427               if (e->internal_name && strcmp (e->internal_name, e->name))
1428                 {
1429                   fprintf (out, " = ");
1430                   quoteput (e->internal_name, out, 0);
1431                 }
1432
1433               if (e->ordinal != -1)
1434                 fprintf (out, " @%d", e->ordinal);
1435
1436               if (e->flag_private)
1437                 fprintf (out, " PRIVATE");
1438
1439               if (e->flag_constant)
1440                 fprintf (out, " CONSTANT");
1441
1442               if (e->flag_noname)
1443                 fprintf (out, " NONAME");
1444
1445               if (e->flag_data)
1446                 fprintf (out, " DATA");
1447
1448               fprintf (out, "\n");
1449             }
1450         }
1451
1452       if (pe_def_file->num_imports > 0)
1453         {
1454           fprintf (out, "\nIMPORTS\n\n");
1455
1456           for (i = 0; i < pe_def_file->num_imports; i++)
1457             {
1458               def_file_import *im = pe_def_file->imports + i;
1459               fprintf (out, "    ");
1460
1461               if (im->internal_name
1462                   && (!im->name || strcmp (im->internal_name, im->name)))
1463                 {
1464                   quoteput (im->internal_name, out, 0);
1465                   fprintf (out, " = ");
1466                 }
1467
1468               quoteput (im->module->name, out, 0);
1469               fprintf (out, ".");
1470
1471               if (im->name)
1472                 quoteput (im->name, out, 0);
1473               else
1474                 fprintf (out, "%d", im->ordinal);
1475
1476               fprintf (out, "\n");
1477             }
1478         }
1479     }
1480   else
1481     fprintf (out, _("; no contents available\n"));
1482
1483   if (fclose (out) == EOF)
1484     /* xgettext:c-format */
1485     einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1486 }
1487
1488 /* Generate the import library.  */
1489
1490 static asymbol **symtab;
1491 static int symptr;
1492 static int tmp_seq;
1493 static const char *dll_filename;
1494 static char *dll_symname;
1495
1496 #define UNDSEC (asection *) &bfd_und_section
1497
1498 static asection *
1499 quick_section (abfd, name, flags, align)
1500      bfd *abfd;
1501      const char *name;
1502      int flags;
1503      int align;
1504 {
1505   asection *sec;
1506   asymbol *sym;
1507
1508   sec = bfd_make_section_old_way (abfd, name);
1509   bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1510   bfd_set_section_alignment (abfd, sec, align);
1511   /* Remember to undo this before trying to link internally!  */
1512   sec->output_section = sec;
1513
1514   sym = bfd_make_empty_symbol (abfd);
1515   symtab[symptr++] = sym;
1516   sym->name = sec->name;
1517   sym->section = sec;
1518   sym->flags = BSF_LOCAL;
1519   sym->value = 0;
1520
1521   return sec;
1522 }
1523
1524 static void
1525 quick_symbol (abfd, n1, n2, n3, sec, flags, addr)
1526      bfd *abfd;
1527      const char *n1;
1528      const char *n2;
1529      const char *n3;
1530      asection *sec;
1531      int flags;
1532      int addr;
1533 {
1534   asymbol *sym;
1535   char *name = (char *) xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1536
1537   strcpy (name, n1);
1538   strcat (name, n2);
1539   strcat (name, n3);
1540   sym = bfd_make_empty_symbol (abfd);
1541   sym->name = name;
1542   sym->section = sec;
1543   sym->flags = flags;
1544   sym->value = addr;
1545   symtab[symptr++] = sym;
1546 }
1547
1548 static arelent *reltab = 0;
1549 static int relcount = 0, relsize = 0;
1550
1551 static void
1552 quick_reloc (abfd, address, which_howto, symidx)
1553      bfd *abfd;
1554      int address;
1555      int which_howto;
1556      int symidx;
1557 {
1558   if (relcount >= (relsize - 1))
1559     {
1560       relsize += 10;
1561       if (reltab)
1562         reltab = (arelent *) xrealloc (reltab, relsize * sizeof (arelent));
1563       else
1564         reltab = (arelent *) xmalloc (relsize * sizeof (arelent));
1565     }
1566   reltab[relcount].address = address;
1567   reltab[relcount].addend = 0;
1568   reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1569   reltab[relcount].sym_ptr_ptr = symtab + symidx;
1570   relcount++;
1571 }
1572
1573 static void
1574 save_relocs (asection *sec)
1575 {
1576   int i;
1577
1578   sec->relocation = reltab;
1579   sec->reloc_count = relcount;
1580   sec->orelocation = (arelent **) xmalloc ((relcount + 1) * sizeof (arelent *));
1581   for (i = 0; i < relcount; i++)
1582     sec->orelocation[i] = sec->relocation + i;
1583   sec->orelocation[relcount] = 0;
1584   sec->flags |= SEC_RELOC;
1585   reltab = 0;
1586   relcount = relsize = 0;
1587 }
1588
1589 /*      .section        .idata$2
1590         .global         __head_my_dll
1591    __head_my_dll:
1592         .rva            hname
1593         .long           0
1594         .long           0
1595         .rva            __my_dll_iname
1596         .rva            fthunk
1597
1598         .section        .idata$5
1599         .long           0
1600    fthunk:
1601
1602         .section        .idata$4
1603         .long           0
1604    hname:                              */
1605
1606 static bfd *
1607 make_head (parent)
1608      bfd *parent;
1609 {
1610   asection *id2, *id5, *id4;
1611   unsigned char *d2, *d5, *d4;
1612   char *oname;
1613   bfd *abfd;
1614
1615   oname = (char *) xmalloc (20);
1616   sprintf (oname, "d%06d.o", tmp_seq);
1617   tmp_seq++;
1618
1619   abfd = bfd_create (oname, parent);
1620   bfd_find_target (pe_details->object_target, abfd);
1621   bfd_make_writable (abfd);
1622
1623   bfd_set_format (abfd, bfd_object);
1624   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1625
1626   symptr = 0;
1627   symtab = (asymbol **) xmalloc (6 * sizeof (asymbol *));
1628   id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1629   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1630   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1631   quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1632   quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1633
1634   /* OK, pay attention here.  I got confused myself looking back at
1635      it.  We create a four-byte section to mark the beginning of the
1636      list, and we include an offset of 4 in the section, so that the
1637      pointer to the list points to the *end* of this section, which is
1638      the start of the list of sections from other objects.  */
1639
1640   bfd_set_section_size (abfd, id2, 20);
1641   d2 = (unsigned char *) xmalloc (20);
1642   id2->contents = d2;
1643   memset (d2, 0, 20);
1644   d2[0] = d2[16] = 4; /* Reloc addend.  */
1645   quick_reloc (abfd,  0, BFD_RELOC_RVA, 2);
1646   quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1647   quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1648   save_relocs (id2);
1649
1650   bfd_set_section_size (abfd, id5, 4);
1651   d5 = (unsigned char *) xmalloc (4);
1652   id5->contents = d5;
1653   memset (d5, 0, 4);
1654
1655   bfd_set_section_size (abfd, id4, 4);
1656   d4 = (unsigned char *) xmalloc (4);
1657   id4->contents = d4;
1658   memset (d4, 0, 4);
1659
1660   bfd_set_symtab (abfd, symtab, symptr);
1661
1662   bfd_set_section_contents (abfd, id2, d2, 0, 20);
1663   bfd_set_section_contents (abfd, id5, d5, 0, 4);
1664   bfd_set_section_contents (abfd, id4, d4, 0, 4);
1665
1666   bfd_make_readable (abfd);
1667   return abfd;
1668 }
1669
1670 /*      .section        .idata$4
1671         .long           0
1672         .section        .idata$5
1673         .long           0
1674         .section        idata$7
1675         .global         __my_dll_iname
1676   __my_dll_iname:
1677         .asciz          "my.dll"       */
1678
1679 static bfd *
1680 make_tail (parent)
1681      bfd *parent;
1682 {
1683   asection *id4, *id5, *id7;
1684   unsigned char *d4, *d5, *d7;
1685   int len;
1686   char *oname;
1687   bfd *abfd;
1688
1689   oname = (char *) xmalloc (20);
1690   sprintf (oname, "d%06d.o", tmp_seq);
1691   tmp_seq++;
1692
1693   abfd = bfd_create (oname, parent);
1694   bfd_find_target (pe_details->object_target, abfd);
1695   bfd_make_writable (abfd);
1696
1697   bfd_set_format (abfd, bfd_object);
1698   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1699
1700   symptr = 0;
1701   symtab = (asymbol **) xmalloc (5 * sizeof (asymbol *));
1702   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1703   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1704   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1705   quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1706
1707   bfd_set_section_size (abfd, id4, 4);
1708   d4 = (unsigned char *) xmalloc (4);
1709   id4->contents = d4;
1710   memset (d4, 0, 4);
1711
1712   bfd_set_section_size (abfd, id5, 4);
1713   d5 = (unsigned char *) xmalloc (4);
1714   id5->contents = d5;
1715   memset (d5, 0, 4);
1716
1717   len = strlen (dll_filename) + 1;
1718   if (len & 1)
1719     len++;
1720   bfd_set_section_size (abfd, id7, len);
1721   d7 = (unsigned char *) xmalloc (len);
1722   id7->contents = d7;
1723   strcpy (d7, dll_filename);
1724
1725   bfd_set_symtab (abfd, symtab, symptr);
1726
1727   bfd_set_section_contents (abfd, id4, d4, 0, 4);
1728   bfd_set_section_contents (abfd, id5, d5, 0, 4);
1729   bfd_set_section_contents (abfd, id7, d7, 0, len);
1730
1731   bfd_make_readable (abfd);
1732   return abfd;
1733 }
1734
1735 /*      .text
1736         .global         _function
1737         .global         ___imp_function
1738         .global         __imp__function
1739   _function:
1740         jmp             *__imp__function:
1741
1742         .section        idata$7
1743         .long           __head_my_dll
1744
1745         .section        .idata$5
1746   ___imp_function:
1747   __imp__function:
1748   iat?
1749         .section        .idata$4
1750   iat?
1751         .section        .idata$6
1752   ID<ordinal>:
1753         .short          <hint>
1754         .asciz          "function" xlate? (add underscore, kill at)  */
1755
1756 static unsigned char jmp_ix86_bytes[] =
1757 {
1758   0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1759 };
1760
1761 /* _function:
1762         mov.l   ip+8,r0
1763         mov.l   @r0,r0
1764         jmp     @r0
1765         nop
1766         .dw     __imp_function   */
1767
1768 static unsigned char jmp_sh_bytes[] =
1769 {
1770   0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1771 };
1772
1773 /* _function:
1774         lui     $t0,<high:__imp_function>
1775         lw      $t0,<low:__imp_function>
1776         jr      $t0
1777         nop                              */
1778
1779 static unsigned char jmp_mips_bytes[] =
1780 {
1781   0x00, 0x00, 0x08, 0x3c,  0x00, 0x00, 0x08, 0x8d,
1782   0x08, 0x00, 0x00, 0x01,  0x00, 0x00, 0x00, 0x00
1783 };
1784
1785 static bfd *
1786 make_one (exp, parent)
1787      def_file_export *exp;
1788      bfd *parent;
1789 {
1790   asection *tx, *id7, *id5, *id4, *id6;
1791   unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
1792   int len;
1793   char *oname;
1794   bfd *abfd;
1795   unsigned char *jmp_bytes = NULL;
1796   int jmp_byte_count = 0;
1797
1798   switch (pe_details->pe_arch)
1799     {
1800     case PE_ARCH_i386:
1801       jmp_bytes = jmp_ix86_bytes;
1802       jmp_byte_count = sizeof (jmp_ix86_bytes);
1803       break;
1804     case PE_ARCH_sh:
1805       jmp_bytes = jmp_sh_bytes;
1806       jmp_byte_count = sizeof (jmp_sh_bytes);
1807       break;
1808     case PE_ARCH_mips:
1809       jmp_bytes = jmp_mips_bytes;
1810       jmp_byte_count = sizeof (jmp_mips_bytes);
1811       break;
1812     default:
1813       abort ();
1814     }
1815
1816   oname = (char *) xmalloc (20);
1817   sprintf (oname, "d%06d.o", tmp_seq);
1818   tmp_seq++;
1819
1820   abfd = bfd_create (oname, parent);
1821   bfd_find_target (pe_details->object_target, abfd);
1822   bfd_make_writable (abfd);
1823
1824   bfd_set_format (abfd, bfd_object);
1825   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1826
1827   symptr = 0;
1828   symtab = (asymbol **) xmalloc (11 * sizeof (asymbol *));
1829   tx  = quick_section (abfd, ".text",    SEC_CODE|SEC_HAS_CONTENTS, 2);
1830   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1831   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1832   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1833   id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1834
1835   if  (*exp->internal_name == '@')
1836     {
1837       if (! exp->flag_data)
1838         quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
1839       quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC, BSF_GLOBAL, 0);
1840       quick_symbol (abfd, U ("_imp_"), exp->internal_name, "", id5, BSF_GLOBAL, 0);
1841       /* Fastcall applies only to functions,
1842          so no need for auto-import symbol.  */
1843     }
1844   else
1845     {
1846       if (! exp->flag_data)
1847         quick_symbol (abfd, U (""), exp->internal_name, "", tx, BSF_GLOBAL, 0);
1848       quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC, BSF_GLOBAL, 0);
1849       quick_symbol (abfd, U ("_imp__"), exp->internal_name, "", id5, BSF_GLOBAL, 0);
1850       /* Symbol to reference ord/name of imported
1851          data symbol, used to implement auto-import.  */
1852       if (exp->flag_data)
1853         quick_symbol (abfd, U("_nm__"), exp->internal_name, "", id6, BSF_GLOBAL,0);
1854     }
1855   if (pe_dll_compat_implib)
1856     quick_symbol (abfd, U ("__imp_"), exp->internal_name, "",
1857                   id5, BSF_GLOBAL, 0);
1858
1859   if (! exp->flag_data)
1860     {
1861       bfd_set_section_size (abfd, tx, jmp_byte_count);
1862       td = (unsigned char *) xmalloc (jmp_byte_count);
1863       tx->contents = td;
1864       memcpy (td, jmp_bytes, jmp_byte_count);
1865
1866       switch (pe_details->pe_arch)
1867         {
1868         case PE_ARCH_i386:
1869           quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1870           break;
1871         case PE_ARCH_sh:
1872           quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1873           break;
1874         case PE_ARCH_mips:
1875           quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1876           quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1877           quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1878           break;
1879         default:
1880           abort ();
1881         }
1882       save_relocs (tx);
1883     }
1884
1885   bfd_set_section_size (abfd, id7, 4);
1886   d7 = (unsigned char *) xmalloc (4);
1887   id7->contents = d7;
1888   memset (d7, 0, 4);
1889   quick_reloc (abfd, 0, BFD_RELOC_RVA, 6);
1890   save_relocs (id7);
1891
1892   bfd_set_section_size (abfd, id5, 4);
1893   d5 = (unsigned char *) xmalloc (4);
1894   id5->contents = d5;
1895   memset (d5, 0, 4);
1896
1897   if (exp->flag_noname)
1898     {
1899       d5[0] = exp->ordinal;
1900       d5[1] = exp->ordinal >> 8;
1901       d5[3] = 0x80;
1902     }
1903   else
1904     {
1905       quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1906       save_relocs (id5);
1907     }
1908
1909   bfd_set_section_size (abfd, id4, 4);
1910   d4 = (unsigned char *) xmalloc (4);
1911   id4->contents = d4;
1912   memset (d4, 0, 4);
1913
1914   if (exp->flag_noname)
1915     {
1916       d4[0] = exp->ordinal;
1917       d4[1] = exp->ordinal >> 8;
1918       d4[3] = 0x80;
1919     }
1920   else
1921     {
1922       quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1923       save_relocs (id4);
1924     }
1925
1926   if (exp->flag_noname)
1927     {
1928       len = 0;
1929       bfd_set_section_size (abfd, id6, 0);
1930     }
1931   else
1932     {
1933       len = strlen (exp->name) + 3;
1934       if (len & 1)
1935         len++;
1936       bfd_set_section_size (abfd, id6, len);
1937       d6 = (unsigned char *) xmalloc (len);
1938       id6->contents = d6;
1939       memset (d6, 0, len);
1940       d6[0] = exp->hint & 0xff;
1941       d6[1] = exp->hint >> 8;
1942       strcpy (d6 + 2, exp->name);
1943     }
1944
1945   bfd_set_symtab (abfd, symtab, symptr);
1946
1947   bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
1948   bfd_set_section_contents (abfd, id7, d7, 0, 4);
1949   bfd_set_section_contents (abfd, id5, d5, 0, 4);
1950   bfd_set_section_contents (abfd, id4, d4, 0, 4);
1951   if (!exp->flag_noname)
1952     bfd_set_section_contents (abfd, id6, d6, 0, len);
1953
1954   bfd_make_readable (abfd);
1955   return abfd;
1956 }
1957
1958 static bfd *
1959 make_singleton_name_thunk (import, parent)
1960      const char *import;
1961      bfd *parent;
1962 {
1963   /* Name thunks go to idata$4.  */
1964   asection *id4;
1965   unsigned char *d4;
1966   char *oname;
1967   bfd *abfd;
1968
1969   oname = (char *) xmalloc (20);
1970   sprintf (oname, "nmth%06d.o", tmp_seq);
1971   tmp_seq++;
1972
1973   abfd = bfd_create (oname, parent);
1974   bfd_find_target (pe_details->object_target, abfd);
1975   bfd_make_writable (abfd);
1976
1977   bfd_set_format (abfd, bfd_object);
1978   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1979
1980   symptr = 0;
1981   symtab = (asymbol **) xmalloc (3 * sizeof (asymbol *));
1982   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1983   quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
1984   quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
1985
1986   bfd_set_section_size (abfd, id4, 8);
1987   d4 = (unsigned char *) xmalloc (4);
1988   id4->contents = d4;
1989   memset (d4, 0, 8);
1990   quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1991   save_relocs (id4);
1992
1993   bfd_set_symtab (abfd, symtab, symptr);
1994
1995   bfd_set_section_contents (abfd, id4, d4, 0, 8);
1996
1997   bfd_make_readable (abfd);
1998   return abfd;
1999 }
2000
2001 static char *
2002 make_import_fixup_mark (rel)
2003      arelent *rel;
2004 {
2005   /* We convert reloc to symbol, for later reference.  */
2006   static int counter;
2007   static char *fixup_name = NULL;
2008   static size_t buffer_len = 0;
2009
2010   struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
2011
2012   bfd *abfd = bfd_asymbol_bfd (sym);
2013   struct bfd_link_hash_entry *bh;
2014
2015   if (!fixup_name)
2016     {
2017       fixup_name = (char *) xmalloc (384);
2018       buffer_len = 384;
2019     }
2020
2021   if (strlen (sym->name) + 25 > buffer_len)
2022   /* Assume 25 chars for "__fu" + counter + "_".  If counter is
2023      bigger than 20 digits long, we've got worse problems than
2024      overflowing this buffer...  */
2025     {
2026       free (fixup_name);
2027       /* New buffer size is length of symbol, plus 25, but
2028          then rounded up to the nearest multiple of 128.  */
2029       buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2030       fixup_name = (char *) xmalloc (buffer_len);
2031     }
2032
2033   sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2034
2035   bh = NULL;
2036   bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2037                                 current_sec, /* sym->section, */
2038                                 rel->address, NULL, TRUE, FALSE, &bh);
2039
2040   if (0)
2041     {
2042       struct coff_link_hash_entry *myh;
2043
2044       myh = (struct coff_link_hash_entry *) bh;
2045       printf ("type:%d\n", myh->type);
2046       printf ("%s\n", myh->root.u.def.section->name);
2047     }
2048
2049   return fixup_name;
2050 }
2051
2052 /*      .section        .idata$3
2053         .rva            __nm_thnk_SYM (singleton thunk with name of func)
2054         .long           0
2055         .long           0
2056         .rva            __my_dll_iname (name of dll)
2057         .rva            __fuNN_SYM (pointer to reference (address) in text)  */
2058
2059 static bfd *
2060 make_import_fixup_entry (name, fixup_name, dll_symname, parent)
2061      const char *name;
2062      const char *fixup_name;
2063      const char *dll_symname;
2064      bfd *parent;
2065 {
2066   asection *id3;
2067   unsigned char *d3;
2068   char *oname;
2069   bfd *abfd;
2070
2071   oname = (char *) xmalloc (20);
2072   sprintf (oname, "fu%06d.o", tmp_seq);
2073   tmp_seq++;
2074
2075   abfd = bfd_create (oname, parent);
2076   bfd_find_target (pe_details->object_target, abfd);
2077   bfd_make_writable (abfd);
2078
2079   bfd_set_format (abfd, bfd_object);
2080   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2081
2082   symptr = 0;
2083   symtab = (asymbol **) xmalloc (6 * sizeof (asymbol *));
2084   id3 = quick_section (abfd, ".idata$3", SEC_HAS_CONTENTS, 2);
2085
2086 #if 0
2087   quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
2088 #endif
2089   quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
2090   quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2091   quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2092
2093   bfd_set_section_size (abfd, id3, 20);
2094   d3 = (unsigned char *) xmalloc (20);
2095   id3->contents = d3;
2096   memset (d3, 0, 20);
2097
2098   quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2099   quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2100   quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2101   save_relocs (id3);
2102
2103   bfd_set_symtab (abfd, symtab, symptr);
2104
2105   bfd_set_section_contents (abfd, id3, d3, 0, 20);
2106
2107   bfd_make_readable (abfd);
2108   return abfd;
2109 }
2110
2111 /*      .section        .rdata_runtime_pseudo_reloc
2112         .long           addend
2113         .rva            __fuNN_SYM (pointer to reference (address) in text)  */
2114
2115 static bfd *
2116 make_runtime_pseudo_reloc (name, fixup_name, addend, parent)
2117      const char *name ATTRIBUTE_UNUSED;
2118      const char *fixup_name;
2119      int addend;
2120      bfd *parent;
2121 {
2122   asection *rt_rel;
2123   unsigned char *rt_rel_d;
2124   char *oname;
2125   bfd *abfd;
2126
2127   oname = (char *) xmalloc (20);
2128   sprintf (oname, "rtr%06d.o", tmp_seq);
2129   tmp_seq++;
2130
2131   abfd = bfd_create (oname, parent);
2132   bfd_find_target (pe_details->object_target, abfd);
2133   bfd_make_writable (abfd);
2134
2135   bfd_set_format (abfd, bfd_object);
2136   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2137
2138   symptr = 0;
2139   symtab = (asymbol **) xmalloc (2 * sizeof (asymbol *));
2140   rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS, 2);
2141
2142   quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2143
2144   bfd_set_section_size (abfd, rt_rel, 8);
2145   rt_rel_d = (unsigned char *) xmalloc (8);
2146   rt_rel->contents = rt_rel_d;
2147   memset (rt_rel_d, 0, 8);
2148   bfd_put_32 (abfd, addend, rt_rel_d);
2149
2150   quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2151   save_relocs (rt_rel);
2152
2153   bfd_set_symtab (abfd, symtab, symptr);
2154
2155   bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2156
2157   bfd_make_readable (abfd);
2158   return abfd;
2159 }
2160
2161 /*      .section        .rdata
2162         .rva            __pei386_runtime_relocator  */
2163
2164 static bfd *
2165 pe_create_runtime_relocator_reference (parent)
2166      bfd *parent;
2167 {
2168   asection *extern_rt_rel;
2169   unsigned char *extern_rt_rel_d;
2170   char *oname;
2171   bfd *abfd;
2172
2173   oname = (char *) xmalloc (20);
2174   sprintf (oname, "ertr%06d.o", tmp_seq);
2175   tmp_seq++;
2176
2177   abfd = bfd_create (oname, parent);
2178   bfd_find_target (pe_details->object_target, abfd);
2179   bfd_make_writable (abfd);
2180
2181   bfd_set_format (abfd, bfd_object);
2182   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2183
2184   symptr = 0;
2185   symtab = (asymbol **) xmalloc (2 * sizeof (asymbol *));
2186   extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2187
2188   quick_symbol (abfd, "", "__pei386_runtime_relocator", "", UNDSEC, BSF_NO_FLAGS, 0);
2189
2190   bfd_set_section_size (abfd, extern_rt_rel, 4);
2191   extern_rt_rel_d = (unsigned char *) xmalloc (4);
2192   extern_rt_rel->contents = extern_rt_rel_d;
2193
2194   quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2195   save_relocs (extern_rt_rel);
2196
2197   bfd_set_symtab (abfd, symtab, symptr);
2198
2199   bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
2200
2201   bfd_make_readable (abfd);
2202   return abfd;
2203 }
2204
2205 void
2206 pe_create_import_fixup (rel, s, addend)
2207      arelent *rel;
2208      asection *s;
2209      int addend;
2210 {
2211   char buf[300];
2212   struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
2213   struct bfd_link_hash_entry *name_thunk_sym;
2214   const char *name = sym->name;
2215   char *fixup_name = make_import_fixup_mark (rel);
2216   bfd *b;
2217
2218   sprintf (buf, U ("_nm_thnk_%s"), name);
2219
2220   name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2221
2222   if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
2223     {
2224       bfd *b = make_singleton_name_thunk (name, output_bfd);
2225       add_bfd_to_link (b, b->filename, &link_info);
2226
2227       /* If we ever use autoimport, we have to cast text section writable.  */
2228       config.text_read_only = FALSE;
2229     }
2230
2231   if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2232     {
2233       extern char * pe_data_import_dll;
2234       char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2235
2236       b = make_import_fixup_entry (name, fixup_name, dll_symname, output_bfd);
2237       add_bfd_to_link (b, b->filename, &link_info);
2238     }
2239
2240   if (addend != 0)
2241     {
2242       if (link_info.pei386_runtime_pseudo_reloc)
2243         {
2244           if (pe_dll_extra_pe_debug)
2245             printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2246                    fixup_name, addend);
2247           b = make_runtime_pseudo_reloc (name, fixup_name, addend, output_bfd);
2248           add_bfd_to_link (b, b->filename, &link_info);
2249
2250           if (runtime_pseudo_relocs_created == 0)
2251             {
2252               b = pe_create_runtime_relocator_reference (output_bfd);
2253               add_bfd_to_link (b, b->filename, &link_info);
2254             }
2255           runtime_pseudo_relocs_created++;
2256         }
2257       else
2258         {
2259           einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2260                  s->owner, s, rel->address, sym->name);
2261           einfo ("%X");
2262         }
2263     }
2264 }
2265
2266
2267 void
2268 pe_dll_generate_implib (def, impfilename)
2269      def_file *def;
2270      const char *impfilename;
2271 {
2272   int i;
2273   bfd *ar_head;
2274   bfd *ar_tail;
2275   bfd *outarch;
2276   bfd *head = 0;
2277
2278   dll_filename = (def->name) ? def->name : dll_name;
2279   dll_symname = xstrdup (dll_filename);
2280   for (i = 0; dll_symname[i]; i++)
2281     if (!ISALNUM (dll_symname[i]))
2282       dll_symname[i] = '_';
2283
2284   unlink (impfilename);
2285
2286   outarch = bfd_openw (impfilename, 0);
2287
2288   if (!outarch)
2289     {
2290       /* xgettext:c-format */
2291       einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2292       return;
2293     }
2294
2295   /* xgettext:c-format */
2296   einfo (_("Creating library file: %s\n"), impfilename);
2297
2298   bfd_set_format (outarch, bfd_archive);
2299   outarch->has_armap = 1;
2300
2301   /* Work out a reasonable size of things to put onto one line.  */
2302   ar_head = make_head (outarch);
2303
2304   for (i = 0; i < def->num_exports; i++)
2305     {
2306       /* The import library doesn't know about the internal name.  */
2307       char *internal = def->exports[i].internal_name;
2308       bfd *n;
2309
2310       def->exports[i].internal_name = def->exports[i].name;
2311       n = make_one (def->exports + i, outarch);
2312       n->next = head;
2313       head = n;
2314       def->exports[i].internal_name = internal;
2315     }
2316
2317   ar_tail = make_tail (outarch);
2318
2319   if (ar_head == NULL || ar_tail == NULL)
2320     return;
2321
2322   /* Now stick them all into the archive.  */
2323   ar_head->next = head;
2324   ar_tail->next = ar_head;
2325   head = ar_tail;
2326
2327   if (! bfd_set_archive_head (outarch, head))
2328     einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
2329
2330   if (! bfd_close (outarch))
2331     einfo ("%Xbfd_close %s: %s\n", impfilename, bfd_errmsg (bfd_get_error ()));
2332
2333   while (head != NULL)
2334     {
2335       bfd *n = head->next;
2336       bfd_close (head);
2337       head = n;
2338     }
2339 }
2340
2341 static void
2342 add_bfd_to_link (abfd, name, link_info)
2343      bfd *abfd;
2344      const char *name;
2345      struct bfd_link_info *link_info;
2346 {
2347   lang_input_statement_type *fake_file;
2348
2349   fake_file = lang_add_input_file (name,
2350                                    lang_input_file_is_fake_enum,
2351                                    NULL);
2352   fake_file->the_bfd = abfd;
2353   ldlang_add_file (fake_file);
2354
2355   if (!bfd_link_add_symbols (abfd, link_info))
2356     einfo ("%Xaddsym %s: %s\n", name, bfd_errmsg (bfd_get_error ()));
2357 }
2358
2359 void
2360 pe_process_import_defs (output_bfd, link_info)
2361      bfd *output_bfd;
2362      struct bfd_link_info *link_info;
2363 {
2364   def_file_module *module;
2365
2366   pe_dll_id_target (bfd_get_target (output_bfd));
2367
2368   if (!pe_def_file)
2369     return;
2370
2371   for (module = pe_def_file->modules; module; module = module->next)
2372     {
2373       int i, do_this_dll;
2374
2375       dll_filename = module->name;
2376       dll_symname = xstrdup (module->name);
2377       for (i = 0; dll_symname[i]; i++)
2378         if (!ISALNUM (dll_symname[i]))
2379           dll_symname[i] = '_';
2380
2381       do_this_dll = 0;
2382
2383       for (i = 0; i < pe_def_file->num_imports; i++)
2384         if (pe_def_file->imports[i].module == module)
2385           {
2386             def_file_export exp;
2387             struct bfd_link_hash_entry *blhe;
2388             int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2389             /* See if we need this import.  */
2390             char *name = (char *) xmalloc (strlen (pe_def_file->imports[i].internal_name) + 2 + 6);
2391
2392             if (lead_at)
2393               sprintf (name, "%s%s", "", pe_def_file->imports[i].internal_name);
2394             else
2395               sprintf (name, "%s%s",U (""), pe_def_file->imports[i].internal_name);
2396
2397             blhe = bfd_link_hash_lookup (link_info->hash, name,
2398                                          FALSE, FALSE, FALSE);
2399
2400             if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2401               {
2402                 if (lead_at)
2403                   sprintf (name, "%s%s", U ("_imp_"),
2404                            pe_def_file->imports[i].internal_name);
2405                 else
2406                   sprintf (name, "%s%s", U ("_imp__"),
2407                            pe_def_file->imports[i].internal_name);
2408
2409                 blhe = bfd_link_hash_lookup (link_info->hash, name,
2410                                              FALSE, FALSE, FALSE);
2411               }
2412             free (name);
2413
2414             if (blhe && blhe->type == bfd_link_hash_undefined)
2415               {
2416                 bfd *one;
2417                 /* We do.  */
2418                 if (!do_this_dll)
2419                   {
2420                     bfd *ar_head = make_head (output_bfd);
2421                     add_bfd_to_link (ar_head, ar_head->filename, link_info);
2422                     do_this_dll = 1;
2423                   }
2424                 exp.internal_name = pe_def_file->imports[i].internal_name;
2425                 exp.name = pe_def_file->imports[i].name;
2426                 exp.ordinal = pe_def_file->imports[i].ordinal;
2427                 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2428                 exp.flag_private = 0;
2429                 exp.flag_constant = 0;
2430                 exp.flag_data = pe_def_file->imports[i].data;
2431                 exp.flag_noname = exp.name ? 0 : 1;
2432                 one = make_one (&exp, output_bfd);
2433                 add_bfd_to_link (one, one->filename, link_info);
2434               }
2435           }
2436       if (do_this_dll)
2437         {
2438           bfd *ar_tail = make_tail (output_bfd);
2439           add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
2440         }
2441
2442       free (dll_symname);
2443     }
2444 }
2445
2446 /* We were handed a *.DLL file.  Parse it and turn it into a set of
2447    IMPORTS directives in the def file.  Return TRUE if the file was
2448    handled, FALSE if not.  */
2449
2450 static unsigned int
2451 pe_get16 (abfd, where)
2452      bfd *abfd;
2453      int where;
2454 {
2455   unsigned char b[2];
2456
2457   bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2458   bfd_bread (b, (bfd_size_type) 2, abfd);
2459   return b[0] + (b[1] << 8);
2460 }
2461
2462 static unsigned int
2463 pe_get32 (abfd, where)
2464      bfd *abfd;
2465      int where;
2466 {
2467   unsigned char b[4];
2468
2469   bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2470   bfd_bread (b, (bfd_size_type) 4, abfd);
2471   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2472 }
2473
2474 #if 0 /* This is not currently used.  */
2475
2476 static unsigned int
2477 pe_as16 (ptr)
2478      void *ptr;
2479 {
2480   unsigned char *b = ptr;
2481
2482   return b[0] + (b[1] << 8);
2483 }
2484
2485 #endif
2486
2487 static unsigned int
2488 pe_as32 (ptr)
2489      void *ptr;
2490 {
2491   unsigned char *b = ptr;
2492
2493   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2494 }
2495
2496 bfd_boolean
2497 pe_implied_import_dll (filename)
2498      const char *filename;
2499 {
2500   bfd *dll;
2501   unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
2502   unsigned long export_rva, export_size, nsections, secptr, expptr;
2503   unsigned long exp_funcbase;
2504   unsigned char *expdata, *erva;
2505   unsigned long name_rvas, ordinals, nexp, ordbase;
2506   const char *dll_name;
2507   /* Initialization with start > end guarantees that is_data
2508      will not be set by mistake, and avoids compiler warning.  */
2509   unsigned long data_start = 1;
2510   unsigned long data_end   = 0;
2511   unsigned long bss_start  = 1;
2512   unsigned long bss_end    = 0;
2513
2514   /* No, I can't use bfd here.  kernel32.dll puts its export table in
2515      the middle of the .rdata section.  */
2516   dll = bfd_openr (filename, pe_details->target_name);
2517   if (!dll)
2518     {
2519       einfo ("%Xopen %s: %s\n", filename, bfd_errmsg (bfd_get_error ()));
2520       return FALSE;
2521     }
2522
2523   /* PEI dlls seem to be bfd_objects.  */
2524   if (!bfd_check_format (dll, bfd_object))
2525     {
2526       einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
2527       return FALSE;
2528     }
2529
2530   /* Get pe_header, optional header and numbers of export entries.  */
2531   pe_header_offset = pe_get32 (dll, 0x3c);
2532   opthdr_ofs = pe_header_offset + 4 + 20;
2533   num_entries = pe_get32 (dll, opthdr_ofs + 92);
2534
2535   if (num_entries < 1) /* No exports.  */
2536     return FALSE;
2537
2538   export_rva = pe_get32 (dll, opthdr_ofs + 96);
2539   export_size = pe_get32 (dll, opthdr_ofs + 100);
2540   nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
2541   secptr = (pe_header_offset + 4 + 20 +
2542             pe_get16 (dll, pe_header_offset + 4 + 16));
2543   expptr = 0;
2544
2545   /* Get the rva and size of the export section.  */
2546   for (i = 0; i < nsections; i++)
2547     {
2548       char sname[8];
2549       unsigned long secptr1 = secptr + 40 * i;
2550       unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2551       unsigned long vsize = pe_get32 (dll, secptr1 + 16);
2552       unsigned long fptr = pe_get32 (dll, secptr1 + 20);
2553
2554       bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
2555       bfd_bread (sname, (bfd_size_type) 8, dll);
2556
2557       if (vaddr <= export_rva && vaddr + vsize > export_rva)
2558         {
2559           expptr = fptr + (export_rva - vaddr);
2560           if (export_rva + export_size > vaddr + vsize)
2561             export_size = vsize - (export_rva - vaddr);
2562           break;
2563         }
2564     }
2565
2566   /* Scan sections and store the base and size of the
2567      data and bss segments in data/base_start/end.  */
2568   for (i = 0; i < nsections; i++)
2569     {
2570       unsigned long secptr1 = secptr + 40 * i;
2571       unsigned long vsize = pe_get32 (dll, secptr1 + 8);
2572       unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
2573       unsigned long flags = pe_get32 (dll, secptr1 + 36);
2574       char sec_name[9];
2575
2576       sec_name[8] = '\0';
2577       bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
2578       bfd_bread (sec_name, (bfd_size_type) 8, dll);
2579
2580       if (strcmp(sec_name,".data") == 0)
2581         {
2582           data_start = vaddr;
2583           data_end = vaddr + vsize;
2584
2585           if (pe_dll_extra_pe_debug)
2586             printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2587                     __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2588         }
2589       else if (strcmp (sec_name,".bss") == 0)
2590         {
2591           bss_start = vaddr;
2592           bss_end = vaddr + vsize;
2593
2594           if (pe_dll_extra_pe_debug)
2595             printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
2596                     __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
2597         }
2598     }
2599
2600   expdata = (unsigned char *) xmalloc (export_size);
2601   bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
2602   bfd_bread (expdata, (bfd_size_type) export_size, dll);
2603   erva = expdata - export_rva;
2604
2605   if (pe_def_file == 0)
2606     pe_def_file = def_file_empty ();
2607
2608   nexp = pe_as32 (expdata + 24);
2609   name_rvas = pe_as32 (expdata + 32);
2610   ordinals = pe_as32 (expdata + 36);
2611   ordbase = pe_as32 (expdata + 16);
2612   exp_funcbase = pe_as32 (expdata + 28);
2613
2614   /* Use internal dll name instead of filename
2615      to enable symbolic dll linking.  */
2616   dll_name = pe_as32 (expdata + 12) + erva;
2617
2618   /* Check to see if the dll has already been added to
2619      the definition list and if so return without error.
2620      This avoids multiple symbol definitions.  */
2621   if (def_get_module (pe_def_file, dll_name))
2622     {
2623       if (pe_dll_extra_pe_debug)
2624         printf ("%s is already loaded\n", dll_name);
2625       return TRUE;
2626     }
2627
2628   /* Iterate through the list of symbols.  */
2629   for (i = 0; i < nexp; i++)
2630     {
2631       /* Pointer to the names vector.  */
2632       unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
2633       def_file_import *imp;
2634       /* Pointer to the function address vector.  */
2635       unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
2636       int is_data = 0;
2637
2638       /* Skip unwanted symbols, which are
2639          exported in buggy auto-import releases.  */
2640       if (strncmp (erva + name_rva, "_nm_", 4) != 0)
2641         {
2642           /* is_data is true if the address is in the data or bss segment.  */
2643           is_data =
2644             (func_rva >= data_start && func_rva < data_end)
2645             || (func_rva >= bss_start && func_rva < bss_end);
2646
2647           imp = def_file_add_import (pe_def_file, erva + name_rva,
2648                                      dll_name, i, 0);
2649           /* Mark symbol type.  */
2650           imp->data = is_data;
2651
2652           if (pe_dll_extra_pe_debug)
2653             printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
2654                     __FUNCTION__, dll_name, erva + name_rva,
2655                     func_rva, is_data ? "(data)" : "");
2656         }
2657     }
2658
2659   return TRUE;
2660 }
2661
2662 /* These are the main functions, called from the emulation.  The first
2663    is called after the bfds are read, so we can guess at how much space
2664    we need.  The second is called after everything is placed, so we
2665    can put the right values in place.  */
2666
2667 void
2668 pe_dll_build_sections (abfd, info)
2669      bfd *abfd;
2670      struct bfd_link_info *info;
2671 {
2672   pe_dll_id_target (bfd_get_target (abfd));
2673   process_def_file (abfd, info);
2674
2675   if (pe_def_file->num_exports == 0 && !(info->shared))
2676     return;
2677
2678   generate_edata (abfd, info);
2679   build_filler_bfd (1);
2680 }
2681
2682 void
2683 pe_exe_build_sections (abfd, info)
2684      bfd *abfd;
2685      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2686 {
2687   pe_dll_id_target (bfd_get_target (abfd));
2688   build_filler_bfd (0);
2689 }
2690
2691 void
2692 pe_dll_fill_sections (abfd, info)
2693      bfd *abfd;
2694      struct bfd_link_info *info;
2695 {
2696   pe_dll_id_target (bfd_get_target (abfd));
2697   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2698
2699   generate_reloc (abfd, info);
2700   if (reloc_sz > 0)
2701     {
2702       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2703
2704       /* Resize the sections.  */
2705       lang_size_sections (stat_ptr->head, abs_output_section,
2706                           &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
2707
2708       /* Redo special stuff.  */
2709       ldemul_after_allocation ();
2710
2711       /* Do the assignments again.  */
2712       lang_do_assignments (stat_ptr->head,
2713                            abs_output_section,
2714                            (fill_type *) 0, (bfd_vma) 0);
2715     }
2716
2717   fill_edata (abfd, info);
2718
2719   if (info->shared)
2720     pe_data (abfd)->dll = 1;
2721
2722   edata_s->contents = edata_d;
2723   reloc_s->contents = reloc_d;
2724 }
2725
2726 void
2727 pe_exe_fill_sections (abfd, info)
2728      bfd *abfd;
2729      struct bfd_link_info *info;
2730 {
2731   pe_dll_id_target (bfd_get_target (abfd));
2732   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
2733
2734   generate_reloc (abfd, info);
2735   if (reloc_sz > 0)
2736     {
2737       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
2738
2739       /* Resize the sections.  */
2740       lang_size_sections (stat_ptr->head, abs_output_section,
2741                           &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
2742
2743       /* Redo special stuff.  */
2744       ldemul_after_allocation ();
2745
2746       /* Do the assignments again.  */
2747       lang_do_assignments (stat_ptr->head,
2748                            abs_output_section,
2749                            (fill_type *) 0, (bfd_vma) 0);
2750     }
2751   reloc_s->contents = reloc_d;
2752 }