binutils/rescoff.c

   1 /* rescoff.c -- read and write resources in Windows COFF files.
   2    Copyright 1997, 1998, 2000 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program 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 of the License, or
  10    (at your option) any later version.
  11
  12    This program 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 this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 /* This file contains function that read and write Windows resources
  23    in COFF files.  */
  24
  25 #include "bfd.h"
  26 #include "bucomm.h"
  27 #include "libiberty.h"
  28 #include "windres.h"
  29
  30 #include <assert.h>
  31
  32 /* In order to use the address of a resource data entry, we need to
  33    get the image base of the file.  Right now we extract it from
  34    internal BFD information.  FIXME.  */
  35
  36 #include "coff/internal.h"
  37 #include "libcoff.h"
  38
  39 /* Information we extract from the file.  */
  40
  41 struct coff_file_info
  42 {
  43   /* File name.  */
  44   const char *filename;
  45   /* Data read from the file.  */
  46   const bfd_byte *data;
  47   /* End of data read from file.  */
  48   const bfd_byte *data_end;
  49   /* Address of the resource section minus the image base of the file.  */
  50   bfd_vma secaddr;
  51   /* Non-zero if the file is big endian.  */
  52   int big_endian;
  53 };
  54
  55 /* A resource directory table in a COFF file.  */
  56
  57 struct 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 /* Macros to swap in values.  */
  99
 100 #define getfi_16(fi, s) ((fi)->big_endian ? bfd_getb16 (s) : bfd_getl16 (s))
 101 #define getfi_32(fi, s) ((fi)->big_endian ? bfd_getb32 (s) : bfd_getl32 (s))
 102
 103 /* Local functions.  */
 104
 105 static void overrun PARAMS ((const struct coff_file_info *, const char *));
 106 static struct res_directory *read_coff_res_dir
 107   PARAMS ((const bfd_byte *, const struct coff_file_info *,
 108            const struct res_id *, int));
 109 static struct res_resource *read_coff_data_entry
 110   PARAMS ((const bfd_byte *, const struct coff_file_info *,
 111            const struct res_id *));
 112 \f
 113 /* Read the resources in a COFF file.  */
 114
 115 struct res_directory *
 116 read_coff_rsrc (filename, target)
 117      const char *filename;
 118      const char *target;
 119 {
 120   bfd *abfd;
 121   char **matching;
 122   asection *sec;
 123   bfd_size_type size;
 124   bfd_byte *data;
 125   struct coff_file_info finfo;
 126
 127   if (filename == NULL)
 128     fatal (_("filename required for COFF input"));
 129
 130   abfd = bfd_openr (filename, target);
 131   if (abfd == NULL)
 132     bfd_fatal (filename);
 133
 134   if (! bfd_check_format_matches (abfd, bfd_object, &matching))
 135     {
 136       bfd_nonfatal (bfd_get_filename (abfd));
 137       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 138         list_matching_formats (matching);
 139       xexit (1);
 140     }
 141
 142   sec = bfd_get_section_by_name (abfd, ".rsrc");
 143   if (sec == NULL)
 144     {
 145       fprintf (stderr, _("%s: %s: no resource section\n"), program_name,
 146                filename);
 147       xexit (1);
 148     }
 149
 150   size = bfd_section_size (abfd, sec);
 151   data = (bfd_byte *) res_alloc (size);
 152
 153   if (! bfd_get_section_contents (abfd, sec, data, 0, size))
 154     bfd_fatal (_("can't read resource section"));
 155
 156   finfo.filename = filename;
 157   finfo.data = data;
 158   finfo.data_end = data + size;
 159   finfo.secaddr = (bfd_get_section_vma (abfd, sec)
 160                    - pe_data (abfd)->pe_opthdr.ImageBase);
 161   finfo.big_endian = bfd_big_endian (abfd);
 162
 163   bfd_close (abfd);
 164
 165   /* Now just read in the top level resource directory.  Note that we
 166      don't free data, since we create resource entries that point into
 167      it.  If we ever want to free up the resource information we read,
 168      this will have to be cleaned up.  */
 169
 170   return read_coff_res_dir (data, &finfo, (const struct res_id *) NULL, 0);
 171 }
 172
 173 /* Give an error if we are out of bounds.  */
 174
 175 static void
 176 overrun (finfo, msg)
 177      const struct coff_file_info *finfo;
 178      const char *msg;
 179 {
 180   fatal (_("%s: %s: address out of bounds"), finfo->filename, msg);
 181 }
 182
 183 /* Read a resource directory.  */
 184
 185 static struct res_directory *
 186 read_coff_res_dir (data, finfo, type, level)
 187      const bfd_byte *data;
 188      const struct coff_file_info *finfo;
 189      const struct res_id *type;
 190      int level;
 191 {
 192   const struct extern_res_directory *erd;
 193   struct res_directory *rd;
 194   int name_count, id_count, i;
 195   struct res_entry **pp;
 196   const struct extern_res_entry *ere;
 197
 198   if ((size_t) (finfo->data_end - data) < sizeof (struct extern_res_directory))
 199     overrun (finfo, _("directory"));
 200
 201   erd = (const struct extern_res_directory *) data;
 202
 203   rd = (struct res_directory *) res_alloc (sizeof *rd);
 204   rd->characteristics = getfi_32 (finfo, erd->characteristics);
 205   rd->time = getfi_32 (finfo, erd->time);
 206   rd->major = getfi_16 (finfo, erd->major);
 207   rd->minor = getfi_16 (finfo, erd->minor);
 208   rd->entries = NULL;
 209
 210   name_count = getfi_16 (finfo, erd->name_count);
 211   id_count = getfi_16 (finfo, erd->id_count);
 212
 213   pp = &rd->entries;
 214
 215   /* The resource directory entries immediately follow the directory
 216      table.  */
 217   ere = (const struct extern_res_entry *) (erd + 1);
 218
 219   for (i = 0; i < name_count; i++, ere++)
 220     {
 221       unsigned long name, rva;
 222       struct res_entry *re;
 223       const bfd_byte *ers;
 224       int length, j;
 225
 226       if ((const bfd_byte *) ere >= finfo->data_end)
 227         overrun (finfo, _("named directory entry"));
 228
 229       name = getfi_32 (finfo, ere->name);
 230       rva = getfi_32 (finfo, ere->rva);
 231
 232       /* For some reason the high bit in NAME is set.  */
 233       name &=~ 0x80000000;
 234
 235       if (name > (size_t) (finfo->data_end - finfo->data))
 236         overrun (finfo, _("directory entry name"));
 237
 238       ers = finfo->data + name;
 239
 240       re = (struct res_entry *) res_alloc (sizeof *re);
 241       re->next = NULL;
 242       re->id.named = 1;
 243       length = getfi_16 (finfo, ers);
 244       re->id.u.n.length = length;
 245       re->id.u.n.name = (unichar *) res_alloc (length * sizeof (unichar));
 246       for (j = 0; j < length; j++)
 247         re->id.u.n.name[j] = getfi_16 (finfo, ers + j * 2 + 2);
 248
 249       if (level == 0)
 250         type = &re->id;
 251
 252       if ((rva & 0x80000000) != 0)
 253         {
 254           rva &=~ 0x80000000;
 255           if (rva >= (size_t) (finfo->data_end - finfo->data))
 256             overrun (finfo, _("named subdirectory"));
 257           re->subdir = 1;
 258           re->u.dir = read_coff_res_dir (finfo->data + rva, finfo, type,
 259                                          level + 1);
 260         }
 261       else
 262         {
 263           if (rva >= (size_t) (finfo->data_end - finfo->data))
 264             overrun (finfo, _("named resource"));
 265           re->subdir = 0;
 266           re->u.res = read_coff_data_entry (finfo->data + rva, finfo, type);
 267         }
 268
 269       *pp = re;
 270       pp = &re->next;
 271     }
 272
 273   for (i = 0; i < id_count; i++, ere++)
 274     {
 275       unsigned long name, rva;
 276       struct res_entry *re;
 277
 278       if ((const bfd_byte *) ere >= finfo->data_end)
 279         overrun (finfo, _("ID directory entry"));
 280
 281       name = getfi_32 (finfo, ere->name);
 282       rva = getfi_32 (finfo, ere->rva);
 283
 284       re = (struct res_entry *) res_alloc (sizeof *re);
 285       re->next = NULL;
 286       re->id.named = 0;
 287       re->id.u.id = name;
 288
 289       if (level == 0)
 290         type = &re->id;
 291
 292       if ((rva & 0x80000000) != 0)
 293         {
 294           rva &=~ 0x80000000;
 295           if (rva >= (size_t) (finfo->data_end - finfo->data))
 296             overrun (finfo, _("ID subdirectory"));
 297           re->subdir = 1;
 298           re->u.dir = read_coff_res_dir (finfo->data + rva, finfo, type,
 299                                          level + 1);
 300         }
 301       else
 302         {
 303           if (rva >= (size_t) (finfo->data_end - finfo->data))
 304             overrun (finfo, _("ID resource"));
 305           re->subdir = 0;
 306           re->u.res = read_coff_data_entry (finfo->data + rva, finfo, type);
 307         }
 308
 309       *pp = re;
 310       pp = &re->next;
 311     }
 312
 313   return rd;
 314 }
 315
 316 /* Read a resource data entry.  */
 317
 318 static struct res_resource *
 319 read_coff_data_entry (data, finfo, type)
 320      const bfd_byte *data;
 321      const struct coff_file_info *finfo;
 322      const struct res_id *type;
 323 {
 324   const struct extern_res_data *erd;
 325   struct res_resource *r;
 326   unsigned long size, rva;
 327   const bfd_byte *resdata;
 328
 329   if (type == NULL)
 330     fatal (_("resource type unknown"));
 331
 332   if ((size_t) (finfo->data_end - data) < sizeof (struct extern_res_data))
 333     overrun (finfo, _("data entry"));
 334
 335   erd = (const struct extern_res_data *) data;
 336
 337   size = getfi_32 (finfo, erd->size);
 338   rva = getfi_32 (finfo, erd->rva);
 339   if (rva < finfo->secaddr
 340       || rva - finfo->secaddr >= (size_t) (finfo->data_end - finfo->data))
 341     overrun (finfo, _("resource data"));
 342
 343   resdata = finfo->data + (rva - finfo->secaddr);
 344
 345   if (size > (size_t) (finfo->data_end - resdata))
 346     overrun (finfo, _("resource data size"));
 347
 348   r = bin_to_res (*type, resdata, size, finfo->big_endian);
 349
 350   memset (&r->res_info, 0, sizeof (struct res_res_info));
 351   r->coff_info.codepage = getfi_32 (finfo, erd->codepage);
 352   r->coff_info.reserved = getfi_32 (finfo, erd->reserved);
 353
 354   return r;
 355 }
 356 \f
 357 /* This structure is used to build a list of bindata structures.  */
 358
 359 struct bindata_build
 360 {
 361   /* The data.  */
 362   struct bindata *d;
 363   /* The last structure we have added to the list.  */
 364   struct bindata *last;
 365   /* The size of the list as a whole.  */
 366   unsigned long length;
 367 };
 368
 369 /* This structure keeps track of information as we build the directory
 370    tree.  */
 371
 372 struct coff_write_info
 373 {
 374   /* These fields are based on the BFD.  */
 375   /* The BFD itself.  */
 376   bfd *abfd;
 377   /* Non-zero if the file is big endian.  */
 378   int big_endian;
 379   /* Pointer to section symbol used to build RVA relocs.  */
 380   asymbol **sympp;
 381
 382   /* These fields are computed initially, and then not changed.  */
 383   /* Length of directory tables and entries.  */
 384   unsigned long dirsize;
 385   /* Length of directory entry strings.  */
 386   unsigned long dirstrsize;
 387   /* Length of resource data entries.  */
 388   unsigned long dataentsize;
 389
 390   /* These fields are updated as we add data.  */
 391   /* Directory tables and entries.  */
 392   struct bindata_build dirs;
 393   /* Directory entry strings.  */
 394   struct bindata_build dirstrs;
 395   /* Resource data entries.  */
 396   struct bindata_build dataents;
 397   /* Actual resource data.  */
 398   struct bindata_build resources;
 399   /* Relocations.  */
 400   arelent **relocs;
 401   /* Number of relocations.  */
 402   unsigned int reloc_count;
 403 };
 404
 405 /* Macros to swap out values.  */
 406
 407 #define putcwi_16(cwi, v, s) \
 408   ((cwi->big_endian) ? bfd_putb16 ((v), (s)) : bfd_putl16 ((v), (s)))
 409 #define putcwi_32(cwi, v, s) \
 410   ((cwi->big_endian) ? bfd_putb32 ((v), (s)) : bfd_putl32 ((v), (s)))
 411
 412 static void coff_bin_sizes
 413   PARAMS ((const struct res_directory *, struct coff_write_info *));
 414 static unsigned char *coff_alloc PARAMS ((struct bindata_build *, size_t));
 415 static void coff_to_bin
 416   PARAMS ((const struct res_directory *, struct coff_write_info *));
 417 static void coff_res_to_bin
 418   PARAMS ((const struct res_resource *, struct coff_write_info *));
 419
 420 /* Write resources to a COFF file.  RESOURCES should already be
 421    sorted.
 422
 423    Right now we always create a new file.  Someday we should also
 424    offer the ability to merge resources into an existing file.  This
 425    would require doing the basic work of objcopy, just modifying or
 426    adding the .rsrc section.  */
 427
 428 void
 429 write_coff_file (filename, target, resources)
 430      const char *filename;
 431      const char *target;
 432      const struct res_directory *resources;
 433 {
 434   bfd *abfd;
 435   asection *sec;
 436   struct coff_write_info cwi;
 437   struct bindata *d;
 438   unsigned long length, offset;
 439
 440   if (filename == NULL)
 441     fatal (_("filename required for COFF output"));
 442
 443   abfd = bfd_openw (filename, target);
 444   if (abfd == NULL)
 445     bfd_fatal (filename);
 446
 447   if (! bfd_set_format (abfd, bfd_object))
 448     bfd_fatal ("bfd_set_format");
 449
 450 #if defined DLLTOOL_SH
 451   if (! bfd_set_arch_mach (abfd, bfd_arch_sh, 0))
 452     bfd_fatal ("bfd_set_arch_mach(sh)");
 453 #elif defined DLLTOOL_MIPS
 454   if (! bfd_set_arch_mach (abfd, bfd_arch_mips, 0))
 455     bfd_fatal ("bfd_set_arch_mach(mips)");
 456 #elif defined DLLTOOL_ARM
 457   if (! bfd_set_arch_mach (abfd, bfd_arch_arm, 0))
 458     bfd_fatal ("bfd_set_arch_mach(arm)");
 459 #else
 460   /* FIXME: This is obviously i386 specific.  */
 461   if (! bfd_set_arch_mach (abfd, bfd_arch_i386, 0))
 462     bfd_fatal ("bfd_set_arch_mach(i386)");
 463 #endif
 464
 465   if (! bfd_set_file_flags (abfd, HAS_SYMS | HAS_RELOC))
 466     bfd_fatal ("bfd_set_file_flags");
 467
 468   sec = bfd_make_section (abfd, ".rsrc");
 469   if (sec == NULL)
 470     bfd_fatal ("bfd_make_section");
 471
 472   if (! bfd_set_section_flags (abfd, sec,
 473                                (SEC_HAS_CONTENTS | SEC_ALLOC
 474                                 | SEC_LOAD | SEC_DATA)))
 475     bfd_fatal ("bfd_set_section_flags");
 476
 477   if (! bfd_set_symtab (abfd, sec->symbol_ptr_ptr, 1))
 478     bfd_fatal ("bfd_set_symtab");
 479
 480   /* Requiring this is probably a bug in BFD.  */
 481   sec->output_section = sec;
 482
 483   /* The order of data in the .rsrc section is
 484        resource directory tables and entries
 485        resource directory strings
 486        resource data entries
 487        actual resource data
 488
 489      We build these different types of data in different lists.  */
 490
 491   cwi.abfd = abfd;
 492   cwi.big_endian = bfd_big_endian (abfd);
 493   cwi.sympp = sec->symbol_ptr_ptr;
 494   cwi.dirsize = 0;
 495   cwi.dirstrsize = 0;
 496   cwi.dataentsize = 0;
 497   cwi.dirs.d = NULL;
 498   cwi.dirs.last = NULL;
 499   cwi.dirs.length = 0;
 500   cwi.dirstrs.d = NULL;
 501   cwi.dirstrs.last = NULL;
 502   cwi.dirstrs.length = 0;
 503   cwi.dataents.d = NULL;
 504   cwi.dataents.last = NULL;
 505   cwi.dataents.length = 0;
 506   cwi.resources.d = NULL;
 507   cwi.resources.last = NULL;
 508   cwi.resources.length = 0;
 509   cwi.relocs = NULL;
 510   cwi.reloc_count = 0;
 511
 512   /* Work out the sizes of the resource directory entries, so that we
 513      know the various offsets we will need.  */
 514   coff_bin_sizes (resources, &cwi);
 515
 516   /* Force the directory strings to be 32 bit aligned.  Every other
 517      structure is 32 bit aligned anyhow.  */
 518   cwi.dirstrsize = (cwi.dirstrsize + 3) &~ 3;
 519
 520   /* Actually convert the resources to binary.  */
 521   coff_to_bin (resources, &cwi);
 522
 523   /* Add another 2 bytes to the directory strings if needed for
 524      alignment.  */
 525   if ((cwi.dirstrs.length & 3) != 0)
 526     {
 527       unsigned char *ex;
 528
 529       ex = coff_alloc (&cwi.dirstrs, 2);
 530       ex[0] = 0;
 531       ex[1] = 0;
 532     }
 533
 534   /* Make sure that the data we built came out to the same size as we
 535      calculated initially.  */
 536   assert (cwi.dirs.length == cwi.dirsize);
 537   assert (cwi.dirstrs.length == cwi.dirstrsize);
 538   assert (cwi.dataents.length == cwi.dataentsize);
 539
 540   length = (cwi.dirsize
 541             + cwi.dirstrsize
 542             + cwi.dataentsize
 543             + cwi.resources.length);
 544
 545   if (! bfd_set_section_size (abfd, sec, length))
 546     bfd_fatal ("bfd_set_section_size");
 547
 548   bfd_set_reloc (abfd, sec, cwi.relocs, cwi.reloc_count);
 549
 550   offset = 0;
 551   for (d = cwi.dirs.d; d != NULL; d = d->next)
 552     {
 553       if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
 554         bfd_fatal ("bfd_set_section_contents");
 555       offset += d->length;
 556     }
 557   for (d = cwi.dirstrs.d; d != NULL; d = d->next)
 558     {
 559       if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
 560         bfd_fatal ("bfd_set_section_contents");
 561       offset += d->length;
 562     }
 563   for (d = cwi.dataents.d; d != NULL; d = d->next)
 564     {
 565       if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
 566         bfd_fatal ("bfd_set_section_contents");
 567       offset += d->length;
 568     }
 569   for (d = cwi.resources.d; d != NULL; d = d->next)
 570     {
 571       if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
 572         bfd_fatal ("bfd_set_section_contents");
 573       offset += d->length;
 574     }
 575
 576   assert (offset == length);
 577
 578   if (! bfd_close (abfd))
 579     bfd_fatal ("bfd_close");
 580
 581   /* We allocated the relocs array using malloc.  */
 582   free (cwi.relocs);
 583 }
 584
 585 /* Work out the sizes of the various fixed size resource directory
 586    entries.  This updates fields in CWI.  */
 587
 588 static void
 589 coff_bin_sizes (resdir, cwi)
 590      const struct res_directory *resdir;
 591      struct coff_write_info *cwi;
 592 {
 593   const struct res_entry *re;
 594
 595   cwi->dirsize += sizeof (struct extern_res_directory);
 596
 597   for (re = resdir->entries; re != NULL; re = re->next)
 598     {
 599       cwi->dirsize += sizeof (struct extern_res_entry);
 600
 601       if (re->id.named)
 602         cwi->dirstrsize += re->id.u.n.length * 2 + 2;
 603
 604       if (re->subdir)
 605         coff_bin_sizes (re->u.dir, cwi);
 606       else
 607         cwi->dataentsize += sizeof (struct extern_res_data);
 608     }
 609 }
 610
 611 /* Allocate data for a particular list.  */
 612
 613 static unsigned char *
 614 coff_alloc (bb, size)
 615      struct bindata_build *bb;
 616      size_t size;
 617 {
 618   struct bindata *d;
 619
 620   d = (struct bindata *) reswr_alloc (sizeof *d);
 621
 622   d->next = NULL;
 623   d->data = (unsigned char *) reswr_alloc (size);
 624   d->length = size;
 625
 626   if (bb->d == NULL)
 627     bb->d = d;
 628   else
 629     bb->last->next = d;
 630   bb->last = d;
 631   bb->length += size;
 632
 633   return d->data;
 634 }
 635
 636 /* Convert the resource directory RESDIR to binary.  */
 637
 638 static void
 639 coff_to_bin (resdir, cwi)
 640      const struct res_directory *resdir;
 641      struct coff_write_info *cwi;
 642 {
 643   struct extern_res_directory *erd;
 644   int ci, cn;
 645   const struct 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   putcwi_32 (cwi, resdir->characteristics, erd->characteristics);
 654   putcwi_32 (cwi, resdir->time, erd->time);
 655   putcwi_16 (cwi, resdir->major, erd->major);
 656   putcwi_16 (cwi, resdir->minor, erd->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   putcwi_16 (cwi, cn, erd->name_count);
 669   putcwi_16 (cwi, ci, erd->id_count);
 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         putcwi_32 (cwi, e->id.u.id, ere->name);
 681       else
 682         {
 683           unsigned char *str;
 684           int 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           putcwi_32 (cwi,
 690                      0x80000000 | (cwi->dirsize + cwi->dirstrs.length),
 691                      ere->name);
 692
 693           str = coff_alloc (&cwi->dirstrs, e->id.u.n.length * 2 + 2);
 694           putcwi_16 (cwi, e->id.u.n.length, str);
 695           for (i = 0; i < e->id.u.n.length; i++)
 696             putcwi_16 (cwi, e->id.u.n.name[i], str + i * 2 + 2);
 697         }
 698
 699       if (e->subdir)
 700         {
 701           putcwi_32 (cwi, 0x80000000 | cwi->dirs.length, ere->rva);
 702           coff_to_bin (e->u.dir, cwi);
 703         }
 704       else
 705         {
 706           putcwi_32 (cwi,
 707                      cwi->dirsize + cwi->dirstrsize + cwi->dataents.length,
 708                      ere->rva);
 709
 710           coff_res_to_bin (e->u.res, cwi);
 711         }
 712     }
 713 }
 714
 715 /* Convert the resource RES to binary.  */
 716
 717 static void
 718 coff_res_to_bin (res, cwi)
 719      const struct res_resource *res;
 720      struct coff_write_info *cwi;
 721 {
 722   arelent *r;
 723   struct extern_res_data *erd;
 724   struct bindata *d;
 725   unsigned long length;
 726
 727   /* For some reason, although every other address is a section
 728      offset, the address of the resource data itself is an RVA.  That
 729      means that we need to generate a relocation for it.  We allocate
 730      the relocs array using malloc so that we can use realloc.  FIXME:
 731      This relocation handling is correct for the i386, but probably
 732      not for any other target.  */
 733
 734   r = (arelent *) reswr_alloc (sizeof (arelent));
 735   r->sym_ptr_ptr = cwi->sympp;
 736   r->address = cwi->dirsize + cwi->dirstrsize + cwi->dataents.length;
 737   r->addend = 0;
 738   r->howto = bfd_reloc_type_lookup (cwi->abfd, BFD_RELOC_RVA);
 739   if (r->howto == NULL)
 740     bfd_fatal (_("can't get BFD_RELOC_RVA relocation type"));
 741
 742   cwi->relocs = xrealloc (cwi->relocs,
 743                           (cwi->reloc_count + 2) * sizeof (arelent *));
 744   cwi->relocs[cwi->reloc_count] = r;
 745   cwi->relocs[cwi->reloc_count + 1] = NULL;
 746   ++cwi->reloc_count;
 747
 748   erd = (struct extern_res_data *) coff_alloc (&cwi->dataents, sizeof (*erd));
 749
 750   putcwi_32 (cwi,
 751              (cwi->dirsize
 752               + cwi->dirstrsize
 753               + cwi->dataentsize
 754               + cwi->resources.length),
 755              erd->rva);
 756   putcwi_32 (cwi, res->coff_info.codepage, erd->codepage);
 757   putcwi_32 (cwi, res->coff_info.reserved, erd->reserved);
 758
 759   d = res_to_bin (res, cwi->big_endian);
 760
 761   if (cwi->resources.d == NULL)
 762     cwi->resources.d = d;
 763   else
 764     cwi->resources.last->next = d;
 765
 766   length = 0;
 767   for (; d->next != NULL; d = d->next)
 768     length += d->length;
 769   length += d->length;
 770   cwi->resources.last = d;
 771   cwi->resources.length += length;
 772
 773   putcwi_32 (cwi, length, erd->size);
 774
 775   /* Force the next resource to have 32 bit alignment.  */
 776
 777   if ((length & 3) != 0)
 778     {
 779       int add;
 780       unsigned char *ex;
 781
 782       add = 4 - (length & 3);
 783
 784       ex = coff_alloc (&cwi->resources, add);
 785       memset (ex, 0, add);
 786     }
 787 }