contrib/binutils/ld/pe-dll.c

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