binutils/rescoff.c

   1 /* rescoff.c -- read and write resources in Windows COFF files.
   2    Copyright (C) 1997-2014 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 (abfd, sec);
 145   data = (bfd_byte *) res_alloc (size);
 146
 147   get_windres_bfd_content (&wrbfd, data, 0, size);
 148
 149   flaginfo.filename = filename;
 150   flaginfo.data = data;
 151   flaginfo.data_end = data + size;
 152   flaginfo.secaddr = (bfd_get_section_vma (abfd, sec)
 153                    - pe_data (abfd)->pe_opthdr.ImageBase);
 154
 155   /* Now just read in the top level resource directory.  Note that we
 156      don't free data, since we create resource entries that point into
 157      it.  If we ever want to free up the resource information we read,
 158      this will have to be cleaned up.  */
 159
 160   ret = read_coff_res_dir (&wrbfd, data, &flaginfo, (const rc_res_id *) NULL, 0);
 161
 162   bfd_close (abfd);
 163
 164   return ret;
 165 }
 166
 167 /* Give an error if we are out of bounds.  */
 168
 169 static void
 170 overrun (const struct coff_file_info *flaginfo, const char *msg)
 171 {
 172   fatal (_("%s: %s: address out of bounds"), flaginfo->filename, msg);
 173 }
 174
 175 /* Read a resource directory.  */
 176
 177 static rc_res_directory *
 178 read_coff_res_dir (windres_bfd *wrbfd, const bfd_byte *data,
 179                    const struct coff_file_info *flaginfo,
 180                    const rc_res_id *type, int level)
 181 {
 182   const struct extern_res_directory *erd;
 183   rc_res_directory *rd;
 184   int name_count, id_count, i;
 185   rc_res_entry **pp;
 186   const struct extern_res_entry *ere;
 187
 188   if ((size_t) (flaginfo->data_end - data) < sizeof (struct extern_res_directory))
 189     overrun (flaginfo, _("directory"));
 190
 191   erd = (const struct extern_res_directory *) data;
 192
 193   rd = (rc_res_directory *) res_alloc (sizeof (rc_res_directory));
 194   rd->characteristics = windres_get_32 (wrbfd, erd->characteristics, 4);
 195   rd->time = windres_get_32 (wrbfd, erd->time, 4);
 196   rd->major = windres_get_16 (wrbfd, erd->major, 2);
 197   rd->minor = windres_get_16 (wrbfd, erd->minor, 2);
 198   rd->entries = NULL;
 199
 200   name_count = windres_get_16 (wrbfd, erd->name_count, 2);
 201   id_count = windres_get_16 (wrbfd, erd->id_count, 2);
 202
 203   pp = &rd->entries;
 204
 205   /* The resource directory entries immediately follow the directory
 206      table.  */
 207   ere = (const struct extern_res_entry *) (erd + 1);
 208
 209   for (i = 0; i < name_count; i++, ere++)
 210     {
 211       rc_uint_type name, rva;
 212       rc_res_entry *re;
 213       const bfd_byte *ers;
 214       int length, j;
 215
 216       if ((const bfd_byte *) ere >= flaginfo->data_end)
 217         overrun (flaginfo, _("named directory entry"));
 218
 219       name = windres_get_32 (wrbfd, ere->name, 4);
 220       rva = windres_get_32 (wrbfd, ere->rva, 4);
 221
 222       /* For some reason the high bit in NAME is set.  */
 223       name &=~ 0x80000000;
 224
 225       if (name > (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 226         overrun (flaginfo, _("directory entry name"));
 227
 228       ers = flaginfo->data + name;
 229
 230       re = (rc_res_entry *) res_alloc (sizeof *re);
 231       re->next = NULL;
 232       re->id.named = 1;
 233       length = windres_get_16 (wrbfd, ers, 2);
 234       re->id.u.n.length = length;
 235       re->id.u.n.name = (unichar *) res_alloc (length * sizeof (unichar));
 236       for (j = 0; j < length; j++)
 237         re->id.u.n.name[j] = windres_get_16 (wrbfd, ers + j * 2 + 2, 2);
 238
 239       if (level == 0)
 240         type = &re->id;
 241
 242       if ((rva & 0x80000000) != 0)
 243         {
 244           rva &=~ 0x80000000;
 245           if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 246             overrun (flaginfo, _("named subdirectory"));
 247           re->subdir = 1;
 248           re->u.dir = read_coff_res_dir (wrbfd, flaginfo->data + rva, flaginfo, type,
 249                                          level + 1);
 250         }
 251       else
 252         {
 253           if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 254             overrun (flaginfo, _("named resource"));
 255           re->subdir = 0;
 256           re->u.res = read_coff_data_entry (wrbfd, flaginfo->data + rva, flaginfo, type);
 257         }
 258
 259       *pp = re;
 260       pp = &re->next;
 261     }
 262
 263   for (i = 0; i < id_count; i++, ere++)
 264     {
 265       unsigned long name, rva;
 266       rc_res_entry *re;
 267
 268       if ((const bfd_byte *) ere >= flaginfo->data_end)
 269         overrun (flaginfo, _("ID directory entry"));
 270
 271       name = windres_get_32 (wrbfd, ere->name, 4);
 272       rva = windres_get_32 (wrbfd, ere->rva, 4);
 273
 274       re = (rc_res_entry *) res_alloc (sizeof *re);
 275       re->next = NULL;
 276       re->id.named = 0;
 277       re->id.u.id = name;
 278
 279       if (level == 0)
 280         type = &re->id;
 281
 282       if ((rva & 0x80000000) != 0)
 283         {
 284           rva &=~ 0x80000000;
 285           if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 286             overrun (flaginfo, _("ID subdirectory"));
 287           re->subdir = 1;
 288           re->u.dir = read_coff_res_dir (wrbfd, flaginfo->data + rva, flaginfo, type,
 289                                          level + 1);
 290         }
 291       else
 292         {
 293           if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 294             overrun (flaginfo, _("ID resource"));
 295           re->subdir = 0;
 296           re->u.res = read_coff_data_entry (wrbfd, flaginfo->data + rva, flaginfo, type);
 297         }
 298
 299       *pp = re;
 300       pp = &re->next;
 301     }
 302
 303   return rd;
 304 }
 305
 306 /* Read a resource data entry.  */
 307
 308 static rc_res_resource *
 309 read_coff_data_entry (windres_bfd *wrbfd, const bfd_byte *data,
 310                       const struct coff_file_info *flaginfo,
 311                       const rc_res_id *type)
 312 {
 313   const struct extern_res_data *erd;
 314   rc_res_resource *r;
 315   rc_uint_type size, rva;
 316   const bfd_byte *resdata;
 317
 318   if (type == NULL)
 319     fatal (_("resource type unknown"));
 320
 321   if ((size_t) (flaginfo->data_end - data) < sizeof (struct extern_res_data))
 322     overrun (flaginfo, _("data entry"));
 323
 324   erd = (const struct extern_res_data *) data;
 325
 326   size = windres_get_32 (wrbfd, erd->size, 4);
 327   rva = windres_get_32 (wrbfd, erd->rva, 4);
 328   if (rva < flaginfo->secaddr
 329       || rva - flaginfo->secaddr >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
 330     overrun (flaginfo, _("resource data"));
 331
 332   resdata = flaginfo->data + (rva - flaginfo->secaddr);
 333
 334   if (size > (rc_uint_type) (flaginfo->data_end - resdata))
 335     overrun (flaginfo, _("resource data size"));
 336
 337   r = bin_to_res (wrbfd, *type, resdata, size);
 338
 339   memset (&r->res_info, 0, sizeof (rc_res_res_info));
 340   r->coff_info.codepage = windres_get_32 (wrbfd, erd->codepage, 4);
 341   r->coff_info.reserved = windres_get_32 (wrbfd, erd->reserved, 4);
 342
 343   return r;
 344 }
 345 \f
 346 /* This structure is used to build a list of bindata structures.  */
 347
 348 struct bindata_build
 349 {
 350   /* The data.  */
 351   bindata *d;
 352   /* The last structure we have added to the list.  */
 353   bindata *last;
 354   /* The size of the list as a whole.  */
 355   unsigned long length;
 356 };
 357
 358 struct coff_res_data_build
 359 {
 360   /* The data.  */
 361   coff_res_data *d;
 362   /* The last structure we have added to the list.  */
 363   coff_res_data *last;
 364   /* The size of the list as a whole.  */
 365   unsigned long length;
 366 };
 367
 368 /* This structure keeps track of information as we build the directory
 369    tree.  */
 370
 371 struct coff_write_info
 372 {
 373   /* These fields are based on the BFD.  */
 374   /* The BFD itself.  */
 375   windres_bfd *wrbfd;
 376   /* Pointer to section symbol used to build RVA relocs.  */
 377   asymbol **sympp;
 378
 379   /* These fields are computed initially, and then not changed.  */
 380   /* Length of directory tables and entries.  */
 381   unsigned long dirsize;
 382   /* Length of directory entry strings.  */
 383   unsigned long dirstrsize;
 384   /* Length of resource data entries.  */
 385   unsigned long dataentsize;
 386
 387   /* These fields are updated as we add data.  */
 388   /* Directory tables and entries.  */
 389   struct bindata_build dirs;
 390   /* Directory entry strings.  */
 391   struct bindata_build dirstrs;
 392   /* Resource data entries.  */
 393   struct bindata_build dataents;
 394   /* Actual resource data.  */
 395   struct coff_res_data_build resources;
 396   /* Relocations.  */
 397   arelent **relocs;
 398   /* Number of relocations.  */
 399   unsigned int reloc_count;
 400 };
 401
 402 static void coff_bin_sizes (const rc_res_directory *, struct coff_write_info *);
 403 static bfd_byte *coff_alloc (struct bindata_build *, rc_uint_type);
 404 static void coff_to_bin
 405   (const rc_res_directory *, struct coff_write_info *);
 406 static void coff_res_to_bin
 407   (const rc_res_resource *, struct coff_write_info *);
 408
 409 /* Write resources to a COFF file.  RESOURCES should already be
 410    sorted.
 411
 412    Right now we always create a new file.  Someday we should also
 413    offer the ability to merge resources into an existing file.  This
 414    would require doing the basic work of objcopy, just modifying or
 415    adding the .rsrc section.  */
 416
 417 void
 418 write_coff_file (const char *filename, const char *target,
 419                  const rc_res_directory *resources)
 420 {
 421   bfd *abfd;
 422   asection *sec;
 423   struct coff_write_info cwi;
 424   windres_bfd wrbfd;
 425   bindata *d;
 426   coff_res_data *rd;
 427   unsigned long length, offset;
 428
 429   if (filename == NULL)
 430     fatal (_("filename required for COFF output"));
 431
 432   abfd = bfd_openw (filename, target);
 433   if (abfd == NULL)
 434     bfd_fatal (filename);
 435
 436   if (! bfd_set_format (abfd, bfd_object))
 437     bfd_fatal ("bfd_set_format");
 438
 439 #if defined DLLTOOL_SH
 440   if (! bfd_set_arch_mach (abfd, bfd_arch_sh, 0))
 441     bfd_fatal ("bfd_set_arch_mach(sh)");
 442 #elif defined DLLTOOL_MIPS
 443   if (! bfd_set_arch_mach (abfd, bfd_arch_mips, 0))
 444     bfd_fatal ("bfd_set_arch_mach(mips)");
 445 #elif defined DLLTOOL_ARM
 446   if (! bfd_set_arch_mach (abfd, bfd_arch_arm, 0))
 447     bfd_fatal ("bfd_set_arch_mach(arm)");
 448 #else
 449   /* FIXME: This is obviously i386 specific.  */
 450   if (! bfd_set_arch_mach (abfd, bfd_arch_i386, 0))
 451     bfd_fatal ("bfd_set_arch_mach(i386)");
 452 #endif
 453
 454   if (! bfd_set_file_flags (abfd, HAS_SYMS | HAS_RELOC))
 455     bfd_fatal ("bfd_set_file_flags");
 456
 457   sec = bfd_make_section_with_flags (abfd, ".rsrc",
 458                                      (SEC_HAS_CONTENTS | SEC_ALLOC
 459                                       | SEC_LOAD | SEC_DATA));
 460   if (sec == NULL)
 461     bfd_fatal ("bfd_make_section");
 462
 463   if (! bfd_set_symtab (abfd, sec->symbol_ptr_ptr, 1))
 464     bfd_fatal ("bfd_set_symtab");
 465
 466   /* Requiring this is probably a bug in BFD.  */
 467   sec->output_section = sec;
 468
 469   /* The order of data in the .rsrc section is
 470        resource directory tables and entries
 471        resource directory strings
 472        resource data entries
 473        actual resource data
 474
 475      We build these different types of data in different lists.  */
 476
 477   set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD);
 478
 479   cwi.wrbfd = &wrbfd;
 480   cwi.sympp = sec->symbol_ptr_ptr;
 481   cwi.dirsize = 0;
 482   cwi.dirstrsize = 0;
 483   cwi.dataentsize = 0;
 484   cwi.dirs.d = NULL;
 485   cwi.dirs.last = NULL;
 486   cwi.dirs.length = 0;
 487   cwi.dirstrs.d = NULL;
 488   cwi.dirstrs.last = NULL;
 489   cwi.dirstrs.length = 0;
 490   cwi.dataents.d = NULL;
 491   cwi.dataents.last = NULL;
 492   cwi.dataents.length = 0;
 493   cwi.resources.d = NULL;
 494   cwi.resources.last = NULL;
 495   cwi.resources.length = 0;
 496   cwi.relocs = NULL;
 497   cwi.reloc_count = 0;
 498
 499   /* Work out the sizes of the resource directory entries, so that we
 500      know the various offsets we will need.  */
 501   coff_bin_sizes (resources, &cwi);
 502
 503   /* Force the directory strings to be 64 bit aligned.  Every other
 504      structure is 64 bit aligned anyhow.  */
 505   cwi.dirstrsize = (cwi.dirstrsize + 7) & ~7;
 506
 507   /* Actually convert the resources to binary.  */
 508   coff_to_bin (resources, &cwi);
 509
 510   /* Add another few bytes to the directory strings if needed for
 511      alignment.  */
 512   if ((cwi.dirstrs.length & 7) != 0)
 513     {
 514       rc_uint_type pad = 8 - (cwi.dirstrs.length & 7);
 515       bfd_byte *ex;
 516
 517       ex = coff_alloc (& cwi.dirstrs, pad);
 518       memset (ex, 0, pad);
 519     }
 520
 521   /* Make sure that the data we built came out to the same size as we
 522      calculated initially.  */
 523   assert (cwi.dirs.length == cwi.dirsize);
 524   assert (cwi.dirstrs.length == cwi.dirstrsize);
 525   assert (cwi.dataents.length == cwi.dataentsize);
 526
 527   length = (cwi.dirsize
 528             + cwi.dirstrsize
 529             + cwi.dataentsize
 530             + cwi.resources.length);
 531
 532   if (! bfd_set_section_size (abfd, sec, length))
 533     bfd_fatal ("bfd_set_section_size");
 534
 535   bfd_set_reloc (abfd, sec, cwi.relocs, cwi.reloc_count);
 536
 537   offset = 0;
 538   for (d = cwi.dirs.d; d != NULL; d = d->next)
 539     {
 540       if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
 541         bfd_fatal ("bfd_set_section_contents");
 542       offset += d->length;
 543     }
 544   for (d = cwi.dirstrs.d; d != NULL; d = d->next)
 545     {
 546       set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
 547       offset += d->length;
 548     }
 549   for (d = cwi.dataents.d; d != NULL; d = d->next)
 550     {
 551       set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
 552       offset += d->length;
 553     }
 554   for (rd = cwi.resources.d; rd != NULL; rd = rd->next)
 555     {
 556       res_to_bin (cwi.wrbfd, (rc_uint_type) offset, rd->res);
 557       offset += rd->length;
 558     }
 559
 560   assert (offset == length);
 561
 562   if (! bfd_close (abfd))
 563     bfd_fatal ("bfd_close");
 564
 565   /* We allocated the relocs array using malloc.  */
 566   free (cwi.relocs);
 567 }
 568
 569 /* Work out the sizes of the various fixed size resource directory
 570    entries.  This updates fields in CWI.  */
 571
 572 static void
 573 coff_bin_sizes (const rc_res_directory *resdir,
 574                 struct coff_write_info *cwi)
 575 {
 576   const rc_res_entry *re;
 577
 578   cwi->dirsize += sizeof (struct extern_res_directory);
 579
 580   for (re = resdir->entries; re != NULL; re = re->next)
 581     {
 582       cwi->dirsize += sizeof (struct extern_res_entry);
 583
 584       if (re->id.named)
 585         cwi->dirstrsize += re->id.u.n.length * 2 + 2;
 586
 587       if (re->subdir)
 588         coff_bin_sizes (re->u.dir, cwi);
 589       else
 590         cwi->dataentsize += sizeof (struct extern_res_data);
 591     }
 592 }
 593
 594 /* Allocate data for a particular list.  */
 595
 596 static bfd_byte *
 597 coff_alloc (struct bindata_build *bb, rc_uint_type size)
 598 {
 599   bindata *d;
 600
 601   d = (bindata *) reswr_alloc (sizeof (bindata));
 602
 603   d->next = NULL;
 604   d->data = (bfd_byte *) reswr_alloc (size);
 605   d->length = size;
 606
 607   if (bb->d == NULL)
 608     bb->d = d;
 609   else
 610     bb->last->next = d;
 611   bb->last = d;
 612   bb->length += size;
 613
 614   return d->data;
 615 }
 616
 617 /* Convert the resource directory RESDIR to binary.  */
 618
 619 static void
 620 coff_to_bin (const rc_res_directory *resdir, struct coff_write_info *cwi)
 621 {
 622   struct extern_res_directory *erd;
 623   int ci, cn;
 624   const rc_res_entry *e;
 625   struct extern_res_entry *ere;
 626
 627   /* Write out the directory table.  */
 628
 629   erd = ((struct extern_res_directory *)
 630          coff_alloc (&cwi->dirs, sizeof (*erd)));
 631
 632   windres_put_32 (cwi->wrbfd, erd->characteristics, resdir->characteristics);
 633   windres_put_32 (cwi->wrbfd, erd->time, resdir->time);
 634   windres_put_16 (cwi->wrbfd, erd->major, resdir->major);
 635   windres_put_16 (cwi->wrbfd, erd->minor, resdir->minor);
 636
 637   ci = 0;
 638   cn = 0;
 639   for (e = resdir->entries; e != NULL; e = e->next)
 640     {
 641       if (e->id.named)
 642         ++cn;
 643       else
 644         ++ci;
 645     }
 646
 647   windres_put_16 (cwi->wrbfd, erd->name_count, cn);
 648   windres_put_16 (cwi->wrbfd, erd->id_count, ci);
 649
 650   /* Write out the data entries.  Note that we allocate space for all
 651      the entries before writing them out.  That permits a recursive
 652      call to work correctly when writing out subdirectories.  */
 653
 654   ere = ((struct extern_res_entry *)
 655          coff_alloc (&cwi->dirs, (ci + cn) * sizeof (*ere)));
 656   for (e = resdir->entries; e != NULL; e = e->next, ere++)
 657     {
 658       if (! e->id.named)
 659         windres_put_32 (cwi->wrbfd, ere->name, e->id.u.id);
 660       else
 661         {
 662           bfd_byte *str;
 663           rc_uint_type i;
 664
 665           /* For some reason existing files seem to have the high bit
 666              set on the address of the name, although that is not
 667              documented.  */
 668           windres_put_32 (cwi->wrbfd, ere->name,
 669                      0x80000000 | (cwi->dirsize + cwi->dirstrs.length));
 670
 671           str = coff_alloc (&cwi->dirstrs, e->id.u.n.length * 2 + 2);
 672           windres_put_16 (cwi->wrbfd, str, e->id.u.n.length);
 673           for (i = 0; i < e->id.u.n.length; i++)
 674             windres_put_16 (cwi->wrbfd, str + (i + 1) * sizeof (unichar), e->id.u.n.name[i]);
 675         }
 676
 677       if (e->subdir)
 678         {
 679           windres_put_32 (cwi->wrbfd, ere->rva, 0x80000000 | cwi->dirs.length);
 680           coff_to_bin (e->u.dir, cwi);
 681         }
 682       else
 683         {
 684           windres_put_32 (cwi->wrbfd, ere->rva,
 685                      cwi->dirsize + cwi->dirstrsize + cwi->dataents.length);
 686
 687           coff_res_to_bin (e->u.res, cwi);
 688         }
 689     }
 690 }
 691
 692 /* Convert the resource RES to binary.  */
 693
 694 static void
 695 coff_res_to_bin (const rc_res_resource *res, struct coff_write_info *cwi)
 696 {
 697   arelent *r;
 698   struct extern_res_data *erd;
 699   coff_res_data *d;
 700
 701   /* For some reason, although every other address is a section
 702      offset, the address of the resource data itself is an RVA.  That
 703      means that we need to generate a relocation for it.  We allocate
 704      the relocs array using malloc so that we can use realloc.  FIXME:
 705      This relocation handling is correct for the i386, but probably
 706      not for any other target.  */
 707
 708   r = (arelent *) reswr_alloc (sizeof (arelent));
 709   r->sym_ptr_ptr = cwi->sympp;
 710   r->address = cwi->dirsize + cwi->dirstrsize + cwi->dataents.length;
 711   r->addend = 0;
 712   r->howto = bfd_reloc_type_lookup (WR_BFD (cwi->wrbfd), BFD_RELOC_RVA);
 713   if (r->howto == NULL)
 714     bfd_fatal (_("can't get BFD_RELOC_RVA relocation type"));
 715
 716   cwi->relocs = xrealloc (cwi->relocs,
 717                           (cwi->reloc_count + 2) * sizeof (arelent *));
 718   cwi->relocs[cwi->reloc_count] = r;
 719   cwi->relocs[cwi->reloc_count + 1] = NULL;
 720   ++cwi->reloc_count;
 721
 722   erd = (struct extern_res_data *) coff_alloc (&cwi->dataents, sizeof (*erd));
 723
 724   windres_put_32 (cwi->wrbfd, erd->rva,
 725              (cwi->dirsize
 726               + cwi->dirstrsize
 727               + cwi->dataentsize
 728               + cwi->resources.length));
 729   windres_put_32 (cwi->wrbfd, erd->codepage, res->coff_info.codepage);
 730   windres_put_32 (cwi->wrbfd, erd->reserved, res->coff_info.reserved);
 731
 732   d = (coff_res_data *) reswr_alloc (sizeof (coff_res_data));
 733   d->length = res_to_bin (NULL, (rc_uint_type) 0, res);
 734   d->res = res;
 735   d->next = NULL;
 736
 737   if (cwi->resources.d == NULL)
 738     cwi->resources.d = d;
 739   else
 740     cwi->resources.last->next = d;
 741
 742   cwi->resources.last = d;
 743   cwi->resources.length += (d->length + 7) & ~7;
 744
 745   windres_put_32 (cwi->wrbfd, erd->size, d->length);
 746
 747   /* Force the next resource to have 64 bit alignment.  */
 748   d->length = (d->length + 7) & ~7;
 749 }