ld/pe-dll.c

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