ld/pe-dll.c

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