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