ld/pe-dll.c

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