1 /* rescoff.c -- read and write resources in Windows COFF files.
2 Copyright (C) 1997-2015 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4 Rewritten by Kai Tietz, Onevision.
6 This file is part of GNU Binutils.
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.
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.
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
23 /* This file contains function that read and write Windows resources
29 #include "libiberty.h"
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. */
38 #include "coff/internal.h"
41 /* Information we extract from the file. */
47 /* Data read from the file. */
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. */
55 /* A resource directory table in a COFF file. */
57 struct __attribute__ ((__packed__)) extern_res_directory
59 /* Characteristics. */
60 bfd_byte characteristics[4];
63 /* Major version number. */
65 /* Minor version number. */
67 /* Number of named directory entries. */
68 bfd_byte name_count[2];
69 /* Number of directory entries with IDs. */
73 /* A resource directory entry in a COFF file. */
75 struct extern_res_entry
79 /* Address of resource entry or subdirectory. */
83 /* A resource data entry in a COFF file. */
85 struct extern_res_data
87 /* Address of resource data. This is apparently a file relative
88 address, rather than a section offset. */
90 /* Size of resource data. */
98 /* Local functions. */
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 *,
108 /* Read the resources in a COFF file. */
111 read_coff_rsrc (const char *filename, const char *target)
113 rc_res_directory *ret;
120 struct coff_file_info flaginfo;
122 if (filename == NULL)
123 fatal (_("filename required for COFF input"));
125 abfd = bfd_openr (filename, target);
127 bfd_fatal (filename);
129 if (! bfd_check_format_matches (abfd, bfd_object, &matching))
131 bfd_nonfatal (bfd_get_filename (abfd));
132 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
133 list_matching_formats (matching);
137 sec = bfd_get_section_by_name (abfd, ".rsrc");
140 fatal (_("%s: no resource section"), filename);
143 set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD);
144 size = bfd_section_size (abfd, sec);
145 data = (bfd_byte *) res_alloc (size);
147 get_windres_bfd_content (&wrbfd, data, 0, size);
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);
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. */
160 ret = read_coff_res_dir (&wrbfd, data, &flaginfo, (const rc_res_id *) NULL, 0);
167 /* Give an error if we are out of bounds. */
170 overrun (const struct coff_file_info *flaginfo, const char *msg)
172 fatal (_("%s: %s: address out of bounds"), flaginfo->filename, msg);
175 /* Read a resource directory. */
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)
182 const struct extern_res_directory *erd;
183 rc_res_directory *rd;
184 int name_count, id_count, i;
186 const struct extern_res_entry *ere;
188 if ((size_t) (flaginfo->data_end - data) < sizeof (struct extern_res_directory))
189 overrun (flaginfo, _("directory"));
191 erd = (const struct extern_res_directory *) data;
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);
200 name_count = windres_get_16 (wrbfd, erd->name_count, 2);
201 id_count = windres_get_16 (wrbfd, erd->id_count, 2);
205 /* The resource directory entries immediately follow the directory
207 ere = (const struct extern_res_entry *) (erd + 1);
209 for (i = 0; i < name_count; i++, ere++)
211 rc_uint_type name, rva;
216 if ((const bfd_byte *) ere >= flaginfo->data_end)
217 overrun (flaginfo, _("named directory entry"));
219 name = windres_get_32 (wrbfd, ere->name, 4);
220 rva = windres_get_32 (wrbfd, ere->rva, 4);
222 /* For some reason the high bit in NAME is set. */
225 if (name > (rc_uint_type) (flaginfo->data_end - flaginfo->data))
226 overrun (flaginfo, _("directory entry name"));
228 ers = flaginfo->data + name;
230 re = (rc_res_entry *) res_alloc (sizeof *re);
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);
242 if ((rva & 0x80000000) != 0)
245 if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
246 overrun (flaginfo, _("named subdirectory"));
248 re->u.dir = read_coff_res_dir (wrbfd, flaginfo->data + rva, flaginfo, type,
253 if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
254 overrun (flaginfo, _("named resource"));
256 re->u.res = read_coff_data_entry (wrbfd, flaginfo->data + rva, flaginfo, type);
263 for (i = 0; i < id_count; i++, ere++)
265 unsigned long name, rva;
268 if ((const bfd_byte *) ere >= flaginfo->data_end)
269 overrun (flaginfo, _("ID directory entry"));
271 name = windres_get_32 (wrbfd, ere->name, 4);
272 rva = windres_get_32 (wrbfd, ere->rva, 4);
274 re = (rc_res_entry *) res_alloc (sizeof *re);
282 if ((rva & 0x80000000) != 0)
285 if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
286 overrun (flaginfo, _("ID subdirectory"));
288 re->u.dir = read_coff_res_dir (wrbfd, flaginfo->data + rva, flaginfo, type,
293 if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
294 overrun (flaginfo, _("ID resource"));
296 re->u.res = read_coff_data_entry (wrbfd, flaginfo->data + rva, flaginfo, type);
306 /* Read a resource data entry. */
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)
313 const struct extern_res_data *erd;
315 rc_uint_type size, rva;
316 const bfd_byte *resdata;
319 fatal (_("resource type unknown"));
321 if ((size_t) (flaginfo->data_end - data) < sizeof (struct extern_res_data))
322 overrun (flaginfo, _("data entry"));
324 erd = (const struct extern_res_data *) data;
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"));
332 resdata = flaginfo->data + (rva - flaginfo->secaddr);
334 if (size > (rc_uint_type) (flaginfo->data_end - resdata))
335 overrun (flaginfo, _("resource data size"));
337 r = bin_to_res (wrbfd, *type, resdata, size);
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);
346 /* This structure is used to build a list of bindata structures. */
352 /* The last structure we have added to the list. */
354 /* The size of the list as a whole. */
355 unsigned long length;
358 struct coff_res_data_build
362 /* The last structure we have added to the list. */
364 /* The size of the list as a whole. */
365 unsigned long length;
368 /* This structure keeps track of information as we build the directory
371 struct coff_write_info
373 /* These fields are based on the BFD. */
374 /* The BFD itself. */
376 /* Pointer to section symbol used to build RVA relocs. */
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;
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;
398 /* Number of relocations. */
399 unsigned int reloc_count;
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 *);
409 /* Write resources to a COFF file. RESOURCES should already be
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. */
418 write_coff_file (const char *filename, const char *target,
419 const rc_res_directory *resources)
423 struct coff_write_info cwi;
427 unsigned long length, offset;
429 if (filename == NULL)
430 fatal (_("filename required for COFF output"));
432 abfd = bfd_openw (filename, target);
434 bfd_fatal (filename);
436 if (! bfd_set_format (abfd, bfd_object))
437 bfd_fatal ("bfd_set_format");
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)");
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)");
454 if (! bfd_set_file_flags (abfd, HAS_SYMS | HAS_RELOC))
455 bfd_fatal ("bfd_set_file_flags");
457 sec = bfd_make_section_with_flags (abfd, ".rsrc",
458 (SEC_HAS_CONTENTS | SEC_ALLOC
459 | SEC_LOAD | SEC_DATA));
461 bfd_fatal ("bfd_make_section");
463 if (! bfd_set_symtab (abfd, sec->symbol_ptr_ptr, 1))
464 bfd_fatal ("bfd_set_symtab");
466 /* Requiring this is probably a bug in BFD. */
467 sec->output_section = sec;
469 /* The order of data in the .rsrc section is
470 resource directory tables and entries
471 resource directory strings
472 resource data entries
475 We build these different types of data in different lists. */
477 set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD);
480 cwi.sympp = sec->symbol_ptr_ptr;
485 cwi.dirs.last = NULL;
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;
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);
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;
507 /* Actually convert the resources to binary. */
508 coff_to_bin (resources, &cwi);
510 /* Add another few bytes to the directory strings if needed for
512 if ((cwi.dirstrs.length & 7) != 0)
514 rc_uint_type pad = 8 - (cwi.dirstrs.length & 7);
517 ex = coff_alloc (& cwi.dirstrs, pad);
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);
527 length = (cwi.dirsize
530 + cwi.resources.length);
532 if (! bfd_set_section_size (abfd, sec, length))
533 bfd_fatal ("bfd_set_section_size");
535 bfd_set_reloc (abfd, sec, cwi.relocs, cwi.reloc_count);
538 for (d = cwi.dirs.d; d != NULL; d = d->next)
540 if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
541 bfd_fatal ("bfd_set_section_contents");
544 for (d = cwi.dirstrs.d; d != NULL; d = d->next)
546 set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
549 for (d = cwi.dataents.d; d != NULL; d = d->next)
551 set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
554 for (rd = cwi.resources.d; rd != NULL; rd = rd->next)
556 res_to_bin (cwi.wrbfd, (rc_uint_type) offset, rd->res);
557 offset += rd->length;
560 assert (offset == length);
562 if (! bfd_close (abfd))
563 bfd_fatal ("bfd_close");
565 /* We allocated the relocs array using malloc. */
569 /* Work out the sizes of the various fixed size resource directory
570 entries. This updates fields in CWI. */
573 coff_bin_sizes (const rc_res_directory *resdir,
574 struct coff_write_info *cwi)
576 const rc_res_entry *re;
578 cwi->dirsize += sizeof (struct extern_res_directory);
580 for (re = resdir->entries; re != NULL; re = re->next)
582 cwi->dirsize += sizeof (struct extern_res_entry);
585 cwi->dirstrsize += re->id.u.n.length * 2 + 2;
588 coff_bin_sizes (re->u.dir, cwi);
590 cwi->dataentsize += sizeof (struct extern_res_data);
594 /* Allocate data for a particular list. */
597 coff_alloc (struct bindata_build *bb, rc_uint_type size)
601 d = (bindata *) reswr_alloc (sizeof (bindata));
604 d->data = (bfd_byte *) reswr_alloc (size);
617 /* Convert the resource directory RESDIR to binary. */
620 coff_to_bin (const rc_res_directory *resdir, struct coff_write_info *cwi)
622 struct extern_res_directory *erd;
624 const rc_res_entry *e;
625 struct extern_res_entry *ere;
627 /* Write out the directory table. */
629 erd = ((struct extern_res_directory *)
630 coff_alloc (&cwi->dirs, sizeof (*erd)));
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);
639 for (e = resdir->entries; e != NULL; e = e->next)
647 windres_put_16 (cwi->wrbfd, erd->name_count, cn);
648 windres_put_16 (cwi->wrbfd, erd->id_count, ci);
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. */
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++)
659 windres_put_32 (cwi->wrbfd, ere->name, e->id.u.id);
665 /* For some reason existing files seem to have the high bit
666 set on the address of the name, although that is not
668 windres_put_32 (cwi->wrbfd, ere->name,
669 0x80000000 | (cwi->dirsize + cwi->dirstrs.length));
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]);
679 windres_put_32 (cwi->wrbfd, ere->rva, 0x80000000 | cwi->dirs.length);
680 coff_to_bin (e->u.dir, cwi);
684 windres_put_32 (cwi->wrbfd, ere->rva,
685 cwi->dirsize + cwi->dirstrsize + cwi->dataents.length);
687 coff_res_to_bin (e->u.res, cwi);
692 /* Convert the resource RES to binary. */
695 coff_res_to_bin (const rc_res_resource *res, struct coff_write_info *cwi)
698 struct extern_res_data *erd;
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. */
708 r = (arelent *) reswr_alloc (sizeof (arelent));
709 r->sym_ptr_ptr = cwi->sympp;
710 r->address = cwi->dirsize + cwi->dirstrsize + cwi->dataents.length;
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"));
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;
722 erd = (struct extern_res_data *) coff_alloc (&cwi->dataents, sizeof (*erd));
724 windres_put_32 (cwi->wrbfd, erd->rva,
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);
732 d = (coff_res_data *) reswr_alloc (sizeof (coff_res_data));
733 d->length = res_to_bin (NULL, (rc_uint_type) 0, res);
737 if (cwi->resources.d == NULL)
738 cwi->resources.d = d;
740 cwi->resources.last->next = d;
742 cwi->resources.last = d;
743 cwi->resources.length += (d->length + 7) & ~7;
745 windres_put_32 (cwi->wrbfd, erd->size, d->length);
747 /* Force the next resource to have 64 bit alignment. */
748 d->length = (d->length + 7) & ~7;