ld/pe-dll.c

   1 /* Routines to help build PEI-format DLLs (Win32 etc)
   2    Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
   3    Written by DJ Delorie <dj@cygnus.com>
   4
   5    This file is part of GLD, the Gnu Linker.
   6
   7    GLD is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GLD is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GLD; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "bfdlink.h"
  25 #include "libiberty.h"
  26
  27 #include <time.h>
  28 #include <ctype.h>
  29
  30 #include "ld.h"
  31 #include "ldexp.h"
  32 #include "ldlang.h"
  33 #include "ldwrite.h"
  34 #include "ldmisc.h"
  35 #include "ldgram.h"
  36 #include "ldmain.h"
  37 #include "ldfile.h"
  38 #include "ldemul.h"
  39 #include "coff/internal.h"
  40 #include "../bfd/libcoff.h"
  41 #include "deffile.h"
  42 #include "pe-dll.h"
  43
  44 /************************************************************************
  45
  46  This file turns a regular Windows PE image into a DLL.  Because of
  47  the complexity of this operation, it has been broken down into a
  48  number of separate modules which are all called by the main function
  49  at the end of this file.  This function is not re-entrant and is
  50  normally only called once, so static variables are used to reduce
  51  the number of parameters and return values required.
  52
  53  See also: ld/emultempl/pe.em
  54
  55  ************************************************************************/
  56
  57 /* for emultempl/pe.em */
  58
  59 def_file *pe_def_file = 0;
  60 int pe_dll_export_everything = 0;
  61 int pe_dll_do_default_excludes = 1;
  62 int pe_dll_kill_ats = 0;
  63 int pe_dll_stdcall_aliases = 0;
  64 int pe_dll_warn_dup_exports = 0;
  65 int pe_dll_compat_implib = 0;
  66
  67 /************************************************************************
  68
  69  static variables and types
  70
  71  ************************************************************************/
  72
  73 static bfd_vma image_base;
  74
  75 static bfd *filler_bfd;
  76 static struct sec *edata_s, *reloc_s;
  77 static unsigned char *edata_d, *reloc_d;
  78 static size_t edata_sz, reloc_sz;
  79
  80 typedef struct {
  81   char *target_name;
  82   char *object_target;
  83   unsigned int imagebase_reloc;
  84   int pe_arch;
  85   int bfd_arch;
  86   int underscored;
  87 } pe_details_type;
  88
  89 #define PE_ARCH_i386    1
  90 #define PE_ARCH_sh      2
  91 #define PE_ARCH_mips    3
  92 #define PE_ARCH_arm     4
  93
  94 static pe_details_type pe_detail_list[] = {
  95   {
  96     "pei-i386",
  97     "pe-i386",
  98     7 /* R_IMAGEBASE */,
  99     PE_ARCH_i386,
 100     bfd_arch_i386,
 101     1
 102   },
 103   {
 104     "pei-shl",
 105     "pe-shl",
 106     16 /* R_SH_IMAGEBASE */,
 107     PE_ARCH_sh,
 108     bfd_arch_sh,
 109     1
 110   },
 111   {
 112     "pei-mips",
 113     "pe-mips",
 114     34 /* MIPS_R_RVA */,
 115     PE_ARCH_mips,
 116     bfd_arch_mips,
 117     0
 118   },
 119   {
 120     "pei-arm-little",
 121     "pe-arm-little",
 122     11 /* ARM_RVA32 */,
 123     PE_ARCH_arm,
 124     bfd_arch_arm,
 125     0
 126   },
 127   { NULL, NULL, 0, 0, 0, 0 }
 128 };
 129
 130 static pe_details_type *pe_details;
 131
 132 #define U(str) (pe_details->underscored ? "_" str : str)
 133
 134 void
 135 pe_dll_id_target (target)
 136      const char *target;
 137 {
 138   int i;
 139   for (i = 0; pe_detail_list[i].target_name; i++)
 140     if (strcmp (pe_detail_list[i].target_name, target) == 0
 141         || strcmp (pe_detail_list[i].object_target, target) == 0)
 142       {
 143         pe_details = pe_detail_list + i;
 144         return;
 145       }
 146   einfo (_("%XUnsupported PEI architecture: %s\n"), target);
 147   exit (1);
 148 }
 149
 150 /************************************************************************
 151
 152  Helper functions for qsort.  Relocs must be sorted so that we can write
 153  them out by pages.
 154
 155  ************************************************************************/
 156
 157 typedef struct {
 158   bfd_vma vma;
 159   char type;
 160   short extra;
 161 } reloc_data_type;
 162
 163 static int
 164 reloc_sort (va, vb)
 165      const void *va, *vb;
 166 {
 167   bfd_vma a = ((reloc_data_type *) va)->vma;
 168   bfd_vma b = ((reloc_data_type *) vb)->vma;
 169   return (a > b) ? 1 : ((a < b) ? -1 : 0);
 170 }
 171
 172 static int
 173 pe_export_sort (va, vb)
 174      const void *va, *vb;
 175 {
 176   def_file_export *a = (def_file_export *) va;
 177   def_file_export *b = (def_file_export *) vb;
 178   return strcmp (a->name, b->name);
 179 }
 180
 181 /************************************************************************
 182
 183  Read and process the .DEF file
 184
 185  ************************************************************************/
 186
 187 /* These correspond to the entries in pe_def_file->exports[].  I use
 188    exported_symbol_sections[i] to tag whether or not the symbol was
 189    defined, since we can't export symbols we don't have.  */
 190
 191 static bfd_vma *exported_symbol_offsets;
 192 static struct sec **exported_symbol_sections;
 193
 194 static int export_table_size;
 195 static int count_exported;
 196 static int count_exported_byname;
 197 static int count_with_ordinals;
 198 static const char *dll_name;
 199 static int min_ordinal, max_ordinal;
 200 static int *exported_symbols;
 201
 202 typedef struct exclude_list_struct {
 203   char *string;
 204   struct exclude_list_struct *next;
 205 } exclude_list_struct;
 206
 207 static struct exclude_list_struct *excludes = 0;
 208
 209 void
 210 pe_dll_add_excludes (new_excludes)
 211      const char *new_excludes;
 212 {
 213   char *local_copy;
 214   char *exclude_string;
 215
 216   local_copy = xstrdup (new_excludes);
 217
 218   exclude_string = strtok (local_copy, ",:");
 219   for (; exclude_string; exclude_string = strtok (NULL, ",:"))
 220     {
 221       struct exclude_list_struct *new_exclude;
 222
 223       new_exclude = ((struct exclude_list_struct *)
 224                      xmalloc (sizeof (struct exclude_list_struct)));
 225       new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 1);
 226       strcpy (new_exclude->string, exclude_string);
 227       new_exclude->next = excludes;
 228       excludes = new_exclude;
 229     }
 230
 231   free (local_copy);
 232 }
 233
 234 static int
 235 auto_export (d, n)
 236      def_file *d;
 237      const char *n;
 238 {
 239   int i;
 240   struct exclude_list_struct *ex;
 241   for (i = 0; i < d->num_exports; i++)
 242     if (strcmp (d->exports[i].name, n) == 0)
 243       return 0;
 244   if (pe_dll_do_default_excludes)
 245     {
 246       if (strcmp (n, "DllMain@12") == 0)
 247         return 0;
 248       if (strcmp (n, "DllEntryPoint@0") == 0)
 249         return 0;
 250       if (strcmp (n, "impure_ptr") == 0)
 251         return 0;
 252     }
 253   for (ex = excludes; ex; ex = ex->next)
 254     if (strcmp (n, ex->string) == 0)
 255       return 0;
 256   return 1;
 257 }
 258
 259 static void
 260 process_def_file (abfd, info)
 261      bfd *abfd ATTRIBUTE_UNUSED;
 262      struct bfd_link_info *info;
 263 {
 264   int i, j;
 265   struct bfd_link_hash_entry *blhe;
 266   bfd *b;
 267   struct sec *s;
 268   def_file_export *e = 0;
 269
 270   if (!pe_def_file)
 271     pe_def_file = def_file_empty ();
 272
 273   /* First, run around to all the objects looking for the .drectve
 274      sections, and push those into the def file too.  */
 275
 276   for (b = info->input_bfds; b; b = b->link_next)
 277     {
 278       s = bfd_get_section_by_name (b, ".drectve");
 279       if (s)
 280         {
 281           int size = bfd_get_section_size_before_reloc (s);
 282           char *buf = xmalloc (size);
 283           bfd_get_section_contents (b, s, buf, 0, size);
 284           def_file_add_directive (pe_def_file, buf, size);
 285           free (buf);
 286         }
 287     }
 288
 289   /* Now, maybe export everything else the default way.  */
 290
 291   if (pe_dll_export_everything || pe_def_file->num_exports == 0)
 292     {
 293       for (b = info->input_bfds; b; b = b->link_next)
 294         {
 295           asymbol **symbols;
 296           int nsyms, symsize;
 297
 298           symsize = bfd_get_symtab_upper_bound (b);
 299           symbols = (asymbol **) xmalloc (symsize);
 300           nsyms = bfd_canonicalize_symtab (b, symbols);
 301
 302           for (j = 0; j < nsyms; j++)
 303             {
 304               /* We should export symbols which are either global or not
 305                  anything at all.  (.bss data is the latter)  */
 306               if ((symbols[j]->flags & BSF_GLOBAL)
 307                   || (symbols[j]->flags == BSF_NO_FLAGS))
 308                 {
 309                   const char *sn = symbols[j]->name;
 310                   if (*sn == '_')
 311                     sn++;
 312                   if (auto_export (pe_def_file, sn))
 313                     def_file_add_export (pe_def_file, sn, 0, -1);
 314                 }
 315             }
 316         }
 317     }
 318
 319 #undef NE
 320 #define NE pe_def_file->num_exports
 321
 322   /* Canonicalize the export list.  */
 323
 324   if (pe_dll_kill_ats)
 325     {
 326       for (i = 0; i < NE; i++)
 327         {
 328           if (strchr (pe_def_file->exports[i].name, '@'))
 329             {
 330               /* This will preserve internal_name, which may have been
 331                  pointing to the same memory as name, or might not
 332                  have.  */
 333               char *tmp = xstrdup (pe_def_file->exports[i].name);
 334               *(strchr (tmp, '@')) = 0;
 335               pe_def_file->exports[i].name = tmp;
 336             }
 337         }
 338     }
 339
 340   if (pe_dll_stdcall_aliases)
 341     {
 342       for (i = 0; i < NE; i++)
 343         {
 344           if (strchr (pe_def_file->exports[i].name, '@'))
 345             {
 346               char *tmp = xstrdup (pe_def_file->exports[i].name);
 347               *(strchr (tmp, '@')) = 0;
 348               if (auto_export (pe_def_file, tmp))
 349                 def_file_add_export (pe_def_file, tmp,
 350                                      pe_def_file->exports[i].internal_name, -1);
 351               else
 352                 free (tmp);
 353             }
 354         }
 355     }
 356
 357   /* Convenience, but watch out for it changing.  */
 358   e = pe_def_file->exports;
 359
 360   exported_symbol_offsets = (bfd_vma *) xmalloc (NE * sizeof (bfd_vma));
 361   exported_symbol_sections = (struct sec **) xmalloc (NE * sizeof (struct sec *));
 362
 363   memset (exported_symbol_sections, 0, NE * sizeof (struct sec *));
 364   max_ordinal = 0;
 365   min_ordinal = 65536;
 366   count_exported = 0;
 367   count_exported_byname = 0;
 368   count_with_ordinals = 0;
 369
 370   qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]), pe_export_sort);
 371   for (i = 0, j = 0; i < NE; i++)
 372     {
 373       if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
 374         {
 375           /* This is a duplicate.  */
 376           if (e[j - 1].ordinal != -1
 377               && e[i].ordinal != -1
 378               && e[j - 1].ordinal != e[i].ordinal)
 379             {
 380               if (pe_dll_warn_dup_exports)
 381                 /* xgettext:c-format */
 382                 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
 383                        e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
 384             }
 385           else
 386             {
 387               if (pe_dll_warn_dup_exports)
 388                 /* xgettext:c-format */
 389                 einfo (_("Warning, duplicate EXPORT: %s\n"),
 390                        e[j - 1].name);
 391             }
 392           if (e[i].ordinal != -1)
 393             e[j - 1].ordinal = e[i].ordinal;
 394           e[j - 1].flag_private |= e[i].flag_private;
 395           e[j - 1].flag_constant |= e[i].flag_constant;
 396           e[j - 1].flag_noname |= e[i].flag_noname;
 397           e[j - 1].flag_data |= e[i].flag_data;
 398         }
 399       else
 400         {
 401           if (i != j)
 402             e[j] = e[i];
 403           j++;
 404         }
 405     }
 406   pe_def_file->num_exports = j; /* == NE */
 407
 408   for (i = 0; i < NE; i++)
 409     {
 410       char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
 411       if (pe_details->underscored)
 412         {
 413           *name = '_';
 414           strcpy (name + 1, pe_def_file->exports[i].internal_name);
 415         }
 416       else
 417         strcpy (name, pe_def_file->exports[i].internal_name);
 418
 419       blhe = bfd_link_hash_lookup (info->hash,
 420                                    name,
 421                                    false, false, true);
 422
 423       if (blhe
 424           && (blhe->type == bfd_link_hash_defined
 425               || (blhe->type == bfd_link_hash_common)))
 426         {
 427           count_exported++;
 428           if (!pe_def_file->exports[i].flag_noname)
 429             count_exported_byname++;
 430
 431           /* Only fill in the sections. The actual offsets are computed
 432              in fill_exported_offsets() after common symbols are laid
 433              out.  */
 434           if (blhe->type == bfd_link_hash_defined)
 435             exported_symbol_sections[i] = blhe->u.def.section;
 436           else
 437             exported_symbol_sections[i] = blhe->u.c.p->section;
 438
 439           if (pe_def_file->exports[i].ordinal != -1)
 440             {
 441               if (max_ordinal < pe_def_file->exports[i].ordinal)
 442                 max_ordinal = pe_def_file->exports[i].ordinal;
 443               if (min_ordinal > pe_def_file->exports[i].ordinal)
 444                 min_ordinal = pe_def_file->exports[i].ordinal;
 445               count_with_ordinals++;
 446             }
 447         }
 448       else if (blhe && blhe->type == bfd_link_hash_undefined)
 449         {
 450           /* xgettext:c-format */
 451           einfo (_("%XCannot export %s: symbol not defined\n"),
 452                  pe_def_file->exports[i].internal_name);
 453         }
 454       else if (blhe)
 455         {
 456           /* xgettext:c-format */
 457           einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
 458                  pe_def_file->exports[i].internal_name,
 459                  blhe->type, bfd_link_hash_defined);
 460         }
 461       else
 462         {
 463           /* xgettext:c-format */
 464           einfo (_("%XCannot export %s: symbol not found\n"),
 465                  pe_def_file->exports[i].internal_name);
 466         }
 467       free (name);
 468     }
 469 }
 470
 471 /************************************************************************
 472
 473  Build the bfd that will contain .edata and .reloc sections
 474
 475  ************************************************************************/
 476
 477 static void
 478 build_filler_bfd (include_edata)
 479      int include_edata;
 480 {
 481   lang_input_statement_type *filler_file;
 482   filler_file = lang_add_input_file ("dll stuff",
 483                                      lang_input_file_is_fake_enum,
 484                                      NULL);
 485   filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
 486   if (filler_bfd == NULL
 487       || !bfd_set_arch_mach (filler_bfd,
 488                              bfd_get_arch (output_bfd),
 489                              bfd_get_mach (output_bfd)))
 490     {
 491       einfo ("%X%P: can not create BFD %E\n");
 492       return;
 493     }
 494
 495   if (include_edata)
 496     {
 497       edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
 498       if (edata_s == NULL
 499           || !bfd_set_section_flags (filler_bfd, edata_s,
 500                                      (SEC_HAS_CONTENTS
 501                                       | SEC_ALLOC
 502                                       | SEC_LOAD
 503                                       | SEC_KEEP
 504                                       | SEC_IN_MEMORY)))
 505         {
 506           einfo ("%X%P: can not create .edata section: %E\n");
 507           return;
 508         }
 509       bfd_set_section_size (filler_bfd, edata_s, edata_sz);
 510     }
 511
 512   reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
 513   if (reloc_s == NULL
 514       || !bfd_set_section_flags (filler_bfd, reloc_s,
 515                                  (SEC_HAS_CONTENTS
 516                                   | SEC_ALLOC
 517                                   | SEC_LOAD
 518                                   | SEC_KEEP
 519                                   | SEC_IN_MEMORY)))
 520     {
 521       einfo ("%X%P: can not create .reloc section: %E\n");
 522       return;
 523     }
 524   bfd_set_section_size (filler_bfd, reloc_s, 0);
 525
 526   ldlang_add_file (filler_file);
 527 }
 528
 529 /************************************************************************
 530
 531  Gather all the exported symbols and build the .edata section
 532
 533  ************************************************************************/
 534
 535 static void
 536 generate_edata (abfd, info)
 537      bfd *abfd;
 538      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 539 {
 540   int i, next_ordinal;
 541   int name_table_size = 0;
 542   const char *dlnp;
 543
 544   /* First, we need to know how many exported symbols there are,
 545      and what the range of ordinals is.  */
 546
 547   if (pe_def_file->name)
 548     {
 549       dll_name = pe_def_file->name;
 550     }
 551   else
 552     {
 553       dll_name = abfd->filename;
 554       for (dlnp = dll_name; *dlnp; dlnp++)
 555         {
 556           if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
 557             dll_name = dlnp + 1;
 558         }
 559     }
 560
 561   if (count_with_ordinals && max_ordinal > count_exported)
 562     {
 563       if (min_ordinal > max_ordinal - count_exported + 1)
 564         min_ordinal = max_ordinal - count_exported + 1;
 565     }
 566   else
 567     {
 568       min_ordinal = 1;
 569       max_ordinal = count_exported;
 570     }
 571   export_table_size = max_ordinal - min_ordinal + 1;
 572
 573   exported_symbols = (int *) xmalloc (export_table_size * sizeof (int));
 574   for (i = 0; i < export_table_size; i++)
 575     exported_symbols[i] = -1;
 576
 577   /* Now we need to assign ordinals to those that don't have them.  */
 578   for (i = 0; i < NE; i++)
 579     {
 580       if (exported_symbol_sections[i])
 581         {
 582           if (pe_def_file->exports[i].ordinal != -1)
 583             {
 584               int ei = pe_def_file->exports[i].ordinal - min_ordinal;
 585               int pi = exported_symbols[ei];
 586               if (pi != -1)
 587                 {
 588                   /* xgettext:c-format */
 589                   einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
 590                          pe_def_file->exports[i].ordinal,
 591                          pe_def_file->exports[i].name,
 592                          pe_def_file->exports[pi].name);
 593                 }
 594               exported_symbols[ei] = i;
 595             }
 596           name_table_size += strlen (pe_def_file->exports[i].name) + 1;
 597         }
 598     }
 599
 600   next_ordinal = min_ordinal;
 601   for (i = 0; i < NE; i++)
 602     if (exported_symbol_sections[i])
 603       if (pe_def_file->exports[i].ordinal == -1)
 604         {
 605           while (exported_symbols[next_ordinal - min_ordinal] != -1)
 606             next_ordinal++;
 607           exported_symbols[next_ordinal - min_ordinal] = i;
 608           pe_def_file->exports[i].ordinal = next_ordinal;
 609         }
 610
 611   /* OK, now we can allocate some memory.  */
 612
 613   edata_sz = (40                /* directory */
 614               + 4 * export_table_size   /* addresses */
 615               + 4 * count_exported_byname       /* name ptrs */
 616               + 2 * count_exported_byname       /* ordinals */
 617               + name_table_size + strlen (dll_name) + 1);
 618 }
 619
 620 /* Fill the exported symbol offsets. The preliminary work has already
 621    been done in process_def_file().  */
 622
 623 static void
 624 fill_exported_offsets (abfd, info)
 625      bfd *abfd ATTRIBUTE_UNUSED;
 626      struct bfd_link_info *info;
 627 {
 628   int i;
 629   struct bfd_link_hash_entry *blhe;
 630
 631   for (i = 0; i < pe_def_file->num_exports; i++)
 632     {
 633       char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
 634       if (pe_details->underscored)
 635         {
 636           *name = '_';
 637           strcpy (name + 1, pe_def_file->exports[i].internal_name);
 638         }
 639       else
 640         strcpy (name, pe_def_file->exports[i].internal_name);
 641
 642       blhe = bfd_link_hash_lookup (info->hash,
 643                                    name,
 644                                    false, false, true);
 645
 646       if (blhe && (blhe->type == bfd_link_hash_defined))
 647         {
 648           exported_symbol_offsets[i] = blhe->u.def.value;
 649         }
 650       free (name);
 651     }
 652 }
 653
 654 static void
 655 fill_edata (abfd, info)
 656      bfd *abfd;
 657      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 658 {
 659   int i, hint;
 660   unsigned char *edirectory;
 661   unsigned long *eaddresses;
 662   unsigned long *enameptrs;
 663   unsigned short *eordinals;
 664   unsigned char *enamestr;
 665   time_t now;
 666
 667   time (&now);
 668
 669   edata_d = (unsigned char *) xmalloc (edata_sz);
 670
 671   /* Note use of array pointer math here.  */
 672   edirectory = edata_d;
 673   eaddresses = (unsigned long *) (edata_d + 40);
 674   enameptrs = eaddresses + export_table_size;
 675   eordinals = (unsigned short *) (enameptrs + count_exported_byname);
 676   enamestr = (char *) (eordinals + count_exported_byname);
 677
 678 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
 679
 680   memset (edata_d, 0, edata_sz);
 681   bfd_put_32 (abfd, now, edata_d + 4);
 682   if (pe_def_file->version_major != -1)
 683     {
 684       bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
 685       bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
 686     }
 687   bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
 688   strcpy (enamestr, dll_name);
 689   enamestr += strlen (enamestr) + 1;
 690   bfd_put_32 (abfd, min_ordinal, edata_d + 16);
 691   bfd_put_32 (abfd, export_table_size, edata_d + 20);
 692   bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
 693   bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
 694   bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
 695   bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
 696
 697   fill_exported_offsets (abfd, info);
 698
 699   /* Ok, now for the filling in part.  */
 700   hint = 0;
 701   for (i = 0; i < export_table_size; i++)
 702     {
 703       int s = exported_symbols[i];
 704       if (s != -1)
 705         {
 706           struct sec *ssec = exported_symbol_sections[s];
 707           unsigned long srva = (exported_symbol_offsets[s]
 708                                 + ssec->output_section->vma
 709                                 + ssec->output_offset);
 710           int ord = pe_def_file->exports[s].ordinal;
 711
 712           bfd_put_32 (abfd, srva - image_base,
 713                       (void *) (eaddresses + ord - min_ordinal));
 714           if (!pe_def_file->exports[s].flag_noname)
 715             {
 716               char *ename = pe_def_file->exports[s].name;
 717               bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs);
 718               enameptrs++;
 719               strcpy (enamestr, ename);
 720               enamestr += strlen (enamestr) + 1;
 721               bfd_put_16 (abfd, ord - min_ordinal, (void *) eordinals);
 722               eordinals++;
 723               pe_def_file->exports[s].hint = hint++;
 724             }
 725         }
 726     }
 727 }
 728
 729 /************************************************************************
 730
 731  Gather all the relocations and build the .reloc section
 732
 733  ************************************************************************/
 734
 735 static void
 736 generate_reloc (abfd, info)
 737      bfd *abfd;
 738      struct bfd_link_info *info;
 739 {
 740
 741   /* For .reloc stuff.  */
 742   reloc_data_type *reloc_data;
 743   int total_relocs = 0;
 744   int i;
 745   unsigned long sec_page = (unsigned long) (-1);
 746   unsigned long page_ptr, page_count;
 747   int bi;
 748   bfd *b;
 749   struct sec *s;
 750
 751   total_relocs = 0;
 752   for (b = info->input_bfds; b; b = b->link_next)
 753     for (s = b->sections; s; s = s->next)
 754       total_relocs += s->reloc_count;
 755
 756   reloc_data = (reloc_data_type *) xmalloc (total_relocs * sizeof (reloc_data_type));
 757
 758   total_relocs = 0;
 759   bi = 0;
 760   for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
 761     {
 762       arelent **relocs;
 763       int relsize, nrelocs, i;
 764
 765       for (s = b->sections; s; s = s->next)
 766         {
 767           unsigned long sec_vma = s->output_section->vma + s->output_offset;
 768           asymbol **symbols;
 769           int nsyms, symsize;
 770
 771           /* If it's not loaded, we don't need to relocate it this way.  */
 772           if (!(s->output_section->flags & SEC_LOAD))
 773             continue;
 774
 775           /* I don't know why there would be a reloc for these, but I've
 776              seen it happen - DJ  */
 777           if (s->output_section == &bfd_abs_section)
 778             continue;
 779
 780           if (s->output_section->vma == 0)
 781             {
 782               /* Huh?  Shouldn't happen, but punt if it does.  */
 783               einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
 784                      s->output_section->name, s->output_section->index,
 785                      s->output_section->flags);
 786               continue;
 787             }
 788
 789           symsize = bfd_get_symtab_upper_bound (b);
 790           symbols = (asymbol **) xmalloc (symsize);
 791           nsyms = bfd_canonicalize_symtab (b, symbols);
 792
 793           relsize = bfd_get_reloc_upper_bound (b, s);
 794           relocs = (arelent **) xmalloc ((size_t) relsize);
 795           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
 796
 797           for (i = 0; i < nrelocs; i++)
 798             {
 799               if (!relocs[i]->howto->pc_relative
 800                   && relocs[i]->howto->type != pe_details->imagebase_reloc)
 801                 {
 802                   bfd_vma sym_vma;
 803                   struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
 804                   sym_vma = (relocs[i]->addend
 805                              + sym->value
 806                              + sym->section->vma
 807                              + sym->section->output_offset
 808                              + sym->section->output_section->vma);
 809                   reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
 810
 811 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
 812
 813                   switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
 814                                          relocs[i]->howto->rightshift)
 815                     {
 816                     case BITS_AND_SHIFT (32, 0):
 817                       reloc_data[total_relocs].type = 3;
 818                       total_relocs++;
 819                       break;
 820                     case BITS_AND_SHIFT (16, 0):
 821                       reloc_data[total_relocs].type = 2;
 822                       total_relocs++;
 823                       break;
 824                     case BITS_AND_SHIFT (16, 16):
 825                       reloc_data[total_relocs].type = 4;
 826                       /* FIXME: we can't know the symbol's right value
 827                          yet, but we probably can safely assume that
 828                          CE will relocate us in 64k blocks, so leaving
 829                          it zero is safe.  */
 830                       reloc_data[total_relocs].extra = 0;
 831                       total_relocs++;
 832                       break;
 833                     case BITS_AND_SHIFT (26, 2):
 834                       reloc_data[total_relocs].type = 5;
 835                       total_relocs++;
 836                       break;
 837                     default:
 838                       /* xgettext:c-format */
 839                       einfo (_("%XError: %d-bit reloc in dll\n"),
 840                              relocs[i]->howto->bitsize);
 841                       break;
 842                     }
 843                 }
 844             }
 845           free (relocs);
 846           /* Warning: the allocated symbols are remembered in BFD and
 847              reused later, so don't free them!  */
 848 #if 0
 849           free (symbol);
 850 #endif
 851         }
 852     }
 853
 854   /* At this point, we have total_relocs relocation addresses in
 855      reloc_addresses, which are all suitable for the .reloc section.
 856      We must now create the new sections.  */
 857
 858   qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
 859
 860   for (i = 0; i < total_relocs; i++)
 861     {
 862       unsigned long this_page = (reloc_data[i].vma >> 12);
 863
 864       if (this_page != sec_page)
 865         {
 866           reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align */
 867           reloc_sz += 8;
 868           sec_page = this_page;
 869         }
 870
 871       reloc_sz += 2;
 872
 873       if (reloc_data[i].type == 4)
 874         reloc_sz += 2;
 875     }
 876   reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align */
 877
 878   reloc_d = (unsigned char *) xmalloc (reloc_sz);
 879
 880   sec_page = (unsigned long) (-1);
 881   reloc_sz = 0;
 882   page_ptr = (unsigned long) (-1);
 883   page_count = 0;
 884   for (i = 0; i < total_relocs; i++)
 885     {
 886       unsigned long rva = reloc_data[i].vma - image_base;
 887       unsigned long this_page = (rva & ~0xfff);
 888       if (this_page != sec_page)
 889         {
 890           while (reloc_sz & 3)
 891             reloc_d[reloc_sz++] = 0;
 892           if (page_ptr != (unsigned long) (-1))
 893             bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
 894           bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
 895           page_ptr = reloc_sz;
 896           reloc_sz += 8;
 897           sec_page = this_page;
 898           page_count = 0;
 899         }
 900       bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
 901                   reloc_d + reloc_sz);
 902       reloc_sz += 2;
 903       if (reloc_data[i].type == 4)
 904         {
 905           bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
 906           reloc_sz += 2;
 907         }
 908       page_count++;
 909     }
 910   while (reloc_sz & 3)
 911     reloc_d[reloc_sz++] = 0;
 912   if (page_ptr != (unsigned long) (-1))
 913     bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
 914   while (reloc_sz < reloc_s->_raw_size)
 915     reloc_d[reloc_sz++] = 0;
 916 }
 917
 918 /************************************************************************
 919
 920  Given the exiting def_file structure, print out a .DEF file that
 921  corresponds to it.
 922
 923  ************************************************************************/
 924
 925 static void
 926 quoteput (s, f, needs_quotes)
 927      char *s;
 928      FILE *f;
 929      int needs_quotes;
 930 {
 931   char *cp;
 932   for (cp = s; *cp; cp++)
 933     if (*cp == '\''
 934         || *cp == '"'
 935         || *cp == '\\'
 936         || isspace ((unsigned char) *cp)
 937         || *cp == ','
 938         || *cp == ';')
 939       needs_quotes = 1;
 940   if (needs_quotes)
 941     {
 942       putc ('"', f);
 943       while (*s)
 944         {
 945           if (*s == '"' || *s == '\\')
 946             putc ('\\', f);
 947           putc (*s, f);
 948           s++;
 949         }
 950       putc ('"', f);
 951     }
 952   else
 953     fputs (s, f);
 954 }
 955
 956 void
 957 pe_dll_generate_def_file (pe_out_def_filename)
 958      const char *pe_out_def_filename;
 959 {
 960   int i;
 961   FILE *out = fopen (pe_out_def_filename, "w");
 962   if (out == NULL)
 963     {
 964       /* xgettext:c-format */
 965       einfo (_("%s: Can't open output def file %s\n"),
 966              program_name, pe_out_def_filename);
 967     }
 968
 969   if (pe_def_file)
 970     {
 971       if (pe_def_file->name)
 972         {
 973           if (pe_def_file->is_dll)
 974             fprintf (out, "LIBRARY ");
 975           else
 976             fprintf (out, "NAME ");
 977           quoteput (pe_def_file->name, out, 1);
 978           if (pe_data (output_bfd)->pe_opthdr.ImageBase)
 979             fprintf (out, " BASE=0x%lx",
 980                      (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
 981           fprintf (out, "\n");
 982         }
 983
 984       if (pe_def_file->description)
 985         {
 986           fprintf (out, "DESCRIPTION ");
 987           quoteput (pe_def_file->description, out, 1);
 988           fprintf (out, "\n");
 989         }
 990
 991       if (pe_def_file->version_minor != -1)
 992         fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
 993                  pe_def_file->version_minor);
 994       else if (pe_def_file->version_major != -1)
 995         fprintf (out, "VERSION %d\n", pe_def_file->version_major);
 996
 997       if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
 998         fprintf (out, "\n");
 999
1000       if (pe_def_file->stack_commit != -1)
1001         fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1002                  pe_def_file->stack_reserve, pe_def_file->stack_commit);
1003       else if (pe_def_file->stack_reserve != -1)
1004         fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1005       if (pe_def_file->heap_commit != -1)
1006         fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1007                  pe_def_file->heap_reserve, pe_def_file->heap_commit);
1008       else if (pe_def_file->heap_reserve != -1)
1009         fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1010
1011       if (pe_def_file->num_section_defs > 0)
1012         {
1013           fprintf (out, "\nSECTIONS\n\n");
1014           for (i = 0; i < pe_def_file->num_section_defs; i++)
1015             {
1016               fprintf (out, "    ");
1017               quoteput (pe_def_file->section_defs[i].name, out, 0);
1018               if (pe_def_file->section_defs[i].class)
1019                 {
1020                   fprintf (out, " CLASS ");
1021                   quoteput (pe_def_file->section_defs[i].class, out, 0);
1022                 }
1023               if (pe_def_file->section_defs[i].flag_read)
1024                 fprintf (out, " READ");
1025               if (pe_def_file->section_defs[i].flag_write)
1026                 fprintf (out, " WRITE");
1027               if (pe_def_file->section_defs[i].flag_execute)
1028                 fprintf (out, " EXECUTE");
1029               if (pe_def_file->section_defs[i].flag_shared)
1030                 fprintf (out, " SHARED");
1031               fprintf (out, "\n");
1032             }
1033         }
1034
1035       if (pe_def_file->num_exports > 0)
1036         {
1037           fprintf (out, "\nEXPORTS\n\n");
1038           for (i = 0; i < pe_def_file->num_exports; i++)
1039             {
1040               def_file_export *e = pe_def_file->exports + i;
1041               fprintf (out, "    ");
1042               quoteput (e->name, out, 0);
1043               if (e->internal_name && strcmp (e->internal_name, e->name))
1044                 {
1045                   fprintf (out, " = ");
1046                   quoteput (e->internal_name, out, 0);
1047                 }
1048               if (e->ordinal != -1)
1049                 fprintf (out, " @%d", e->ordinal);
1050               if (e->flag_private)
1051                 fprintf (out, " PRIVATE");
1052               if (e->flag_constant)
1053                 fprintf (out, " CONSTANT");
1054               if (e->flag_noname)
1055                 fprintf (out, " NONAME");
1056               if (e->flag_data)
1057                 fprintf (out, " DATA");
1058
1059               fprintf (out, "\n");
1060             }
1061         }
1062
1063       if (pe_def_file->num_imports > 0)
1064         {
1065           fprintf (out, "\nIMPORTS\n\n");
1066           for (i = 0; i < pe_def_file->num_imports; i++)
1067             {
1068               def_file_import *im = pe_def_file->imports + i;
1069               fprintf (out, "    ");
1070               if (im->internal_name
1071                   && (!im->name || strcmp (im->internal_name, im->name)))
1072                 {
1073                   quoteput (im->internal_name, out, 0);
1074                   fprintf (out, " = ");
1075                 }
1076               quoteput (im->module->name, out, 0);
1077               fprintf (out, ".");
1078               if (im->name)
1079                 quoteput (im->name, out, 0);
1080               else
1081                 fprintf (out, "%d", im->ordinal);
1082               fprintf (out, "\n");
1083             }
1084         }
1085     }
1086   else
1087     fprintf (out, _("; no contents available\n"));
1088
1089   if (fclose (out) == EOF)
1090     {
1091       /* xgettext:c-format */
1092       einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1093     }
1094 }
1095
1096 /************************************************************************
1097
1098  Generate the import library
1099
1100  ************************************************************************/
1101
1102 static asymbol **symtab;
1103 static int symptr;
1104 static int tmp_seq;
1105 static const char *dll_filename;
1106 static char *dll_symname;
1107
1108 #define UNDSEC (asection *) &bfd_und_section
1109
1110 static asection *
1111 quick_section (abfd, name, flags, align)
1112      bfd *abfd;
1113      const char *name;
1114      int flags;
1115      int align;
1116 {
1117   asection *sec;
1118   asymbol *sym;
1119
1120   sec = bfd_make_section_old_way (abfd, name);
1121   bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1122   bfd_set_section_alignment (abfd, sec, align);
1123   /* Remember to undo this before trying to link internally!  */
1124   sec->output_section = sec;
1125
1126   sym = bfd_make_empty_symbol (abfd);
1127   symtab[symptr++] = sym;
1128   sym->name = sec->name;
1129   sym->section = sec;
1130   sym->flags = BSF_LOCAL;
1131   sym->value = 0;
1132
1133   return sec;
1134 }
1135
1136 static void
1137 quick_symbol (abfd, n1, n2, n3, sec, flags, addr)
1138      bfd *abfd;
1139      char *n1;
1140      char *n2;
1141      char *n3;
1142      asection *sec;
1143      int flags;
1144      int addr;
1145 {
1146   asymbol *sym;
1147   char *name = (char *) xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1148   strcpy (name, n1);
1149   strcat (name, n2);
1150   strcat (name, n3);
1151   sym = bfd_make_empty_symbol (abfd);
1152   sym->name = name;
1153   sym->section = sec;
1154   sym->flags = flags;
1155   sym->value = addr;
1156   symtab[symptr++] = sym;
1157 }
1158
1159 static arelent *reltab = 0;
1160 static int relcount = 0, relsize = 0;
1161
1162 static void
1163 quick_reloc (abfd, address, which_howto, symidx)
1164      bfd *abfd;
1165      int address;
1166      int which_howto;
1167      int symidx;
1168 {
1169   if (relcount >= (relsize - 1))
1170     {
1171       relsize += 10;
1172       if (reltab)
1173         reltab = (arelent *) xrealloc (reltab, relsize * sizeof (arelent));
1174       else
1175         reltab = (arelent *) xmalloc (relsize * sizeof (arelent));
1176     }
1177   reltab[relcount].address = address;
1178   reltab[relcount].addend = 0;
1179   reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1180   reltab[relcount].sym_ptr_ptr = symtab + symidx;
1181   relcount++;
1182 }
1183
1184 static void
1185 save_relocs (asection *sec)
1186 {
1187   int i;
1188   sec->relocation = reltab;
1189   sec->reloc_count = relcount;
1190   sec->orelocation = (arelent **) xmalloc ((relcount + 1) * sizeof (arelent *));
1191   for (i = 0; i < relcount; i++)
1192     sec->orelocation[i] = sec->relocation + i;
1193   sec->orelocation[relcount] = 0;
1194   sec->flags |= SEC_RELOC;
1195   reltab = 0;
1196   relcount = relsize = 0;
1197 }
1198
1199 /*
1200  *      .section        .idata$2
1201  *      .global         __head_my_dll
1202  * __head_my_dll:
1203  *      .rva            hname
1204  *      .long           0
1205  *      .long           0
1206  *      .rva            __my_dll_iname
1207  *      .rva            fthunk
1208  *
1209  *      .section        .idata$5
1210  *      .long           0
1211  * fthunk:
1212  *
1213  *      .section        .idata$4
1214  *      .long           0
1215  * hname:
1216  */
1217
1218 static bfd *
1219 make_head (parent)
1220      bfd *parent;
1221 {
1222   asection *id2, *id5, *id4;
1223   unsigned char *d2, *d5, *d4;
1224   char *oname;
1225   bfd *abfd;
1226
1227   oname = (char *) xmalloc (20);
1228   sprintf (oname, "d%06d.o", tmp_seq);
1229   tmp_seq++;
1230
1231   abfd = bfd_create (oname, parent);
1232   bfd_find_target (pe_details->object_target, abfd);
1233   bfd_make_writable (abfd);
1234
1235   bfd_set_format (abfd, bfd_object);
1236   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1237
1238   symptr = 0;
1239   symtab = (asymbol **) xmalloc (6 * sizeof (asymbol *));
1240   id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1241   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1242   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1243   quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1244   quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1245
1246   /* OK, pay attention here.  I got confused myself looking back at
1247      it.  We create a four-byte section to mark the beginning of the
1248      list, and we include an offset of 4 in the section, so that the
1249      pointer to the list points to the *end* of this section, which is
1250      the start of the list of sections from other objects.  */
1251
1252   bfd_set_section_size (abfd, id2, 20);
1253   d2 = (unsigned char *) xmalloc (20);
1254   id2->contents = d2;
1255   memset (d2, 0, 20);
1256   d2[0] = d2[16] = 4; /* reloc addend */
1257   quick_reloc (abfd,  0, BFD_RELOC_RVA, 2);
1258   quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1259   quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1260   save_relocs (id2);
1261
1262   bfd_set_section_size (abfd, id5, 4);
1263   d5 = (unsigned char *) xmalloc (4);
1264   id5->contents = d5;
1265   memset (d5, 0, 4);
1266
1267   bfd_set_section_size (abfd, id4, 4);
1268   d4 = (unsigned char *) xmalloc (4);
1269   id4->contents = d4;
1270   memset (d4, 0, 4);
1271
1272   bfd_set_symtab (abfd, symtab, symptr);
1273
1274   bfd_set_section_contents (abfd, id2, d2, 0, 20);
1275   bfd_set_section_contents (abfd, id5, d5, 0, 4);
1276   bfd_set_section_contents (abfd, id4, d4, 0, 4);
1277
1278   bfd_make_readable (abfd);
1279   return abfd;
1280 }
1281
1282 /*
1283  *      .section        .idata$4
1284  *      .long           0
1285  *      .section        .idata$5
1286  *      .long           0
1287  *      .section        idata$7
1288  *      .global         __my_dll_iname
1289  *__my_dll_iname:
1290  *      .asciz          "my.dll"
1291  */
1292
1293 static bfd *
1294 make_tail (parent)
1295      bfd *parent;
1296 {
1297   asection *id4, *id5, *id7;
1298   unsigned char *d4, *d5, *d7;
1299   int len;
1300   char *oname;
1301   bfd *abfd;
1302
1303   oname = (char *) xmalloc (20);
1304   sprintf (oname, "d%06d.o", tmp_seq);
1305   tmp_seq++;
1306
1307   abfd = bfd_create (oname, parent);
1308   bfd_find_target (pe_details->object_target, abfd);
1309   bfd_make_writable (abfd);
1310
1311   bfd_set_format (abfd, bfd_object);
1312   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1313
1314   symptr = 0;
1315   symtab = (asymbol **) xmalloc (5 * sizeof (asymbol *));
1316   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1317   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1318   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1319   quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1320
1321   bfd_set_section_size (abfd, id4, 4);
1322   d4 = (unsigned char *) xmalloc (4);
1323   id4->contents = d4;
1324   memset (d4, 0, 4);
1325
1326   bfd_set_section_size (abfd, id5, 4);
1327   d5 = (unsigned char *) xmalloc (4);
1328   id5->contents = d5;
1329   memset (d5, 0, 4);
1330
1331   len = strlen (dll_filename) + 1;
1332   if (len & 1)
1333     len++;
1334   bfd_set_section_size (abfd, id7, len);
1335   d7 = (unsigned char *) xmalloc (len);
1336   id7->contents = d7;
1337   strcpy (d7, dll_filename);
1338
1339   bfd_set_symtab (abfd, symtab, symptr);
1340
1341   bfd_set_section_contents (abfd, id4, d4, 0, 4);
1342   bfd_set_section_contents (abfd, id5, d5, 0, 4);
1343   bfd_set_section_contents (abfd, id7, d7, 0, len);
1344
1345   bfd_make_readable (abfd);
1346   return abfd;
1347 }
1348
1349 /*
1350  *      .text
1351  *      .global         _function
1352  *      .global         ___imp_function
1353  *      .global         __imp__function
1354  *_function:
1355  *      jmp             *__imp__function:
1356  *
1357  *      .section        idata$7
1358  *      .long           __head_my_dll
1359  *
1360  *      .section        .idata$5
1361  *___imp_function:
1362  *__imp__function:
1363  *iat?
1364  *      .section        .idata$4
1365  *iat?
1366  *      .section        .idata$6
1367  *ID<ordinal>:
1368  *      .short          <hint>
1369  *      .asciz          "function" xlate? (add underscore, kill at)
1370  */
1371
1372 static unsigned char jmp_ix86_bytes[] = {
1373   0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1374 };
1375
1376 /*
1377  *_function:
1378  *      mov.l   ip+8,r0
1379  *      mov.l   @r0,r0
1380  *      jmp     @r0
1381  *      nop
1382  *      .dw     __imp_function
1383  */
1384
1385 static unsigned char jmp_sh_bytes[] = {
1386   0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1387 };
1388
1389 /*
1390  *_function:
1391  *      lui     $t0,<high:__imp_function>
1392  *      lw      $t0,<low:__imp_function>
1393  *      jr      $t0
1394  *      nop
1395  */
1396
1397 static unsigned char jmp_mips_bytes[] = {
1398   0x00, 0x00, 0x08, 0x3c,  0x00, 0x00, 0x08, 0x8d,
1399   0x08, 0x00, 0x00, 0x01,  0x00, 0x00, 0x00, 0x00
1400 };
1401
1402 static bfd *
1403 make_one (exp, parent)
1404      def_file_export *exp;
1405      bfd *parent;
1406 {
1407   asection *tx, *id7, *id5, *id4, *id6;
1408   unsigned char *td, *d7, *d5, *d4, *d6 = NULL;
1409   int len;
1410   char *oname;
1411   bfd *abfd;
1412   unsigned char *jmp_bytes = NULL;
1413   int jmp_byte_count = 0;
1414
1415   switch (pe_details->pe_arch)
1416     {
1417     case PE_ARCH_i386:
1418       jmp_bytes = jmp_ix86_bytes;
1419       jmp_byte_count = sizeof (jmp_ix86_bytes);
1420       break;
1421     case PE_ARCH_sh:
1422       jmp_bytes = jmp_sh_bytes;
1423       jmp_byte_count = sizeof (jmp_sh_bytes);
1424       break;
1425     case PE_ARCH_mips:
1426       jmp_bytes = jmp_mips_bytes;
1427       jmp_byte_count = sizeof (jmp_mips_bytes);
1428       break;
1429     }
1430
1431   oname = (char *) xmalloc (20);
1432   sprintf (oname, "d%06d.o", tmp_seq);
1433   tmp_seq++;
1434
1435   abfd = bfd_create (oname, parent);
1436   bfd_find_target (pe_details->object_target, abfd);
1437   bfd_make_writable (abfd);
1438
1439   bfd_set_format (abfd, bfd_object);
1440   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1441
1442   symptr = 0;
1443   symtab = (asymbol **) xmalloc (10 * sizeof (asymbol *));
1444   tx  = quick_section (abfd, ".text",    SEC_CODE|SEC_HAS_CONTENTS, 2);
1445   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1446   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1447   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1448   id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
1449   if (! exp->flag_data)
1450     quick_symbol (abfd, U (""), exp->internal_name, "", tx, BSF_GLOBAL, 0);
1451   quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC, BSF_GLOBAL, 0);
1452   quick_symbol (abfd, U ("_imp__"), exp->internal_name, "", id5, BSF_GLOBAL, 0);
1453   if (pe_dll_compat_implib)
1454     quick_symbol (abfd, U ("__imp_"), exp->internal_name, "",
1455                   id5, BSF_GLOBAL, 0);
1456
1457   bfd_set_section_size (abfd, tx, jmp_byte_count);
1458   td = (unsigned char *) xmalloc (jmp_byte_count);
1459   tx->contents = td;
1460   memcpy (td, jmp_bytes, jmp_byte_count);
1461   switch (pe_details->pe_arch)
1462     {
1463     case PE_ARCH_i386:
1464       quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1465       break;
1466     case PE_ARCH_sh:
1467       quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1468       break;
1469     case PE_ARCH_mips:
1470       quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1471       quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1472       quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1473       break;
1474     }
1475   save_relocs (tx);
1476
1477   bfd_set_section_size (abfd, id7, 4);
1478   d7 = (unsigned char *) xmalloc (4);
1479   id7->contents = d7;
1480   memset (d7, 0, 4);
1481   quick_reloc (abfd, 0, BFD_RELOC_RVA, 6);
1482   save_relocs (id7);
1483
1484   bfd_set_section_size (abfd, id5, 4);
1485   d5 = (unsigned char *) xmalloc (4);
1486   id5->contents = d5;
1487   memset (d5, 0, 4);
1488   if (exp->flag_noname)
1489     {
1490       d5[0] = exp->ordinal;
1491       d5[1] = exp->ordinal >> 8;
1492       d5[3] = 0x80;
1493     }
1494   else
1495     {
1496       quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1497       save_relocs (id5);
1498     }
1499
1500   bfd_set_section_size (abfd, id4, 4);
1501   d4 = (unsigned char *) xmalloc (4);
1502   id4->contents = d4;
1503   memset (d4, 0, 4);
1504   if (exp->flag_noname)
1505     {
1506       d4[0] = exp->ordinal;
1507       d4[1] = exp->ordinal >> 8;
1508       d4[3] = 0x80;
1509     }
1510   else
1511     {
1512       quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1513       save_relocs (id4);
1514     }
1515
1516   if (exp->flag_noname)
1517     {
1518       len = 0;
1519       bfd_set_section_size (abfd, id6, 0);
1520     }
1521   else
1522     {
1523       len = strlen (exp->name) + 3;
1524       if (len & 1)
1525         len++;
1526       bfd_set_section_size (abfd, id6, len);
1527       d6 = (unsigned char *) xmalloc (len);
1528       id6->contents = d6;
1529       memset (d6, 0, len);
1530       d6[0] = exp->hint & 0xff;
1531       d6[1] = exp->hint >> 8;
1532       strcpy (d6 + 2, exp->name);
1533     }
1534
1535   bfd_set_symtab (abfd, symtab, symptr);
1536
1537   bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
1538   bfd_set_section_contents (abfd, id7, d7, 0, 4);
1539   bfd_set_section_contents (abfd, id5, d5, 0, 4);
1540   bfd_set_section_contents (abfd, id4, d4, 0, 4);
1541   if (!exp->flag_noname)
1542     bfd_set_section_contents (abfd, id6, d6, 0, len);
1543
1544   bfd_make_readable (abfd);
1545   return abfd;
1546 }
1547
1548 void
1549 pe_dll_generate_implib (def, impfilename)
1550      def_file *def;
1551      const char *impfilename;
1552 {
1553   int i;
1554   bfd *ar_head;
1555   bfd *ar_tail;
1556   bfd *outarch;
1557   bfd *head = 0;
1558
1559   dll_filename = (def->name) ? def->name : dll_name;
1560   dll_symname = xstrdup (dll_filename);
1561   for (i = 0; dll_symname[i]; i++)
1562     if (!isalnum ((unsigned char) dll_symname[i]))
1563       dll_symname[i] = '_';
1564
1565   unlink (impfilename);
1566
1567   outarch = bfd_openw (impfilename, 0);
1568
1569   if (!outarch)
1570     {
1571       /* xgettext:c-format */
1572       einfo (_("%XCan't open .lib file: %s\n"), impfilename);
1573       return;
1574     }
1575
1576   /* xgettext:c-format */
1577   einfo (_("Creating library file: %s\n"), impfilename);
1578
1579   bfd_set_format (outarch, bfd_archive);
1580   outarch->has_armap = 1;
1581
1582   /* Work out a reasonable size of things to put onto one line.  */
1583
1584   ar_head = make_head (outarch);
1585
1586   for (i = 0; i < def->num_exports; i++)
1587     {
1588       /* The import library doesn't know about the internal name.  */
1589       char *internal = def->exports[i].internal_name;
1590       bfd *n;
1591       def->exports[i].internal_name = def->exports[i].name;
1592       n = make_one (def->exports + i, outarch);
1593       n->next = head;
1594       head = n;
1595       def->exports[i].internal_name = internal;
1596     }
1597
1598   ar_tail = make_tail (outarch);
1599
1600   if (ar_head == NULL || ar_tail == NULL)
1601     return;
1602
1603   /* Now stick them all into the archive.  */
1604
1605   ar_head->next = head;
1606   ar_tail->next = ar_head;
1607   head = ar_tail;
1608
1609   if (! bfd_set_archive_head (outarch, head))
1610     einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
1611
1612   if (! bfd_close (outarch))
1613     einfo ("%Xbfd_close %s: %s\n", impfilename, bfd_errmsg (bfd_get_error ()));
1614
1615   while (head != NULL)
1616     {
1617       bfd *n = head->next;
1618       bfd_close (head);
1619       head = n;
1620     }
1621 }
1622
1623 static void
1624 add_bfd_to_link (abfd, name, link_info)
1625      bfd *abfd;
1626      char *name;
1627      struct bfd_link_info *link_info;
1628 {
1629   lang_input_statement_type *fake_file;
1630   fake_file = lang_add_input_file (name,
1631                                    lang_input_file_is_fake_enum,
1632                                    NULL);
1633   fake_file->the_bfd = abfd;
1634   ldlang_add_file (fake_file);
1635   if (!bfd_link_add_symbols (abfd, link_info))
1636     einfo ("%Xaddsym %s: %s\n", name, bfd_errmsg (bfd_get_error ()));
1637 }
1638
1639 void
1640 pe_process_import_defs (output_bfd, link_info)
1641      bfd *output_bfd;
1642      struct bfd_link_info *link_info;
1643 {
1644   def_file_module *module;
1645   pe_dll_id_target (bfd_get_target (output_bfd));
1646
1647   if (!pe_def_file)
1648     return;
1649
1650   for (module = pe_def_file->modules; module; module = module->next)
1651     {
1652       int i, do_this_dll;
1653
1654       dll_filename = module->name;
1655       dll_symname = xstrdup (module->name);
1656       for (i = 0; dll_symname[i]; i++)
1657         if (!isalnum (dll_symname[i]))
1658           dll_symname[i] = '_';
1659
1660       do_this_dll = 0;
1661
1662       for (i = 0; i < pe_def_file->num_imports; i++)
1663         if (pe_def_file->imports[i].module == module)
1664           {
1665             def_file_export exp;
1666             struct bfd_link_hash_entry *blhe;
1667
1668             /* See if we need this import.  */
1669             char *name = (char *) xmalloc (strlen (pe_def_file->imports[i].internal_name) + 2 + 6);
1670             sprintf (name, "%s%s", U (""), pe_def_file->imports[i].internal_name);
1671             blhe = bfd_link_hash_lookup (link_info->hash, name,
1672                                          false, false, false);
1673             if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
1674               {
1675                 sprintf (name, "%s%s", U ("_imp__"),
1676                          pe_def_file->imports[i].internal_name);
1677                 blhe = bfd_link_hash_lookup (link_info->hash, name,
1678                                              false, false, false);
1679               }
1680             free (name);
1681             if (blhe && blhe->type == bfd_link_hash_undefined)
1682               {
1683                 bfd *one;
1684                 /* We do.  */
1685                 if (!do_this_dll)
1686                   {
1687                     bfd *ar_head = make_head (output_bfd);
1688                     add_bfd_to_link (ar_head, ar_head->filename, link_info);
1689                     do_this_dll = 1;
1690                   }
1691                 exp.internal_name = pe_def_file->imports[i].internal_name;
1692                 exp.name = pe_def_file->imports[i].name;
1693                 exp.ordinal = pe_def_file->imports[i].ordinal;
1694                 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
1695                 exp.flag_private = 0;
1696                 exp.flag_constant = 0;
1697                 exp.flag_data = 0;
1698                 exp.flag_noname = exp.name ? 0 : 1;
1699                 one = make_one (&exp, output_bfd);
1700                 add_bfd_to_link (one, one->filename, link_info);
1701               }
1702           }
1703       if (do_this_dll)
1704         {
1705           bfd *ar_tail = make_tail (output_bfd);
1706           add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
1707         }
1708
1709       free (dll_symname);
1710     }
1711 }
1712
1713 /************************************************************************
1714
1715  We were handed a *.DLL file.  Parse it and turn it into a set of
1716  IMPORTS directives in the def file.  Return true if the file was
1717  handled, false if not.
1718
1719  ************************************************************************/
1720
1721 static unsigned int
1722 pe_get16 (abfd, where)
1723      bfd *abfd;
1724      int where;
1725 {
1726   unsigned char b[2];
1727   bfd_seek (abfd, where, SEEK_SET);
1728   bfd_read (b, 1, 2, abfd);
1729   return b[0] + (b[1] << 8);
1730 }
1731
1732 static unsigned int
1733 pe_get32 (abfd, where)
1734      bfd *abfd;
1735      int where;
1736 {
1737   unsigned char b[4];
1738   bfd_seek (abfd, where, SEEK_SET);
1739   bfd_read (b, 1, 4, abfd);
1740   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
1741 }
1742
1743 #if 0 /* This is not currently used.  */
1744
1745 static unsigned int
1746 pe_as16 (ptr)
1747      void *ptr;
1748 {
1749   unsigned char *b = ptr;
1750   return b[0] + (b[1] << 8);
1751 }
1752
1753 #endif
1754
1755 static unsigned int
1756 pe_as32 (ptr)
1757      void *ptr;
1758 {
1759   unsigned char *b = ptr;
1760   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
1761 }
1762
1763 boolean
1764 pe_implied_import_dll (filename)
1765      const char *filename;
1766 {
1767   bfd *dll;
1768   unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
1769   unsigned long export_rva, export_size, nsections, secptr, expptr;
1770   unsigned char *expdata, *erva;
1771   unsigned long name_rvas, ordinals, nexp, ordbase;
1772   const char *dll_name;
1773
1774   /* No, I can't use bfd here.  kernel32.dll puts its export table in
1775      the middle of the .rdata section.  */
1776
1777   dll = bfd_openr (filename, pe_details->target_name);
1778   if (!dll)
1779     {
1780       einfo ("%Xopen %s: %s\n", filename, bfd_errmsg (bfd_get_error ()));
1781       return false;
1782     }
1783   /* PEI dlls seem to be bfd_objects.  */
1784   if (!bfd_check_format (dll, bfd_object))
1785     {
1786       einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
1787       return false;
1788     }
1789
1790   dll_name = filename;
1791   for (i = 0; filename[i]; i++)
1792     if (filename[i] == '/' || filename[i] == '\\' || filename[i] == ':')
1793       dll_name = filename + i + 1;
1794
1795   pe_header_offset = pe_get32 (dll, 0x3c);
1796   opthdr_ofs = pe_header_offset + 4 + 20;
1797   num_entries = pe_get32 (dll, opthdr_ofs + 92);
1798   if (num_entries < 1) /* no exports */
1799     return false;
1800   export_rva = pe_get32 (dll, opthdr_ofs + 96);
1801   export_size = pe_get32 (dll, opthdr_ofs + 100);
1802   nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
1803   secptr = (pe_header_offset + 4 + 20 +
1804             pe_get16 (dll, pe_header_offset + 4 + 16));
1805   expptr = 0;
1806   for (i = 0; i < nsections; i++)
1807     {
1808       char sname[8];
1809       unsigned long secptr1 = secptr + 40 * i;
1810       unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
1811       unsigned long vsize = pe_get32 (dll, secptr1 + 16);
1812       unsigned long fptr = pe_get32 (dll, secptr1 + 20);
1813       bfd_seek (dll, secptr1, SEEK_SET);
1814       bfd_read (sname, 1, 8, dll);
1815       if (vaddr <= export_rva && vaddr + vsize > export_rva)
1816         {
1817           expptr = fptr + (export_rva - vaddr);
1818           if (export_rva + export_size > vaddr + vsize)
1819             export_size = vsize - (export_rva - vaddr);
1820           break;
1821         }
1822     }
1823
1824   expdata = (unsigned char *) xmalloc (export_size);
1825   bfd_seek (dll, expptr, SEEK_SET);
1826   bfd_read (expdata, 1, export_size, dll);
1827   erva = expdata - export_rva;
1828
1829   if (pe_def_file == 0)
1830     pe_def_file = def_file_empty ();
1831
1832   nexp = pe_as32 (expdata + 24);
1833   name_rvas = pe_as32 (expdata + 32);
1834   ordinals = pe_as32 (expdata + 36);
1835   ordbase = pe_as32 (expdata + 16);
1836   for (i = 0; i < nexp; i++)
1837     {
1838       unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
1839       def_file_import *imp;
1840       imp = def_file_add_import (pe_def_file, erva + name_rva, dll_name,
1841                                  i, 0);
1842     }
1843
1844   return true;
1845 }
1846
1847 /************************************************************************
1848
1849  These are the main functions, called from the emulation.  The first
1850  is called after the bfds are read, so we can guess at how much space
1851  we need.  The second is called after everything is placed, so we
1852  can put the right values in place.
1853
1854  ************************************************************************/
1855
1856 void
1857 pe_dll_build_sections (abfd, info)
1858      bfd *abfd;
1859      struct bfd_link_info *info;
1860 {
1861   pe_dll_id_target (bfd_get_target (abfd));
1862   process_def_file (abfd, info);
1863
1864   generate_edata (abfd, info);
1865   build_filler_bfd (1);
1866 }
1867
1868 void
1869 pe_exe_build_sections (abfd, info)
1870      bfd *abfd;
1871      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1872 {
1873   pe_dll_id_target (bfd_get_target (abfd));
1874   build_filler_bfd (0);
1875 }
1876
1877 void
1878 pe_dll_fill_sections (abfd, info)
1879      bfd *abfd;
1880      struct bfd_link_info *info;
1881 {
1882   pe_dll_id_target (bfd_get_target (abfd));
1883   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
1884
1885   generate_reloc (abfd, info);
1886   if (reloc_sz > 0)
1887     {
1888       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
1889
1890       /* Resize the sections.  */
1891       lang_size_sections (stat_ptr->head, abs_output_section,
1892                           &stat_ptr->head, 0, (bfd_vma) 0, false);
1893
1894       /* Redo special stuff.  */
1895       ldemul_after_allocation ();
1896
1897       /* Do the assignments again.  */
1898       lang_do_assignments (stat_ptr->head,
1899                            abs_output_section,
1900                            (fill_type) 0, (bfd_vma) 0);
1901     }
1902
1903   fill_edata (abfd, info);
1904
1905   pe_data (abfd)->dll = 1;
1906
1907   edata_s->contents = edata_d;
1908   reloc_s->contents = reloc_d;
1909 }
1910
1911 void
1912 pe_exe_fill_sections (abfd, info)
1913      bfd *abfd;
1914      struct bfd_link_info *info;
1915 {
1916   pe_dll_id_target (bfd_get_target (abfd));
1917   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
1918
1919   generate_reloc (abfd, info);
1920   if (reloc_sz > 0)
1921     {
1922       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
1923
1924       /* Resize the sections.  */
1925       lang_size_sections (stat_ptr->head, abs_output_section,
1926                           &stat_ptr->head, 0, (bfd_vma) 0, false);
1927
1928       /* Redo special stuff.  */
1929       ldemul_after_allocation ();
1930
1931       /* Do the assignments again.  */
1932       lang_do_assignments (stat_ptr->head,
1933                            abs_output_section,
1934                            (fill_type) 0, (bfd_vma) 0);
1935     }
1936   reloc_s->contents = reloc_d;
1937 }