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);
 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           /* if it's not loaded, we don't need to relocate it this way */
 621           if (!(s->output_section->flags & SEC_LOAD))
 622             continue;
 623
 624           /* I don't know why there would be a reloc for these, but I've
 625              seen it happen - DJ */
 626           if (s->output_section == &bfd_abs_section)
 627             continue;
 628
 629           if (s->output_section->vma == 0)
 630             {
 631               /* Huh?  Shouldn't happen, but punt if it does */
 632               einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
 633                      s->output_section->name, s->output_section->index,
 634                      s->output_section->flags);
 635               continue;
 636             }
 637
 638           symsize = bfd_get_symtab_upper_bound (b);
 639           symbols = (asymbol **) xmalloc (symsize);
 640           nsyms = bfd_canonicalize_symtab (b, symbols);
 641
 642           relsize = bfd_get_reloc_upper_bound (b, s);
 643           relocs = (arelent **) xmalloc ((size_t) relsize);
 644           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
 645
 646           for (i = 0; i < nrelocs; i++)
 647             {
 648               if (!relocs[i]->howto->pc_relative
 649                   && relocs[i]->howto->type != R_IMAGEBASE)
 650                 {
 651                   switch (relocs[i]->howto->bitsize)
 652                     {
 653                     case 32:
 654                       reloc_addresses[total_relocs++] = sec_vma + relocs[i]->address;
 655                       break;
 656                     default:
 657                       /* xgettext:c-format */
 658                       einfo (_("%XError: %d-bit reloc in dll\n"),
 659                              relocs[i]->howto->bitsize);
 660                       break;
 661                     }
 662                 }
 663             }
 664           free (relocs);
 665           /* Warning: the allocated symbols are remembered in BFD and reused
 666              later, so don't free them! */
 667           /* free(symbols); */
 668         }
 669     }
 670
 671   /* At this point, we have total_relocs relocation addresses in
 672      reloc_addresses, which are all suitable for the .reloc section.
 673      We must now create the new sections. */
 674
 675   qsort (reloc_addresses, total_relocs, sizeof (unsigned long), reloc_sort);
 676
 677   for (i = 0; i < total_relocs; i++)
 678     {
 679       unsigned long this_page = (reloc_addresses[i] >> 12);
 680       if (this_page != sec_page)
 681         {
 682           reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align */
 683           reloc_sz += 8;
 684           sec_page = this_page;
 685         }
 686       reloc_sz += 2;
 687     }
 688   reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align */
 689
 690   reloc_d = (unsigned char *) xmalloc (reloc_sz);
 691
 692   sec_page = (unsigned long) (-1);
 693   reloc_sz = 0;
 694   page_ptr = (unsigned long) (-1);
 695   page_count = 0;
 696   for (i = 0; i < total_relocs; i++)
 697     {
 698       unsigned long rva = reloc_addresses[i] - image_base;
 699       unsigned long this_page = (rva & ~0xfff);
 700       if (this_page != sec_page)
 701         {
 702           while (reloc_sz & 3)
 703             reloc_d[reloc_sz++] = 0;
 704           if (page_ptr != (unsigned long) (-1))
 705             bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
 706           bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
 707           page_ptr = reloc_sz;
 708           reloc_sz += 8;
 709           sec_page = this_page;
 710           page_count = 0;
 711         }
 712       bfd_put_16 (abfd, (rva & 0xfff) + 0x3000, reloc_d + reloc_sz);
 713       reloc_sz += 2;
 714       page_count++;
 715     }
 716   while (reloc_sz & 3)
 717     reloc_d[reloc_sz++] = 0;
 718   if (page_ptr != (unsigned long) (-1))
 719     bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
 720   while (reloc_sz < reloc_s->_raw_size)
 721     reloc_d[reloc_sz++] = 0;
 722 }
 723
 724 /************************************************************************
 725
 726  Given the exiting def_file structure, print out a .DEF file that
 727  corresponds to it.
 728
 729  ************************************************************************/
 730
 731 static void
 732 quoteput (s, f, needs_quotes)
 733      char *s;
 734      FILE * f;
 735      int needs_quotes;
 736 {
 737   char *cp;
 738   for (cp = s; *cp; cp++)
 739     if (*cp == '\'' || *cp == '"' || *cp == '\\' || isspace (*cp) || *cp == ','
 740         || *cp == ';')
 741       needs_quotes = 1;
 742   if (needs_quotes)
 743     {
 744       putc ('"', f);
 745       while (*s)
 746         {
 747           if (*s == '"' || *s == '\\')
 748             putc ('\\', f);
 749           putc (*s, f);
 750           s++;
 751         }
 752       putc ('"', f);
 753     }
 754   else
 755     fputs (s, f);
 756 }
 757
 758 void
 759 pe_dll_generate_def_file (pe_out_def_filename)
 760      char *pe_out_def_filename;
 761 {
 762   int i;
 763   FILE *out = fopen (pe_out_def_filename, "w");
 764   if (out == NULL)
 765     {
 766       /* xgettext:c-format */
 767       einfo (_("%s: Can't open output def file %s\n"),
 768              program_name, pe_out_def_filename);
 769     }
 770
 771   if (pe_def_file)
 772     {
 773       if (pe_def_file->name)
 774         {
 775           if (pe_def_file->is_dll)
 776             fprintf (out, "LIBRARY ");
 777           else
 778             fprintf (out, "NAME ");
 779           quoteput (pe_def_file->name, out, 1);
 780           if (pe_def_file->base_address != (bfd_vma) (-1))
 781             fprintf (out, " BASE=0x%x", pe_def_file->base_address);
 782           fprintf (out, "\n");
 783         }
 784
 785       if (pe_def_file->description)
 786         {
 787           fprintf (out, "DESCRIPTION ");
 788           quoteput (pe_def_file->description, out, 1);
 789           fprintf (out, "\n");
 790         }
 791
 792       if (pe_def_file->version_minor)
 793         fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
 794                  pe_def_file->version_minor);
 795       else
 796         fprintf (out, "VERSION %d\n", pe_def_file->version_major);
 797
 798       if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
 799         fprintf (out, "\n");
 800
 801       if (pe_def_file->stack_commit != -1)
 802         fprintf (out, "STACKSIZE 0x%x,0x%x\n",
 803                  pe_def_file->stack_reserve, pe_def_file->stack_commit);
 804       else if (pe_def_file->stack_reserve != -1)
 805         fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
 806       if (pe_def_file->heap_commit != -1)
 807         fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
 808                  pe_def_file->heap_reserve, pe_def_file->heap_commit);
 809       else if (pe_def_file->heap_reserve != -1)
 810         fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
 811
 812       if (pe_def_file->num_section_defs > 0)
 813         {
 814           fprintf (out, "\nSECTIONS\n\n");
 815           for (i = 0; i < pe_def_file->num_section_defs; i++)
 816             {
 817               fprintf (out, "    ");
 818               quoteput (pe_def_file->section_defs[i].name, out, 0);
 819               if (pe_def_file->section_defs[i].class)
 820                 {
 821                   fprintf (out, " CLASS ");
 822                   quoteput (pe_def_file->section_defs[i].class, out, 0);
 823                 }
 824               if (pe_def_file->section_defs[i].flag_read)
 825                 fprintf (out, " READ");
 826               if (pe_def_file->section_defs[i].flag_write)
 827                 fprintf (out, " WRITE");
 828               if (pe_def_file->section_defs[i].flag_execute)
 829                 fprintf (out, " EXECUTE");
 830               if (pe_def_file->section_defs[i].flag_shared)
 831                 fprintf (out, " SHARED");
 832               fprintf (out, "\n");
 833             }
 834         }
 835
 836       if (pe_def_file->num_exports > 0)
 837         {
 838           fprintf (out, "\nEXPORTS\n\n");
 839           for (i = 0; i < pe_def_file->num_exports; i++)
 840             {
 841               def_file_export *e = pe_def_file->exports + i;
 842               fprintf (out, "    ");
 843               quoteput (e->name, out, 0);
 844               if (e->internal_name && strcmp (e->internal_name, e->name))
 845                 {
 846                   fprintf (out, " = ");
 847                   quoteput (e->internal_name, out, 0);
 848                 }
 849               if (e->ordinal != -1)
 850                 fprintf (out, " @%d", e->ordinal);
 851               if (e->flag_private)
 852                 fprintf (out, " PRIVATE");
 853               if (e->flag_constant)
 854                 fprintf (out, " CONSTANT");
 855               if (e->flag_noname)
 856                 fprintf (out, " NONAME");
 857               if (e->flag_data)
 858                 fprintf (out, " DATA");
 859
 860               fprintf (out, "\n");
 861             }
 862         }
 863
 864       if (pe_def_file->num_imports > 0)
 865         {
 866           fprintf (out, "\nIMPORTS\n\n");
 867           for (i = 0; i < pe_def_file->num_imports; i++)
 868             {
 869               def_file_import *im = pe_def_file->imports + i;
 870               fprintf (out, "    ");
 871               if (im->internal_name
 872                   && (!im->name || strcmp (im->internal_name, im->name)))
 873                 {
 874                   quoteput (im->internal_name, out, 0);
 875                   fprintf (out, " = ");
 876                 }
 877               quoteput (im->module->name, out, 0);
 878               fprintf (out, ".");
 879               if (im->name)
 880                 quoteput (im->name, out, 0);
 881               else
 882                 fprintf (out, "%d", im->ordinal);
 883               fprintf (out, "\n");
 884             }
 885         }
 886     }
 887   else
 888     fprintf (out, _("; no contents available\n"));
 889
 890   if (fclose (out) == EOF)
 891     {
 892       /* xgettext:c-format */
 893       einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
 894     }
 895 }
 896
 897 /************************************************************************
 898
 899  These are the main functions, called from the emulation.  The first
 900  is called after the bfds are read, so we can guess at how much space
 901  we need.  The second is called after everything is placed, so we
 902  can put the right values in place.
 903
 904  ************************************************************************/
 905
 906 void
 907 pe_dll_build_sections (abfd, info)
 908      bfd *abfd;
 909      struct bfd_link_info *info;
 910 {
 911   process_def_file (abfd, info);
 912
 913   generate_edata (abfd, info);
 914   build_filler_bfd ();
 915 }
 916
 917 void
 918 pe_dll_fill_sections (abfd, info)
 919      bfd *abfd;
 920      struct bfd_link_info *info;
 921 {
 922   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
 923
 924   generate_reloc (abfd, info);
 925   if (reloc_sz > 0)
 926     {
 927       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
 928
 929       /* Resize the sections.  */
 930       lang_size_sections (stat_ptr->head, abs_output_section,
 931                           &stat_ptr->head, 0, (bfd_vma) 0, false);
 932
 933       /* Redo special stuff.  */
 934       ldemul_after_allocation ();
 935
 936       /* Do the assignments again.  */
 937       lang_do_assignments (stat_ptr->head,
 938                            abs_output_section,
 939                            (fill_type) 0, (bfd_vma) 0);
 940     }
 941
 942   fill_edata (abfd, info);
 943
 944   pe_data (abfd)->dll = 1;
 945
 946   edata_s->contents = edata_d;
 947   reloc_s->contents = reloc_d;
 948 }