binutils/rescoff.c

   1 /* rescoff.c -- read and write resources in Windows COFF files.
   2    Copyright (C) 1997-2024 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support.
   4    Rewritten by Kai Tietz, Onevision.
   5
   6    This file is part of GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* This file contains function that read and write Windows resources
  24    in COFF files.  */
  25
  26 #include "sysdep.h"
  27 #include "bfd.h"
  28 #include "bucomm.h"
  29 #include "libiberty.h"
  30 #include "windres.h"
  31
  32 #include <assert.h>
  33
  34 /* In order to use the address of a resource data entry, we need to
  35    get the image base of the file.  Right now we extract it from
  36    internal BFD information.  FIXME.  */
  37
  38 #include "coff/internal.h"
  39 #include "libcoff.h"
  40
  41 /* Information we extract from the file.  */
  42
  43 struct coff_file_info
  44 {
  45   /* File name.  */
  46   const char *filename;
  47   /* Data read from the file.  */
  48   const bfd_byte *data;
  49   /* End of data read from file.  */
  50   const bfd_byte *data_end;
  51   /* Address of the resource section minus the image base of the file.  */
  52   rc_uint_type secaddr;
  53 };
  54
  55 /* A resource directory table in a COFF file.  */
  56
  57 struct __attribute__ ((__packed__)) extern_res_directory
  58 {
  59   /* Characteristics.  */
  60   bfd_byte characteristics[4];
  61   /* Time stamp.  */
  62   bfd_byte time[4];
  63   /* Major version number.  */
  64   bfd_byte major[2];
  65   /* Minor version number.  */
  66   bfd_byte minor[2];
  67   /* Number of named directory entries.  */
  68   bfd_byte name_count[2];
  69   /* Number of directory entries with IDs.  */
  70   bfd_byte id_count[2];
  71 };
  72
  73 /* A resource directory entry in a COFF file.  */
  74
  75 struct extern_res_entry
  76 {
  77   /* Name or ID.  */
  78   bfd_byte name[4];
  79   /* Address of resource entry or subdirectory.  */
  80   bfd_byte rva[4];
  81 };
  82
  83 /* A resource data entry in a COFF file.  */
  84
  85 struct extern_res_data
  86 {
  87   /* Address of resource data.  This is apparently a file relative
  88      address, rather than a section offset.  */
  89   bfd_byte rva[4];
  90   /* Size of resource data.  */
  91   bfd_byte size[4];
  92   /* Code page.  */
  93   bfd_byte codepage[4];
  94   /* Reserved.  */
  95   bfd_byte reserved[4];
  96 };
  97
  98 /* Local functions.  */
  99
 100 static void overrun (const struct coff_file_info *, const char *);
 101 static rc_res_directory *read_coff_res_dir (windres_bfd *, const bfd_byte *,
 102                                             const struct coff_file_info *,
 103                                             const rc_res_id *, int);
 104 static rc_res_resource *read_coff_data_entry (windres_bfd *, const bfd_byte *,
 105                                               const struct coff_file_info *,
 106                                               const rc_res_id *);
 107 \f
 108 /* Read the resources in a COFF file.  */
 109
 110 rc_res_directory *
 111 read_coff_rsrc (const char *filename, const char *target)
 112 {
 113   rc_res_directory *ret;
 114   bfd *abfd;
 115   windres_bfd wrbfd;
 116   char **matching;
 117   asection *sec;
 118   bfd_size_type size;
 119   bfd_byte *data;
 120   struct coff_file_info flaginfo;
 121
 122   if (filename == NULL)
 123     fatal (_("filename required for COFF input"));
 124
 125   abfd = bfd_openr (filename, target);
 126   if (abfd == NULL)
 127     bfd_fatal (filename);
 128
 129   if (! bfd_check_format_matches (abfd, bfd_object, &matching))
 130     {
 131       bfd_nonfatal (bfd_get_filename (abfd));
 132       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 133         list_matching_formats (matching);
 134       xexit (1);
 135     }
 136
 137   sec = bfd_get_section_by_name (abfd, ".rsrc");
 138   if (sec == NULL)
 139     {
 140       fatal (_("%s: no resource section"), filename);
 141     }
 142
 143   set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD);
 144   size = bfd_section_size (sec);
 145   /* PR 17512: file: 1b25ba5d
 146      The call to get_file_size here may be expensive
 147      but there is no other way to determine if the section size
 148      is reasonable.  */
 149   if (size > (bfd_size_type) get_file_size (filename))
 150     fatal (_("%s: .rsrc section is bigger than the file!"), filename);
 151
 152   data = (bfd_byte *) res_alloc (size);
 153   get_windres_bfd_content (&wrbfd, data, 0, size);
 154
 155   flaginfo.filename = filename;
 156   flaginfo.data = data;
 157   flaginfo.data_end = data + size;
 158   flaginfo.secaddr = (bfd_section_vma (sec)
 159                       - pe_data (abfd)->pe_opthdr.ImageBase);
 160
 161   /* Now just read in the top level resource directory.  Note that we
 162      don't free data, since we create resource entries that point into
 163      it.  If we ever want to free up the resource information we read,
 164      this will have to be cleaned up.  */
 165
 166   ret = read_coff_res_dir (&wrbfd, data, &flaginfo, (const rc_res_id *) NULL, 0);
 167
 168   bfd_close (abfd);
 169
 170   return ret;
 171 }
 172
 173 /* Give an error if we are out of bounds.  */
 174
 175 static void
 176 overrun (const struct coff_file_info *flaginfo, const char *msg)
 177 {
 178   fatal (_("%s: %s: address out of bounds"), flaginfo->filename, msg);
 179 }
 180
 181 /* Read a resource directory.  */
 182
 183 static rc_res_directory *
 184 read_coff_res_dir (windres_bfd *wrbfd, const bfd_byte *data,
 185                    const struct coff_file_info *flaginfo,
 186                    const rc_res_id *type, int level)
 187 {
 188   const struct extern_res_directory *erd;
 189   rc_res_directory *rd;
 190   int name_count, id_count, i;
 191   rc_res_entry **pp;
 192   const struct extern_res_entry *ere;
 193
 194   /* PR 17512: file: 09d80f53.
 195      Whilst in theory resources can nest to any level, in practice
 196      Microsoft only defines 3 levels.  Corrupt files however might
 197      claim to use more.  */
 198   if (level > 4)
 199     overrun (flaginfo, _("Resources nest too deep"));
 200
 201   if ((size_t) (flaginfo->data_end - data) < sizeof (struct extern_res_directory))
 202     overrun (flaginfo, _("directory"));
 203
 204   erd = (const struct extern_res_directory *) data;
 205
 206   rd = (rc_res_directory *) res_alloc (sizeof (rc_res_directory));
 207   rd->characteristics = windres_get_32 (wrbfd, erd->characteristics, 4);
 208   rd->time = windres_get_32 (wrbfd, erd->time, 4);
 209   rd->major = windres_get_16 (wrbfd, erd->major, 2);
 210   rd->minor = windres_get_16 (wrbfd, erd->minor, 2);
 211   rd->entries = NULL;
 212
 213   name_count = windres_get_16 (wrbfd, erd->name_count, 2);
 214   id_count = windres_get_16 (wrbfd, erd->id_count, 2);
 215
 216   pp = &rd->entries;
 217
 218   /* The resource directory entries immediately follow the directory
 219      table.  */
 220   ere = (const struct extern_res_entry *) (erd + 1);
 221
 222   for (i = 0; i < name_count; i++, ere++)
 223     {
 224       rc_uint_type name, rva;
 225       rc_res_entry *re;
 226       const bfd_byte *ers;
 227       int length, j;
 228
 229       if ((const bfd_byte *) ere >= flaginfo->data_end)
 230         overrun (flaginfo, _("named directory entry"));
 231
 232       name = windres_get_32 (wrbfd, ere->name, 4);
 233       rva = windres_get_32 (wrbfd, ere->rva, 4);
 234
 235       /* For some reason the high bit in NAME is set.  */
 236       name &=~ 0x80000000;
 237
 238       if (name > (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 239         overrun (flaginfo, _("directory entry name"));
 240
 241       ers = flaginfo->data + name;
 242
 243       re = (rc_res_entry *) res_alloc (sizeof *re);
 244       re->next = NULL;
 245       re->id.named = 1;
 246       length = windres_get_16 (wrbfd, ers, 2);
 247       re->id.u.n.length = length;
 248       re->id.u.n.name = (unichar *) res_alloc (length * sizeof (unichar));
 249       for (j = 0; j < length; j++)
 250         {
 251           /* PR 17512: file: 05dc4a16.  */
 252           if (length < 0 || ers >= flaginfo->data_end || ers + j * 2 + 4 >= flaginfo->data_end)
 253             overrun (flaginfo, _("resource name"));
 254           re->id.u.n.name[j] = windres_get_16 (wrbfd, ers + j * 2 + 2, 2);
 255         }
 256
 257       if (level == 0)
 258         type = &re->id;
 259
 260       if ((rva & 0x80000000) != 0)
 261         {
 262           rva &=~ 0x80000000;
 263           if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 264             overrun (flaginfo, _("named subdirectory"));
 265           re->subdir = 1;
 266           re->u.dir = read_coff_res_dir (wrbfd, flaginfo->data + rva, flaginfo, type,
 267                                          level + 1);
 268         }
 269       else
 270         {
 271           if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 272             overrun (flaginfo, _("named resource"));
 273           re->subdir = 0;
 274           re->u.res = read_coff_data_entry (wrbfd, flaginfo->data + rva, flaginfo, type);
 275         }
 276
 277       *pp = re;
 278       pp = &re->next;
 279     }
 280
 281   for (i = 0; i < id_count; i++, ere++)
 282     {
 283       unsigned long name, rva;
 284       rc_res_entry *re;
 285
 286       if ((const bfd_byte *) ere >= flaginfo->data_end)
 287         overrun (flaginfo, _("ID directory entry"));
 288
 289       name = windres_get_32 (wrbfd, ere->name, 4);
 290       rva = windres_get_32 (wrbfd, ere->rva, 4);
 291
 292       re = (rc_res_entry *) res_alloc (sizeof *re);
 293       re->next = NULL;
 294       re->id.named = 0;
 295       re->id.u.id = name;
 296
 297       if (level == 0)
 298         type = &re->id;
 299
 300       if ((rva & 0x80000000) != 0)
 301         {
 302           rva &=~ 0x80000000;
 303           if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 304             overrun (flaginfo, _("ID subdirectory"));
 305           re->subdir = 1;
 306           re->u.dir = read_coff_res_dir (wrbfd, flaginfo->data + rva, flaginfo, type,
 307                                          level + 1);
 308         }
 309       else
 310         {
 311           if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 312             overrun (flaginfo, _("ID resource"));
 313           re->subdir = 0;
 314           re->u.res = read_coff_data_entry (wrbfd, flaginfo->data + rva, flaginfo, type);
 315         }
 316
 317       *pp = re;
 318       pp = &re->next;
 319     }
 320
 321   return rd;
 322 }
 323
 324 /* Read a resource data entry.  */
 325
 326 static rc_res_resource *
 327 read_coff_data_entry (windres_bfd *wrbfd, const bfd_byte *data,
 328                       const struct coff_file_info *flaginfo,
 329                       const rc_res_id *type)
 330 {
 331   const struct extern_res_data *erd;
 332   rc_res_resource *r;
 333   rc_uint_type size, rva;
 334   const bfd_byte *resdata;
 335
 336   if (type == NULL)
 337     fatal (_("resource type unknown"));
 338
 339   if ((size_t) (flaginfo->data_end - data) < sizeof (struct extern_res_data))
 340     overrun (flaginfo, _("data entry"));
 341
 342   erd = (const struct extern_res_data *) data;
 343
 344   size = windres_get_32 (wrbfd, erd->size, 4);
 345   rva = windres_get_32 (wrbfd, erd->rva, 4);
 346   if (rva < flaginfo->secaddr
 347       || rva - flaginfo->secaddr >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 348     overrun (flaginfo, _("resource data"));
 349
 350   resdata = flaginfo->data + (rva - flaginfo->secaddr);
 351
 352   if (size > (rc_uint_type) (flaginfo->data_end - resdata))
 353     overrun (flaginfo, _("resource data size"));
 354
 355   r = bin_to_res (wrbfd, *type, resdata, size);
 356
 357   memset (&r->res_info, 0, sizeof (rc_res_res_info));
 358   r->coff_info.codepage = windres_get_32 (wrbfd, erd->codepage, 4);
 359   r->coff_info.reserved = windres_get_32 (wrbfd, erd->reserved, 4);
 360
 361   return r;
 362 }
 363 \f
 364 /* This structure is used to build a list of bindata structures.  */
 365
 366 struct bindata_build
 367 {
 368   /* The data.  */
 369   bindata *d;
 370   /* The last structure we have added to the list.  */
 371   bindata *last;
 372   /* The size of the list as a whole.  */
 373   unsigned long length;
 374 };
 375
 376 struct coff_res_data_build
 377 {
 378   /* The data.  */
 379   coff_res_data *d;
 380   /* The last structure we have added to the list.  */
 381   coff_res_data *last;
 382   /* The size of the list as a whole.  */
 383   unsigned long length;
 384 };
 385
 386 /* This structure keeps track of information as we build the directory
 387    tree.  */
 388
 389 struct coff_write_info
 390 {
 391   /* These fields are based on the BFD.  */
 392   /* The BFD itself.  */
 393   windres_bfd *wrbfd;
 394   /* Pointer to section symbol used to build RVA relocs.  */
 395   asymbol **sympp;
 396
 397   /* These fields are computed initially, and then not changed.  */
 398   /* Length of directory tables and entries.  */
 399   unsigned long dirsize;
 400   /* Length of directory entry strings.  */
 401   unsigned long dirstrsize;
 402   /* Length of resource data entries.  */
 403   unsigned long dataentsize;
 404
 405   /* These fields are updated as we add data.  */
 406   /* Directory tables and entries.  */
 407   struct bindata_build dirs;
 408   /* Directory entry strings.  */
 409   struct bindata_build dirstrs;
 410   /* Resource data entries.  */
 411   struct bindata_build dataents;
 412   /* Actual resource data.  */
 413   struct coff_res_data_build resources;
 414   /* Relocations.  */
 415   arelent **relocs;
 416   /* Number of relocations.  */
 417   unsigned int reloc_count;
 418 };
 419
 420 static void coff_bin_sizes (const rc_res_directory *, struct coff_write_info *);
 421 static bfd_byte *coff_alloc (struct bindata_build *, rc_uint_type);
 422 static void coff_to_bin
 423   (const rc_res_directory *, struct coff_write_info *);
 424 static void coff_res_to_bin
 425   (const rc_res_resource *, struct coff_write_info *);
 426
 427 /* Write resources to a COFF file.  RESOURCES should already be
 428    sorted.
 429
 430    Right now we always create a new file.  Someday we should also
 431    offer the ability to merge resources into an existing file.  This
 432    would require doing the basic work of objcopy, just modifying or
 433    adding the .rsrc section.  */
 434
 435 void
 436 write_coff_file (const char *filename, const char *target,
 437                  const rc_res_directory *resources)
 438 {
 439   bfd *abfd;
 440   asection *sec;
 441   struct coff_write_info cwi;
 442   windres_bfd wrbfd;
 443   bindata *d;
 444   coff_res_data *rd;
 445   unsigned long length, offset;
 446
 447   if (filename == NULL)
 448     fatal (_("filename required for COFF output"));
 449
 450   abfd = bfd_openw (filename, target);
 451   if (abfd == NULL)
 452     bfd_fatal (filename);
 453
 454   if (! bfd_set_format (abfd, bfd_object))
 455     bfd_fatal ("bfd_set_format");
 456
 457 #if defined DLLTOOL_SH
 458   if (! bfd_set_arch_mach (abfd, bfd_arch_sh, 0))
 459     bfd_fatal ("bfd_set_arch_mach(sh)");
 460 #elif defined DLLTOOL_MIPS
 461   if (! bfd_set_arch_mach (abfd, bfd_arch_mips, 0))
 462     bfd_fatal ("bfd_set_arch_mach(mips)");
 463 #elif defined DLLTOOL_ARM
 464   if (! bfd_set_arch_mach (abfd, bfd_arch_arm, 0))
 465     bfd_fatal ("bfd_set_arch_mach(arm)");
 466 #elif defined DLLTOOL_AARCH64
 467   if (! bfd_set_arch_mach (abfd, bfd_arch_aarch64, 0))
 468     bfd_fatal ("bfd_set_arch_mach(aarch64)");
 469 #else
 470   /* FIXME: This is obviously i386 specific.  */
 471   if (! bfd_set_arch_mach (abfd, bfd_arch_i386, 0))
 472     bfd_fatal ("bfd_set_arch_mach(i386)");
 473 #endif
 474
 475   if (! bfd_set_file_flags (abfd, HAS_SYMS | HAS_RELOC))
 476     bfd_fatal ("bfd_set_file_flags");
 477
 478   sec = bfd_make_section_with_flags (abfd, ".rsrc",
 479                                      (SEC_HAS_CONTENTS | SEC_ALLOC
 480                                       | SEC_LOAD | SEC_DATA | SEC_READONLY));
 481   if (sec == NULL)
 482     bfd_fatal ("bfd_make_section");
 483
 484   if (! bfd_set_symtab (abfd, &sec->symbol, 1))
 485     bfd_fatal ("bfd_set_symtab");
 486
 487   /* Requiring this is probably a bug in BFD.  */
 488   sec->output_section = sec;
 489
 490   /* The order of data in the .rsrc section is
 491        resource directory tables and entries
 492        resource directory strings
 493        resource data entries
 494        actual resource data
 495
 496      We build these different types of data in different lists.  */
 497
 498   set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD);
 499
 500   cwi.wrbfd = &wrbfd;
 501   cwi.sympp = &sec->symbol;
 502   cwi.dirsize = 0;
 503   cwi.dirstrsize = 0;
 504   cwi.dataentsize = 0;
 505   cwi.dirs.d = NULL;
 506   cwi.dirs.last = NULL;
 507   cwi.dirs.length = 0;
 508   cwi.dirstrs.d = NULL;
 509   cwi.dirstrs.last = NULL;
 510   cwi.dirstrs.length = 0;
 511   cwi.dataents.d = NULL;
 512   cwi.dataents.last = NULL;
 513   cwi.dataents.length = 0;
 514   cwi.resources.d = NULL;
 515   cwi.resources.last = NULL;
 516   cwi.resources.length = 0;
 517   cwi.relocs = NULL;
 518   cwi.reloc_count = 0;
 519
 520   /* Work out the sizes of the resource directory entries, so that we
 521      know the various offsets we will need.  */
 522   coff_bin_sizes (resources, &cwi);
 523
 524   /* Force the directory strings to be 64 bit aligned.  Every other
 525      structure is 64 bit aligned anyhow.  */
 526   cwi.dirstrsize = (cwi.dirstrsize + 7) & ~7;
 527
 528   /* Actually convert the resources to binary.  */
 529   coff_to_bin (resources, &cwi);
 530
 531   /* Add another few bytes to the directory strings if needed for
 532      alignment.  */
 533   if ((cwi.dirstrs.length & 7) != 0)
 534     {
 535       rc_uint_type pad = 8 - (cwi.dirstrs.length & 7);
 536       bfd_byte *ex;
 537
 538       ex = coff_alloc (& cwi.dirstrs, pad);
 539       memset (ex, 0, pad);
 540     }
 541
 542   /* Make sure that the data we built came out to the same size as we
 543      calculated initially.  */
 544   assert (cwi.dirs.length == cwi.dirsize);
 545   assert (cwi.dirstrs.length == cwi.dirstrsize);
 546   assert (cwi.dataents.length == cwi.dataentsize);
 547
 548   length = (cwi.dirsize
 549             + cwi.dirstrsize
 550             + cwi.dataentsize
 551             + cwi.resources.length);
 552
 553   if (!bfd_set_section_size (sec, length))
 554     bfd_fatal ("bfd_set_section_size");
 555
 556   bfd_set_reloc (abfd, sec, cwi.relocs, cwi.reloc_count);
 557
 558   offset = 0;
 559   for (d = cwi.dirs.d; d != NULL; d = d->next)
 560     {
 561       if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
 562         bfd_fatal ("bfd_set_section_contents");
 563       offset += d->length;
 564     }
 565   for (d = cwi.dirstrs.d; d != NULL; d = d->next)
 566     {
 567       set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
 568       offset += d->length;
 569     }
 570   for (d = cwi.dataents.d; d != NULL; d = d->next)
 571     {
 572       set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
 573       offset += d->length;
 574     }
 575   for (rd = cwi.resources.d; rd != NULL; rd = rd->next)
 576     {
 577       res_to_bin (cwi.wrbfd, (rc_uint_type) offset, rd->res);
 578       offset += rd->length;
 579     }
 580
 581   assert (offset == length);
 582
 583   if (! bfd_close (abfd))
 584     bfd_fatal ("bfd_close");
 585
 586   /* We allocated the relocs array using malloc.  */
 587   free (cwi.relocs);
 588 }
 589
 590 /* Work out the sizes of the various fixed size resource directory
 591    entries.  This updates fields in CWI.  */
 592
 593 static void
 594 coff_bin_sizes (const rc_res_directory *resdir,
 595                 struct coff_write_info *cwi)
 596 {
 597   const rc_res_entry *re;
 598
 599   cwi->dirsize += sizeof (struct extern_res_directory);
 600
 601   for (re = resdir->entries; re != NULL; re = re->next)
 602     {
 603       cwi->dirsize += sizeof (struct extern_res_entry);
 604
 605       if (re->id.named)
 606         cwi->dirstrsize += re->id.u.n.length * 2 + 2;
 607
 608       if (re->subdir)
 609         coff_bin_sizes (re->u.dir, cwi);
 610       else
 611         cwi->dataentsize += sizeof (struct extern_res_data);
 612     }
 613 }
 614
 615 /* Allocate data for a particular list.  */
 616
 617 static bfd_byte *
 618 coff_alloc (struct bindata_build *bb, rc_uint_type size)
 619 {
 620   bindata *d;
 621
 622   d = (bindata *) reswr_alloc (sizeof (bindata));
 623
 624   d->next = NULL;
 625   d->data = (bfd_byte *) reswr_alloc (size);
 626   d->length = size;
 627
 628   if (bb->d == NULL)
 629     bb->d = d;
 630   else
 631     bb->last->next = d;
 632   bb->last = d;
 633   bb->length += size;
 634
 635   return d->data;
 636 }
 637
 638 /* Convert the resource directory RESDIR to binary.  */
 639
 640 static void
 641 coff_to_bin (const rc_res_directory *resdir, struct coff_write_info *cwi)
 642 {
 643   struct extern_res_directory *erd;
 644   int ci, cn;
 645   const rc_res_entry *e;
 646   struct extern_res_entry *ere;
 647
 648   /* Write out the directory table.  */
 649
 650   erd = ((struct extern_res_directory *)
 651          coff_alloc (&cwi->dirs, sizeof (*erd)));
 652
 653   windres_put_32 (cwi->wrbfd, erd->characteristics, resdir->characteristics);
 654   windres_put_32 (cwi->wrbfd, erd->time, resdir->time);
 655   windres_put_16 (cwi->wrbfd, erd->major, resdir->major);
 656   windres_put_16 (cwi->wrbfd, erd->minor, resdir->minor);
 657
 658   ci = 0;
 659   cn = 0;
 660   for (e = resdir->entries; e != NULL; e = e->next)
 661     {
 662       if (e->id.named)
 663         ++cn;
 664       else
 665         ++ci;
 666     }
 667
 668   windres_put_16 (cwi->wrbfd, erd->name_count, cn);
 669   windres_put_16 (cwi->wrbfd, erd->id_count, ci);
 670
 671   /* Write out the data entries.  Note that we allocate space for all
 672      the entries before writing them out.  That permits a recursive
 673      call to work correctly when writing out subdirectories.  */
 674
 675   ere = ((struct extern_res_entry *)
 676          coff_alloc (&cwi->dirs, (ci + cn) * sizeof (*ere)));
 677   for (e = resdir->entries; e != NULL; e = e->next, ere++)
 678     {
 679       if (! e->id.named)
 680         windres_put_32 (cwi->wrbfd, ere->name, e->id.u.id);
 681       else
 682         {
 683           bfd_byte *str;
 684           rc_uint_type i;
 685
 686           /* For some reason existing files seem to have the high bit
 687              set on the address of the name, although that is not
 688              documented.  */
 689           windres_put_32 (cwi->wrbfd, ere->name,
 690                      0x80000000 | (cwi->dirsize + cwi->dirstrs.length));
 691
 692           str = coff_alloc (&cwi->dirstrs, e->id.u.n.length * 2 + 2);
 693           windres_put_16 (cwi->wrbfd, str, e->id.u.n.length);
 694           for (i = 0; i < e->id.u.n.length; i++)
 695             windres_put_16 (cwi->wrbfd, str + (i + 1) * sizeof (unichar), e->id.u.n.name[i]);
 696         }
 697
 698       if (e->subdir)
 699         {
 700           windres_put_32 (cwi->wrbfd, ere->rva, 0x80000000 | cwi->dirs.length);
 701           coff_to_bin (e->u.dir, cwi);
 702         }
 703       else
 704         {
 705           windres_put_32 (cwi->wrbfd, ere->rva,
 706                      cwi->dirsize + cwi->dirstrsize + cwi->dataents.length);
 707
 708           coff_res_to_bin (e->u.res, cwi);
 709         }
 710     }
 711 }
 712
 713 /* Convert the resource RES to binary.  */
 714
 715 static void
 716 coff_res_to_bin (const rc_res_resource *res, struct coff_write_info *cwi)
 717 {
 718   arelent *r;
 719   struct extern_res_data *erd;
 720   coff_res_data *d;
 721
 722   /* For some reason, although every other address is a section
 723      offset, the address of the resource data itself is an RVA.  That
 724      means that we need to generate a relocation for it.  We allocate
 725      the relocs array using malloc so that we can use realloc.  FIXME:
 726      This relocation handling is correct for the i386, but probably
 727      not for any other target.  */
 728
 729   r = (arelent *) reswr_alloc (sizeof (arelent));
 730   r->sym_ptr_ptr = cwi->sympp;
 731   r->address = cwi->dirsize + cwi->dirstrsize + cwi->dataents.length;
 732   r->addend = 0;
 733   r->howto = bfd_reloc_type_lookup (WR_BFD (cwi->wrbfd), BFD_RELOC_RVA);
 734   if (r->howto == NULL)
 735     bfd_fatal (_("can't get BFD_RELOC_RVA relocation type"));
 736
 737   cwi->relocs = xrealloc (cwi->relocs,
 738                           (cwi->reloc_count + 2) * sizeof (arelent *));
 739   cwi->relocs[cwi->reloc_count] = r;
 740   cwi->relocs[cwi->reloc_count + 1] = NULL;
 741   ++cwi->reloc_count;
 742
 743   erd = (struct extern_res_data *) coff_alloc (&cwi->dataents, sizeof (*erd));
 744
 745   windres_put_32 (cwi->wrbfd, erd->rva,
 746              (cwi->dirsize
 747               + cwi->dirstrsize
 748               + cwi->dataentsize
 749               + cwi->resources.length));
 750   windres_put_32 (cwi->wrbfd, erd->codepage, res->coff_info.codepage);
 751   windres_put_32 (cwi->wrbfd, erd->reserved, res->coff_info.reserved);
 752
 753   d = (coff_res_data *) reswr_alloc (sizeof (coff_res_data));
 754   d->length = res_to_bin (NULL, (rc_uint_type) 0, res);
 755   d->res = res;
 756   d->next = NULL;
 757
 758   if (cwi->resources.d == NULL)
 759     cwi->resources.d = d;
 760   else
 761     cwi->resources.last->next = d;
 762
 763   cwi->resources.last = d;
 764   cwi->resources.length += (d->length + 7) & ~7;
 765
 766   windres_put_32 (cwi->wrbfd, erd->size, d->length);
 767
 768   /* Force the next resource to have 64 bit alignment.  */
 769   d->length = (d->length + 7) & ~7;
 770 }