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