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