+\f
+/* This structure is used to build a list of bindata structures. */
+
+struct bindata_build
+{
+ /* The data. */
+ bindata *d;
+ /* The last structure we have added to the list. */
+ bindata *last;
+ /* The size of the list as a whole. */
+ unsigned long length;
+};
+
+struct coff_res_data_build
+{
+ /* The data. */
+ coff_res_data *d;
+ /* The last structure we have added to the list. */
+ coff_res_data *last;
+ /* The size of the list as a whole. */
+ unsigned long length;
+};
+
+/* This structure keeps track of information as we build the directory
+ tree. */
+
+struct coff_write_info
+{
+ /* These fields are based on the BFD. */
+ /* The BFD itself. */
+ windres_bfd *wrbfd;
+ /* Pointer to section symbol used to build RVA relocs. */
+ asymbol **sympp;
+
+ /* These fields are computed initially, and then not changed. */
+ /* Length of directory tables and entries. */
+ unsigned long dirsize;
+ /* Length of directory entry strings. */
+ unsigned long dirstrsize;
+ /* Length of resource data entries. */
+ unsigned long dataentsize;
+
+ /* These fields are updated as we add data. */
+ /* Directory tables and entries. */
+ struct bindata_build dirs;
+ /* Directory entry strings. */
+ struct bindata_build dirstrs;
+ /* Resource data entries. */
+ struct bindata_build dataents;
+ /* Actual resource data. */
+ struct coff_res_data_build resources;
+ /* Relocations. */
+ arelent **relocs;
+ /* Number of relocations. */
+ unsigned int reloc_count;
+};
+
+static void coff_bin_sizes (const rc_res_directory *, struct coff_write_info *);
+static bfd_byte *coff_alloc (struct bindata_build *, rc_uint_type);
+static void coff_to_bin
+ (const rc_res_directory *, struct coff_write_info *);
+static void coff_res_to_bin
+ (const rc_res_resource *, struct coff_write_info *);
+
+/* Write resources to a COFF file. RESOURCES should already be
+ sorted.
+
+ Right now we always create a new file. Someday we should also
+ offer the ability to merge resources into an existing file. This
+ would require doing the basic work of objcopy, just modifying or
+ adding the .rsrc section. */
+
+void
+write_coff_file (const char *filename, const char *target,
+ const rc_res_directory *resources)
+{
+ bfd *abfd;
+ asection *sec;
+ struct coff_write_info cwi;
+ windres_bfd wrbfd;
+ bindata *d;
+ coff_res_data *rd;
+ unsigned long length, offset;
+
+ if (filename == NULL)
+ fatal (_("filename required for COFF output"));
+
+ abfd = bfd_openw (filename, target);
+ if (abfd == NULL)
+ bfd_fatal (filename);
+
+ if (! bfd_set_format (abfd, bfd_object))
+ bfd_fatal ("bfd_set_format");
+
+#if defined DLLTOOL_SH
+ if (! bfd_set_arch_mach (abfd, bfd_arch_sh, 0))
+ bfd_fatal ("bfd_set_arch_mach(sh)");
+#elif defined DLLTOOL_MIPS
+ if (! bfd_set_arch_mach (abfd, bfd_arch_mips, 0))
+ bfd_fatal ("bfd_set_arch_mach(mips)");
+#elif defined DLLTOOL_ARM
+ if (! bfd_set_arch_mach (abfd, bfd_arch_arm, 0))
+ bfd_fatal ("bfd_set_arch_mach(arm)");
+#else
+ /* FIXME: This is obviously i386 specific. */
+ if (! bfd_set_arch_mach (abfd, bfd_arch_i386, 0))
+ bfd_fatal ("bfd_set_arch_mach(i386)");
+#endif
+
+ if (! bfd_set_file_flags (abfd, HAS_SYMS | HAS_RELOC))
+ bfd_fatal ("bfd_set_file_flags");
+
+ sec = bfd_make_section_with_flags (abfd, ".rsrc",
+ (SEC_HAS_CONTENTS | SEC_ALLOC
+ | SEC_LOAD | SEC_DATA));
+ if (sec == NULL)
+ bfd_fatal ("bfd_make_section");
+
+ if (! bfd_set_symtab (abfd, sec->symbol_ptr_ptr, 1))
+ bfd_fatal ("bfd_set_symtab");
+
+ /* Requiring this is probably a bug in BFD. */
+ sec->output_section = sec;
+
+ /* The order of data in the .rsrc section is
+ resource directory tables and entries
+ resource directory strings
+ resource data entries
+ actual resource data
+
+ We build these different types of data in different lists. */
+
+ set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD);
+
+ cwi.wrbfd = &wrbfd;
+ cwi.sympp = sec->symbol_ptr_ptr;
+ cwi.dirsize = 0;
+ cwi.dirstrsize = 0;
+ cwi.dataentsize = 0;
+ cwi.dirs.d = NULL;
+ cwi.dirs.last = NULL;
+ cwi.dirs.length = 0;
+ cwi.dirstrs.d = NULL;
+ cwi.dirstrs.last = NULL;
+ cwi.dirstrs.length = 0;
+ cwi.dataents.d = NULL;
+ cwi.dataents.last = NULL;
+ cwi.dataents.length = 0;
+ cwi.resources.d = NULL;
+ cwi.resources.last = NULL;
+ cwi.resources.length = 0;
+ cwi.relocs = NULL;
+ cwi.reloc_count = 0;
+
+ /* Work out the sizes of the resource directory entries, so that we
+ know the various offsets we will need. */
+ coff_bin_sizes (resources, &cwi);
+
+ /* Force the directory strings to be 64 bit aligned. Every other
+ structure is 64 bit aligned anyhow. */
+ cwi.dirstrsize = (cwi.dirstrsize + 7) & ~7;
+
+ /* Actually convert the resources to binary. */
+ coff_to_bin (resources, &cwi);
+
+ /* Add another few bytes to the directory strings if needed for
+ alignment. */
+ if ((cwi.dirstrs.length & 7) != 0)
+ {
+ rc_uint_type pad = 8 - (cwi.dirstrs.length & 7);
+ bfd_byte *ex;
+
+ ex = coff_alloc (& cwi.dirstrs, pad);
+ memset (ex, 0, pad);
+ }
+
+ /* Make sure that the data we built came out to the same size as we
+ calculated initially. */
+ assert (cwi.dirs.length == cwi.dirsize);
+ assert (cwi.dirstrs.length == cwi.dirstrsize);
+ assert (cwi.dataents.length == cwi.dataentsize);
+
+ length = (cwi.dirsize
+ + cwi.dirstrsize
+ + cwi.dataentsize
+ + cwi.resources.length);
+
+ if (!bfd_set_section_size (sec, length))
+ bfd_fatal ("bfd_set_section_size");
+
+ bfd_set_reloc (abfd, sec, cwi.relocs, cwi.reloc_count);
+
+ offset = 0;
+ for (d = cwi.dirs.d; d != NULL; d = d->next)
+ {
+ if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
+ bfd_fatal ("bfd_set_section_contents");
+ offset += d->length;
+ }
+ for (d = cwi.dirstrs.d; d != NULL; d = d->next)
+ {
+ set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
+ offset += d->length;
+ }
+ for (d = cwi.dataents.d; d != NULL; d = d->next)
+ {
+ set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
+ offset += d->length;
+ }
+ for (rd = cwi.resources.d; rd != NULL; rd = rd->next)
+ {
+ res_to_bin (cwi.wrbfd, (rc_uint_type) offset, rd->res);
+ offset += rd->length;
+ }
+
+ assert (offset == length);
+
+ if (! bfd_close (abfd))
+ bfd_fatal ("bfd_close");
+
+ /* We allocated the relocs array using malloc. */
+ free (cwi.relocs);
+}
+
+/* Work out the sizes of the various fixed size resource directory
+ entries. This updates fields in CWI. */
+
+static void
+coff_bin_sizes (const rc_res_directory *resdir,
+ struct coff_write_info *cwi)
+{
+ const rc_res_entry *re;
+
+ cwi->dirsize += sizeof (struct extern_res_directory);
+
+ for (re = resdir->entries; re != NULL; re = re->next)
+ {
+ cwi->dirsize += sizeof (struct extern_res_entry);
+
+ if (re->id.named)
+ cwi->dirstrsize += re->id.u.n.length * 2 + 2;
+
+ if (re->subdir)
+ coff_bin_sizes (re->u.dir, cwi);
+ else
+ cwi->dataentsize += sizeof (struct extern_res_data);
+ }
+}
+
+/* Allocate data for a particular list. */
+
+static bfd_byte *
+coff_alloc (struct bindata_build *bb, rc_uint_type size)
+{
+ bindata *d;
+
+ d = (bindata *) reswr_alloc (sizeof (bindata));
+
+ d->next = NULL;
+ d->data = (bfd_byte *) reswr_alloc (size);
+ d->length = size;
+
+ if (bb->d == NULL)
+ bb->d = d;
+ else
+ bb->last->next = d;
+ bb->last = d;
+ bb->length += size;
+
+ return d->data;
+}
+
+/* Convert the resource directory RESDIR to binary. */
+
+static void
+coff_to_bin (const rc_res_directory *resdir, struct coff_write_info *cwi)
+{
+ struct extern_res_directory *erd;
+ int ci, cn;
+ const rc_res_entry *e;
+ struct extern_res_entry *ere;
+
+ /* Write out the directory table. */
+
+ erd = ((struct extern_res_directory *)
+ coff_alloc (&cwi->dirs, sizeof (*erd)));
+
+ windres_put_32 (cwi->wrbfd, erd->characteristics, resdir->characteristics);
+ windres_put_32 (cwi->wrbfd, erd->time, resdir->time);
+ windres_put_16 (cwi->wrbfd, erd->major, resdir->major);
+ windres_put_16 (cwi->wrbfd, erd->minor, resdir->minor);
+
+ ci = 0;
+ cn = 0;
+ for (e = resdir->entries; e != NULL; e = e->next)
+ {
+ if (e->id.named)
+ ++cn;
+ else
+ ++ci;
+ }
+
+ windres_put_16 (cwi->wrbfd, erd->name_count, cn);
+ windres_put_16 (cwi->wrbfd, erd->id_count, ci);
+
+ /* Write out the data entries. Note that we allocate space for all
+ the entries before writing them out. That permits a recursive
+ call to work correctly when writing out subdirectories. */
+
+ ere = ((struct extern_res_entry *)
+ coff_alloc (&cwi->dirs, (ci + cn) * sizeof (*ere)));
+ for (e = resdir->entries; e != NULL; e = e->next, ere++)
+ {
+ if (! e->id.named)
+ windres_put_32 (cwi->wrbfd, ere->name, e->id.u.id);
+ else
+ {
+ bfd_byte *str;
+ rc_uint_type i;
+
+ /* For some reason existing files seem to have the high bit
+ set on the address of the name, although that is not
+ documented. */
+ windres_put_32 (cwi->wrbfd, ere->name,
+ 0x80000000 | (cwi->dirsize + cwi->dirstrs.length));
+
+ str = coff_alloc (&cwi->dirstrs, e->id.u.n.length * 2 + 2);
+ windres_put_16 (cwi->wrbfd, str, e->id.u.n.length);
+ for (i = 0; i < e->id.u.n.length; i++)
+ windres_put_16 (cwi->wrbfd, str + (i + 1) * sizeof (unichar), e->id.u.n.name[i]);
+ }
+
+ if (e->subdir)
+ {
+ windres_put_32 (cwi->wrbfd, ere->rva, 0x80000000 | cwi->dirs.length);
+ coff_to_bin (e->u.dir, cwi);
+ }
+ else
+ {
+ windres_put_32 (cwi->wrbfd, ere->rva,
+ cwi->dirsize + cwi->dirstrsize + cwi->dataents.length);
+
+ coff_res_to_bin (e->u.res, cwi);
+ }
+ }
+}
+
+/* Convert the resource RES to binary. */
+
+static void
+coff_res_to_bin (const rc_res_resource *res, struct coff_write_info *cwi)
+{
+ arelent *r;
+ struct extern_res_data *erd;
+ coff_res_data *d;
+
+ /* For some reason, although every other address is a section
+ offset, the address of the resource data itself is an RVA. That
+ means that we need to generate a relocation for it. We allocate
+ the relocs array using malloc so that we can use realloc. FIXME:
+ This relocation handling is correct for the i386, but probably
+ not for any other target. */
+
+ r = (arelent *) reswr_alloc (sizeof (arelent));
+ r->sym_ptr_ptr = cwi->sympp;
+ r->address = cwi->dirsize + cwi->dirstrsize + cwi->dataents.length;
+ r->addend = 0;
+ r->howto = bfd_reloc_type_lookup (WR_BFD (cwi->wrbfd), BFD_RELOC_RVA);
+ if (r->howto == NULL)
+ bfd_fatal (_("can't get BFD_RELOC_RVA relocation type"));
+
+ cwi->relocs = xrealloc (cwi->relocs,
+ (cwi->reloc_count + 2) * sizeof (arelent *));
+ cwi->relocs[cwi->reloc_count] = r;
+ cwi->relocs[cwi->reloc_count + 1] = NULL;
+ ++cwi->reloc_count;
+
+ erd = (struct extern_res_data *) coff_alloc (&cwi->dataents, sizeof (*erd));
+
+ windres_put_32 (cwi->wrbfd, erd->rva,
+ (cwi->dirsize
+ + cwi->dirstrsize
+ + cwi->dataentsize
+ + cwi->resources.length));
+ windres_put_32 (cwi->wrbfd, erd->codepage, res->coff_info.codepage);
+ windres_put_32 (cwi->wrbfd, erd->reserved, res->coff_info.reserved);
+
+ d = (coff_res_data *) reswr_alloc (sizeof (coff_res_data));
+ d->length = res_to_bin (NULL, (rc_uint_type) 0, res);
+ d->res = res;
+ d->next = NULL;
+
+ if (cwi->resources.d == NULL)
+ cwi->resources.d = d;
+ else
+ cwi->resources.last->next = d;
+
+ cwi->resources.last = d;
+ cwi->resources.length += (d->length + 7) & ~7;
+
+ windres_put_32 (cwi->wrbfd, erd->size, d->length);
+
+ /* Force the next resource to have 64 bit alignment. */
+ d->length = (d->length + 7) & ~7;
+}