ld/pe-dll.c

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