ld/pe-dll.c

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