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