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