ld/pe-dll.c

   1 /* Routines to help build PEI-format DLLs (Win32 etc)
   2    Copyright (C) 1998 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 "ld.h"
  28 #include "ldexp.h"
  29 #include "ldlang.h"
  30 #include "ldwrite.h"
  31 #include "ldmisc.h"
  32 #include "ldgram.h"
  33 #include "ldmain.h"
  34 #include "coff/internal.h"
  35 #include "../bfd/libcoff.h"
  36 #include "deffile.h"
  37
  38 /************************************************************************
  39
  40  This file turns a regular Windows PE image into a DLL.  Because of
  41  the complexity of this operation, it has been broken down into a
  42  number of separate modules which are all called by the main function
  43  at the end of this file.  This function is not re-entrant and is
  44  normally only called once, so static variables are used to reduce
  45  the number of parameters and return values required.
  46
  47  See also: ld/emultempl/pe.em
  48
  49  ************************************************************************/
  50
  51 /* from emultempl/pe.em */
  52
  53 extern def_file *pe_def_file;
  54 extern int pe_dll_export_everything;
  55 extern int pe_dll_do_default_excludes;
  56 extern int pe_dll_kill_ats;
  57 extern int pe_dll_stdcall_aliases;
  58
  59 /************************************************************************
  60
  61  static variables and types
  62
  63  ************************************************************************/
  64
  65 static bfd_vma image_base;
  66
  67 static bfd *filler_bfd;
  68 static struct sec *edata_s, *reloc_s;
  69 static unsigned char *edata_d, *reloc_d;
  70 static int edata_sz, reloc_sz;
  71
  72 /************************************************************************
  73
  74  Helper functions for qsort.  Relocs must be sorted so that we can write
  75  them out by pages.
  76
  77  ************************************************************************/
  78
  79 static int
  80 reloc_sort (va, vb)
  81      const void *va, *vb;
  82 {
  83   unsigned long a = *(unsigned long *) va;
  84   unsigned long b = *(unsigned long *) vb;
  85   return a - b;
  86 }
  87
  88 static int
  89 pe_export_sort (va, vb)
  90      const void *va, *vb;
  91 {
  92   def_file_export *a = (def_file_export *) va;
  93   def_file_export *b = (def_file_export *) vb;
  94   return strcmp (a->name, b->name);
  95 }
  96
  97 /************************************************************************
  98
  99  Read and process the .DEF file
 100
 101  ************************************************************************/
 102
 103 /* These correspond to the entries in pe_def_file->exports[].  I use
 104    exported_symbol_sections[i] to tag whether or not the symbol was
 105    defined, since we can't export symbols we don't have. */
 106
 107 static bfd_vma *exported_symbol_offsets;
 108 static struct sec **exported_symbol_sections;
 109
 110 static int export_table_size;
 111 static int count_exported;
 112 static int count_exported_byname;
 113 static int count_with_ordinals;
 114 static const char *dll_name;
 115 static int min_ordinal, max_ordinal;
 116 static int *exported_symbols;
 117
 118 typedef struct exclude_list_struct
 119   {
 120     char *string;
 121     struct exclude_list_struct *next;
 122   }
 123 exclude_list_struct;
 124 static struct exclude_list_struct *excludes = 0;
 125
 126 void
 127 pe_dll_add_excludes (new_excludes)
 128      const char *new_excludes;
 129 {
 130   char *local_copy;
 131   char *exclude_string;
 132
 133   local_copy = xstrdup (new_excludes);
 134
 135   exclude_string = strtok (local_copy, ",:");
 136   for (; exclude_string; exclude_string = strtok (NULL, ",:"))
 137     {
 138       struct exclude_list_struct *new_exclude;
 139
 140       new_exclude = ((struct exclude_list_struct *)
 141                      xmalloc (sizeof (struct exclude_list_struct)));
 142       new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 1);
 143       strcpy (new_exclude->string, exclude_string);
 144       new_exclude->next = excludes;
 145       excludes = new_exclude;
 146     }
 147
 148   free (local_copy);
 149 }
 150
 151 static int
 152 auto_export (d, n)
 153      def_file *d;
 154      const char *n;
 155 {
 156   int i;
 157   struct exclude_list_struct *ex;
 158   for (i = 0; i < d->num_exports; i++)
 159     if (strcmp (d->exports[i].name, n) == 0)
 160       return 0;
 161   if (pe_dll_do_default_excludes)
 162     {
 163       if (strcmp (n, "DllMain@12") == 0)
 164         return 0;
 165       if (strcmp (n, "DllEntryPoint@0") == 0)
 166         return 0;
 167       if (strcmp (n, "impure_ptr") == 0)
 168         return 0;
 169     }
 170   for (ex = excludes; ex; ex = ex->next)
 171     if (strcmp (n, ex->string) == 0)
 172       return 0;
 173   return 1;
 174 }
 175
 176 static void
 177 process_def_file (abfd, info)
 178      bfd *abfd;
 179      struct bfd_link_info *info;
 180 {
 181   int i, j;
 182   struct bfd_link_hash_entry *blhe;
 183   bfd *b;
 184   struct sec *s;
 185   def_file_export *e=0;
 186
 187   if (!pe_def_file)
 188     pe_def_file = def_file_empty ();
 189
 190   /* First, run around to all the objects looking for the .drectve
 191      sections, and push those into the def file too */
 192
 193   for (b = info->input_bfds; b; b = b->link_next)
 194     {
 195       s = bfd_get_section_by_name (b, ".drectve");
 196       if (s)
 197         {
 198           int size = bfd_get_section_size_before_reloc (s);
 199           char *buf = xmalloc (size);
 200           bfd_get_section_contents (b, s, buf, 0, size);
 201           def_file_add_directive (pe_def_file, buf, size);
 202           free (buf);
 203         }
 204     }
 205
 206   /* Now, maybe export everything else the default way */
 207
 208   if (pe_dll_export_everything || pe_def_file->num_exports == 0)
 209     {
 210       for (b = info->input_bfds; b; b = b->link_next)
 211         {
 212           asymbol **symbols;
 213           int nsyms, symsize;
 214
 215           symsize = bfd_get_symtab_upper_bound (b);
 216           symbols = (asymbol **) xmalloc (symsize);
 217           nsyms = bfd_canonicalize_symtab (b, symbols);
 218
 219           for (j = 0; j < nsyms; j++)
 220             {
 221               if ((symbols[j]->flags & (BSF_FUNCTION | BSF_GLOBAL))
 222                   == (BSF_FUNCTION | BSF_GLOBAL))
 223                 {
 224                   const char *sn = symbols[j]->name;
 225                   if (*sn == '_')
 226                     sn++;
 227                   if (auto_export (pe_def_file, sn))
 228                     def_file_add_export (pe_def_file, sn, 0, -1);
 229                 }
 230             }
 231         }
 232     }
 233
 234 #undef NE
 235 #define NE pe_def_file->num_exports
 236
 237   /* Canonicalize the export list */
 238
 239   if (pe_dll_kill_ats)
 240     {
 241       for (i = 0; i < NE; i++)
 242         {
 243           if (strchr (pe_def_file->exports[i].name, '@'))
 244             {
 245               /* This will preserve internal_name, which may have been pointing
 246                  to the same memory as name, or might not have */
 247               char *tmp = xstrdup (pe_def_file->exports[i].name);
 248               *(strchr (tmp, '@')) = 0;
 249               pe_def_file->exports[i].name = tmp;
 250             }
 251         }
 252     }
 253
 254   if (pe_dll_stdcall_aliases)
 255     {
 256       for (i = 0; i < NE; i++)
 257         {
 258           if (strchr (pe_def_file->exports[i].name, '@'))
 259             {
 260               char *tmp = xstrdup (pe_def_file->exports[i].name);
 261               *(strchr (tmp, '@')) = 0;
 262               if (auto_export (pe_def_file, tmp))
 263                 def_file_add_export (pe_def_file, tmp,
 264                                      pe_def_file->exports[i].internal_name, -1);
 265               else
 266                 free (tmp);
 267             }
 268         }
 269     }
 270
 271   e = pe_def_file->exports; /* convenience, but watch out for it changing */
 272
 273   exported_symbol_offsets = (bfd_vma *) xmalloc (NE * sizeof (bfd_vma));
 274   exported_symbol_sections = (struct sec **) xmalloc (NE * sizeof (struct sec *));
 275
 276   memset (exported_symbol_sections, 0, NE * sizeof (struct sec *));
 277   max_ordinal = 0;
 278   min_ordinal = 65536;
 279   count_exported = 0;
 280   count_exported_byname = 0;
 281   count_with_ordinals = 0;
 282
 283   qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]), pe_export_sort);
 284   for (i = 0, j = 0; i < NE; i++)
 285     {
 286       if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
 287         {
 288           /* This is a duplicate */
 289           if (e[j - 1].ordinal != -1
 290               && e[i].ordinal != -1
 291               && e[j - 1].ordinal != e[i].ordinal)
 292             {
 293               /* xgettext:c-format */
 294               einfo (_("%XError, duplicate EXPORT with oridinals: %s (%d vs %d)\n"),
 295                      e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
 296             }
 297           else
 298             {
 299               /* xgettext:c-format */
 300               einfo (_("Warning, duplicate EXPORT: %s\n"),
 301                      e[j - 1].name);
 302             }
 303           if (e[i].ordinal)
 304             e[j - 1].ordinal = e[i].ordinal;
 305           e[j - 1].flag_private |= e[i].flag_private;
 306           e[j - 1].flag_constant |= e[i].flag_constant;
 307           e[j - 1].flag_noname |= e[i].flag_noname;
 308           e[j - 1].flag_data |= e[i].flag_data;
 309         }
 310       else
 311         {
 312           if (i != j)
 313             e[j] = e[i];
 314           j++;
 315         }
 316     }
 317   pe_def_file->num_exports = j; /* == NE */
 318
 319   for (i = 0; i < NE; i++)
 320     {
 321       char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
 322       *name = '_';
 323       strcpy (name + 1, pe_def_file->exports[i].internal_name);
 324
 325       blhe = bfd_link_hash_lookup (info->hash,
 326                                    name,
 327                                    false, false, true);
 328
 329       if (blhe && (blhe->type == bfd_link_hash_defined))
 330         {
 331           count_exported++;
 332           if (!pe_def_file->exports[i].flag_noname)
 333             count_exported_byname++;
 334           exported_symbol_offsets[i] = blhe->u.def.value;
 335           exported_symbol_sections[i] = blhe->u.def.section;
 336           if (pe_def_file->exports[i].ordinal != -1)
 337             {
 338               if (max_ordinal < pe_def_file->exports[i].ordinal)
 339                 max_ordinal = pe_def_file->exports[i].ordinal;
 340               if (min_ordinal > pe_def_file->exports[i].ordinal)
 341                 min_ordinal = pe_def_file->exports[i].ordinal;
 342               count_with_ordinals++;
 343             }
 344         }
 345       else if (blhe && blhe->type == bfd_link_hash_undefined)
 346         {
 347           /* xgettext:c-format */
 348           einfo (_("%XCannot export %s: symbol not defined\n"),
 349                  pe_def_file->exports[i].internal_name);
 350         }
 351       else if (blhe)
 352         {
 353           /* xgettext:c-format */
 354           einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
 355                  pe_def_file->exports[i].internal_name,
 356                  blhe->type, bfd_link_hash_defined);
 357         }
 358       else
 359         {
 360           /* xgettext:c-format */
 361           einfo (_("%XCannot export %s: symbol not found\n"),
 362                  pe_def_file->exports[i].internal_name);
 363         }
 364       free(name);
 365     }
 366 }
 367
 368 /************************************************************************
 369
 370  Build the bfd that will contain .edata and .reloc sections
 371
 372  ************************************************************************/
 373
 374 static void
 375 build_filler_bfd ()
 376 {
 377   static lang_input_statement_type *filler_file;
 378   filler_file = lang_add_input_file ("dll stuff",
 379                                      lang_input_file_is_fake_enum,
 380                                      NULL);
 381   filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
 382   if (filler_bfd == NULL
 383       || !bfd_set_arch_mach (filler_bfd,
 384                              bfd_get_arch (output_bfd),
 385                              bfd_get_mach (output_bfd)))
 386     {
 387       einfo ("%X%P: can not create BFD %E\n");
 388       return;
 389     }
 390
 391   edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
 392   if (edata_s == NULL
 393       || !bfd_set_section_flags (filler_bfd, edata_s,
 394                                  (SEC_HAS_CONTENTS
 395                                   | SEC_ALLOC
 396                                   | SEC_LOAD
 397                                   | SEC_KEEP
 398                                   | SEC_IN_MEMORY)))
 399     {
 400       einfo ("%X%P: can not create .edata section: %E\n");
 401       return;
 402     }
 403   bfd_set_section_size (filler_bfd, edata_s, edata_sz);
 404
 405   reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
 406   if (reloc_s == NULL
 407       || !bfd_set_section_flags (filler_bfd, reloc_s,
 408                                  (SEC_HAS_CONTENTS
 409                                   | SEC_ALLOC
 410                                   | SEC_LOAD
 411                                   | SEC_KEEP
 412                                   | SEC_IN_MEMORY)))
 413     {
 414       einfo ("%X%P: can not create .reloc section: %E\n");
 415       return;
 416     }
 417   bfd_set_section_size (filler_bfd, reloc_s, 0);
 418
 419   ldlang_add_file (filler_file);
 420 }
 421
 422 /************************************************************************
 423
 424  Gather all the exported symbols and build the .edata section
 425
 426  ************************************************************************/
 427
 428 static void
 429 generate_edata (abfd, info)
 430      bfd *abfd;
 431      struct bfd_link_info *info;
 432 {
 433   int i, j, next_ordinal;
 434   int name_table_size = 0;
 435   const char *dlnp;
 436
 437   /* First, we need to know how many exported symbols there are,
 438      and what the range of ordinals is. */
 439
 440   if (pe_def_file->name)
 441     {
 442       dll_name = pe_def_file->name;
 443     }
 444   else
 445     {
 446       dll_name = abfd->filename;
 447       for (dlnp = dll_name; *dlnp; dlnp++)
 448         {
 449           if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
 450             dll_name = dlnp + 1;
 451         }
 452     }
 453
 454   if (count_with_ordinals && max_ordinal > count_exported)
 455     {
 456       if (min_ordinal > max_ordinal - count_exported + 1)
 457         min_ordinal = max_ordinal - count_exported + 1;
 458     }
 459   else
 460     {
 461       min_ordinal = 1;
 462       max_ordinal = count_exported;
 463     }
 464   export_table_size = max_ordinal - min_ordinal + 1;
 465
 466   exported_symbols = (int *) xmalloc (export_table_size * sizeof (int));
 467   for (i = 0; i < export_table_size; i++)
 468     exported_symbols[i] = -1;
 469
 470   /* Now we need to assign ordinals to those that don't have them */
 471   for (i = 0; i < NE; i++)
 472     {
 473       if (exported_symbol_sections[i])
 474         {
 475           if (pe_def_file->exports[i].ordinal != -1)
 476             {
 477               int ei = pe_def_file->exports[i].ordinal - min_ordinal;
 478               int pi = exported_symbols[ei];
 479               if (pi != -1)
 480                 {
 481                   /* xgettext:c-format */
 482                   einfo (_("%XError, oridinal used twice: %d (%s vs %s)\n"),
 483                          pe_def_file->exports[i].ordinal,
 484                          pe_def_file->exports[i].name,
 485                          pe_def_file->exports[pi].name);
 486                 }
 487               exported_symbols[ei] = i;
 488             }
 489           name_table_size += strlen (pe_def_file->exports[i].name) + 1;
 490         }
 491     }
 492
 493   next_ordinal = min_ordinal;
 494   for (i = 0; i < NE; i++)
 495     if (exported_symbol_sections[i])
 496       if (pe_def_file->exports[i].ordinal == -1)
 497         {
 498           while (exported_symbols[next_ordinal - min_ordinal] != -1)
 499             next_ordinal++;
 500           exported_symbols[next_ordinal - min_ordinal] = i;
 501           pe_def_file->exports[i].ordinal = next_ordinal;
 502         }
 503
 504   /* OK, now we can allocate some memory */
 505
 506   edata_sz = (40                /* directory */
 507               + 4 * export_table_size   /* addresses */
 508               + 4 * count_exported_byname       /* name ptrs */
 509               + 2 * count_exported_byname       /* ordinals */
 510               + name_table_size + strlen (dll_name) + 1);
 511 }
 512
 513 static void
 514 fill_edata (abfd, info)
 515      bfd *abfd;
 516      struct bfd_link_info *info;
 517 {
 518   int i;
 519   unsigned char *edirectory;
 520   unsigned long *eaddresses;
 521   unsigned long *enameptrs;
 522   unsigned short *eordinals;
 523   unsigned char *enamestr;
 524
 525   edata_d = (unsigned char *) xmalloc (edata_sz);
 526
 527   /* Note use of array pointer math here */
 528   edirectory = edata_d;
 529   eaddresses = (unsigned long *) (edata_d + 40);
 530   enameptrs = eaddresses + export_table_size;
 531   eordinals = (unsigned short *) (enameptrs + count_exported_byname);
 532   enamestr = (char *) (eordinals + count_exported_byname);
 533
 534 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
 535
 536   memset (edata_d, 0, 40);
 537   if (pe_def_file->version_major != -1)
 538     {
 539       bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
 540       bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
 541     }
 542   bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
 543   strcpy (enamestr, dll_name);
 544   enamestr += strlen (enamestr) + 1;
 545   bfd_put_32 (abfd, min_ordinal, edata_d + 16);
 546   bfd_put_32 (abfd, export_table_size, edata_d + 20);
 547   bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
 548   bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
 549   bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
 550   bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
 551
 552   /* Ok, now for the filling in part */
 553   for (i = 0; i < export_table_size; i++)
 554     {
 555       int s = exported_symbols[i];
 556       if (s != -1)
 557         {
 558           struct sec *ssec = exported_symbol_sections[s];
 559           unsigned long srva = (exported_symbol_offsets[s]
 560                                 + ssec->output_section->vma
 561                                 + ssec->output_offset);
 562
 563           bfd_put_32 (abfd, srva - image_base, (void *) (eaddresses + i));
 564           if (!pe_def_file->exports[s].flag_noname)
 565             {
 566               char *ename = pe_def_file->exports[s].name;
 567               bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs);
 568               strcpy (enamestr, ename[0] == '_' ? ename + 1 : ename);
 569               enamestr += strlen (enamestr) + 1;
 570               bfd_put_16 (abfd, i, (void *) eordinals);
 571               enameptrs++;
 572             }
 573           eordinals++;
 574         }
 575     }
 576 }
 577
 578 /************************************************************************
 579
 580  Gather all the relocations and build the .reloc section
 581
 582  ************************************************************************/
 583
 584 static void
 585 generate_reloc (abfd, info)
 586      bfd *abfd;
 587      struct bfd_link_info *info;
 588 {
 589
 590   /* for .reloc stuff */
 591   bfd_vma *reloc_addresses;
 592   int total_relocs = 0;
 593   int i, j;
 594   unsigned long sec_page = (unsigned long) (-1);
 595   unsigned long page_ptr, page_count;
 596   int bi;
 597   bfd *b;
 598   struct sec *s;
 599
 600   total_relocs = 0;
 601   for (b = info->input_bfds; b; b = b->link_next)
 602     for (s = b->sections; s; s = s->next)
 603       total_relocs += s->reloc_count;
 604
 605   reloc_addresses = (unsigned long *) xmalloc (total_relocs * sizeof (unsigned long));
 606
 607   total_relocs = 0;
 608   bi = 0;
 609   for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
 610     {
 611       arelent **relocs;
 612       int relsize, nrelocs, i;
 613
 614       for (s = b->sections; s; s = s->next)
 615         {
 616           unsigned long sec_vma = s->output_section->vma + s->output_offset;
 617           asymbol **symbols;
 618           int nsyms, symsize;
 619
 620           symsize = bfd_get_symtab_upper_bound (b);
 621           symbols = (asymbol **) xmalloc (symsize);
 622           nsyms = bfd_canonicalize_symtab (b, symbols);
 623
 624           relsize = bfd_get_reloc_upper_bound (b, s);
 625           relocs = (arelent **) xmalloc ((size_t) relsize);
 626           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
 627
 628           for (i = 0; i < nrelocs; i++)
 629             {
 630               if (!relocs[i]->howto->pc_relative)
 631                 {
 632                   switch (relocs[i]->howto->bitsize)
 633                     {
 634                     case 32:
 635                       reloc_addresses[total_relocs++] = sec_vma + relocs[i]->address;
 636                       break;
 637                     default:
 638                       /* xgettext:c-format */
 639                       einfo (_("%XError: %d-bit reloc in dll\n"),
 640                              relocs[i]->howto->bitsize);
 641                       break;
 642                     }
 643                 }
 644             }
 645           free (relocs);
 646           /* Warning: the allocated symbols are remembered in BFD and reused
 647              later, so don't free them! */
 648           /* free(symbols); */
 649         }
 650     }
 651
 652   /* At this point, we have total_relocs relocation addresses in
 653      reloc_addresses, which are all suitable for the .reloc section.
 654      We must now create the new sections. */
 655
 656   qsort (reloc_addresses, total_relocs, sizeof (unsigned long), reloc_sort);
 657
 658   for (i = 0; i < total_relocs; i++)
 659     {
 660       unsigned long this_page = (reloc_addresses[i] >> 12);
 661       if (this_page != sec_page)
 662         {
 663           reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align */
 664           reloc_sz += 8;
 665           sec_page = this_page;
 666         }
 667       reloc_sz += 2;
 668     }
 669   reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align */
 670
 671   reloc_d = (unsigned char *) xmalloc (reloc_sz);
 672
 673   sec_page = (unsigned long) (-1);
 674   reloc_sz = 0;
 675   page_ptr = (unsigned long) (-1);
 676   page_count = 0;
 677   for (i = 0; i < total_relocs; i++)
 678     {
 679       unsigned long rva = reloc_addresses[i] - image_base;
 680       unsigned long this_page = (rva & ~0xfff);
 681       if (this_page != sec_page)
 682         {
 683           while (reloc_sz & 3)
 684             reloc_d[reloc_sz++] = 0;
 685           if (page_ptr != (unsigned long) (-1))
 686             bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
 687           bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
 688           page_ptr = reloc_sz;
 689           reloc_sz += 8;
 690           sec_page = this_page;
 691           page_count = 0;
 692         }
 693       bfd_put_16 (abfd, (rva & 0xfff) + 0x3000, reloc_d + reloc_sz);
 694       reloc_sz += 2;
 695       page_count++;
 696     }
 697   while (reloc_sz & 3)
 698     reloc_d[reloc_sz++] = 0;
 699   if (page_ptr != (unsigned long) (-1))
 700     bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
 701   while (reloc_sz < reloc_s->_raw_size)
 702     reloc_d[reloc_sz++] = 0;
 703 }
 704
 705 /************************************************************************
 706
 707  Given the exiting def_file structure, print out a .DEF file that
 708  corresponds to it.
 709
 710  ************************************************************************/
 711
 712 static void
 713 quoteput (s, f, needs_quotes)
 714      char *s;
 715      FILE * f;
 716      int needs_quotes;
 717 {
 718   char *cp;
 719   for (cp = s; *cp; cp++)
 720     if (*cp == '\'' || *cp == '"' || *cp == '\\' || isspace (*cp) || *cp == ','
 721         || *cp == ';')
 722       needs_quotes = 1;
 723   if (needs_quotes)
 724     {
 725       putc ('"', f);
 726       while (*s)
 727         {
 728           if (*s == '"' || *s == '\\')
 729             putc ('\\', f);
 730           putc (*s, f);
 731           s++;
 732         }
 733       putc ('"', f);
 734     }
 735   else
 736     fputs (s, f);
 737 }
 738
 739 void
 740 pe_dll_generate_def_file (pe_out_def_filename)
 741      char *pe_out_def_filename;
 742 {
 743   int i;
 744   FILE *out = fopen (pe_out_def_filename, "w");
 745   if (out == NULL)
 746     {
 747       /* xgettext:c-format */
 748       einfo (_("%s: Can't open output def file %s\n"),
 749              program_name, pe_out_def_filename);
 750     }
 751
 752   if (pe_def_file)
 753     {
 754       if (pe_def_file->name)
 755         {
 756           if (pe_def_file->is_dll)
 757             fprintf (out, "LIBRARY ");
 758           else
 759             fprintf (out, "NAME ");
 760           quoteput (pe_def_file->name, out, 1);
 761           if (pe_def_file->base_address != (bfd_vma) (-1))
 762             fprintf (out, " BASE=0x%x", pe_def_file->base_address);
 763           fprintf (out, "\n");
 764         }
 765
 766       if (pe_def_file->description)
 767         {
 768           fprintf (out, "DESCRIPTION ");
 769           quoteput (pe_def_file->description, out, 1);
 770           fprintf (out, "\n");
 771         }
 772
 773       if (pe_def_file->version_minor)
 774         fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
 775                  pe_def_file->version_minor);
 776       else
 777         fprintf (out, "VERSION %d\n", pe_def_file->version_major);
 778
 779       if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
 780         fprintf (out, "\n");
 781
 782       if (pe_def_file->stack_commit != -1)
 783         fprintf (out, "STACKSIZE 0x%x,0x%x\n",
 784                  pe_def_file->stack_reserve, pe_def_file->stack_commit);
 785       else if (pe_def_file->stack_reserve != -1)
 786         fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
 787       if (pe_def_file->heap_commit != -1)
 788         fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
 789                  pe_def_file->heap_reserve, pe_def_file->heap_commit);
 790       else if (pe_def_file->heap_reserve != -1)
 791         fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
 792
 793       if (pe_def_file->num_section_defs > 0)
 794         {
 795           fprintf (out, "\nSECTIONS\n\n");
 796           for (i = 0; i < pe_def_file->num_section_defs; i++)
 797             {
 798               fprintf (out, "    ");
 799               quoteput (pe_def_file->section_defs[i].name, out, 0);
 800               if (pe_def_file->section_defs[i].class)
 801                 {
 802                   fprintf (out, " CLASS ");
 803                   quoteput (pe_def_file->section_defs[i].class, out, 0);
 804                 }
 805               if (pe_def_file->section_defs[i].flag_read)
 806                 fprintf (out, " READ");
 807               if (pe_def_file->section_defs[i].flag_write)
 808                 fprintf (out, " WRITE");
 809               if (pe_def_file->section_defs[i].flag_execute)
 810                 fprintf (out, " EXECUTE");
 811               if (pe_def_file->section_defs[i].flag_shared)
 812                 fprintf (out, " SHARED");
 813               fprintf (out, "\n");
 814             }
 815         }
 816
 817       if (pe_def_file->num_exports > 0)
 818         {
 819           fprintf (out, "\nEXPORTS\n\n");
 820           for (i = 0; i < pe_def_file->num_exports; i++)
 821             {
 822               def_file_export *e = pe_def_file->exports + i;
 823               fprintf (out, "    ");
 824               quoteput (e->name, out, 0);
 825               if (e->internal_name && strcmp (e->internal_name, e->name))
 826                 {
 827                   fprintf (out, " = ");
 828                   quoteput (e->internal_name, out, 0);
 829                 }
 830               if (e->ordinal != -1)
 831                 fprintf (out, " @%d", e->ordinal);
 832               if (e->flag_private)
 833                 fprintf (out, " PRIVATE");
 834               if (e->flag_constant)
 835                 fprintf (out, " CONSTANT");
 836               if (e->flag_noname)
 837                 fprintf (out, " NONAME");
 838               if (e->flag_data)
 839                 fprintf (out, " DATA");
 840
 841               fprintf (out, "\n");
 842             }
 843         }
 844
 845       if (pe_def_file->num_imports > 0)
 846         {
 847           fprintf (out, "\nIMPORTS\n\n");
 848           for (i = 0; i < pe_def_file->num_imports; i++)
 849             {
 850               def_file_import *im = pe_def_file->imports + i;
 851               fprintf (out, "    ");
 852               if (im->internal_name
 853                   && (!im->name || strcmp (im->internal_name, im->name)))
 854                 {
 855                   quoteput (im->internal_name, out, 0);
 856                   fprintf (out, " = ");
 857                 }
 858               quoteput (im->module->name, out, 0);
 859               fprintf (out, ".");
 860               if (im->name)
 861                 quoteput (im->name, out, 0);
 862               else
 863                 fprintf (out, "%d", im->ordinal);
 864               fprintf (out, "\n");
 865             }
 866         }
 867     }
 868   else
 869     fprintf (out, _("; no contents available\n"));
 870
 871   if (fclose (out) == EOF)
 872     {
 873       /* xgettext:c-format */
 874       einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
 875     }
 876 }
 877
 878 /************************************************************************
 879
 880  These are the main functions, called from the emulation.  The first
 881  is called after the bfds are read, so we can guess at how much space
 882  we need.  The second is called after everything is placed, so we
 883  can put the right values in place.
 884
 885  ************************************************************************/
 886
 887 void
 888 pe_dll_build_sections (abfd, info)
 889      bfd *abfd;
 890      struct bfd_link_info *info;
 891 {
 892   process_def_file (abfd, info);
 893
 894   generate_edata (abfd, info);
 895   build_filler_bfd ();
 896 }
 897
 898 void
 899 pe_dll_fill_sections (abfd, info)
 900      bfd *abfd;
 901      struct bfd_link_info *info;
 902 {
 903   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
 904
 905   generate_reloc (abfd, info);
 906   if (reloc_sz > 0)
 907     {
 908       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
 909
 910       /* Resize the sections.  */
 911       lang_size_sections (stat_ptr->head, abs_output_section,
 912                           &stat_ptr->head, 0, (bfd_vma) 0, false);
 913
 914       /* Redo special stuff.  */
 915       ldemul_after_allocation ();
 916
 917       /* Do the assignments again.  */
 918       lang_do_assignments (stat_ptr->head,
 919                            abs_output_section,
 920                            (fill_type) 0, (bfd_vma) 0);
 921     }
 922
 923   fill_edata (abfd, info);
 924
 925   pe_data (abfd)->dll = 1;
 926
 927   edata_s->contents = edata_d;
 928   reloc_s->contents = reloc_d;
 929 }