diff options
| -rw-r--r-- | bfd/ChangeLog | 36 | ||||
| -rw-r--r-- | bfd/config.in | 3 | ||||
| -rwxr-xr-x | bfd/configure | 2 | ||||
| -rw-r--r-- | bfd/configure.in | 2 | ||||
| -rw-r--r-- | bfd/peXXigen.c | 1274 |
5 files changed, 1236 insertions, 81 deletions
diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 63865f4..4df87fe 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,39 @@ +2013-12-17 Nick Clifton <nickc@redhat.com> + + * peXXigen.c: Include wchar.h if available. + Include safe-ctype.h. + (HighBitSet, SetHighBit, WithoutHighBit): New macros. + (pe_print_resource_entries): Rename to + rsrc_print_resource_entries. Handle names that are not RVAs. + (pe_print_resource_directory): Rename to + rsrc_print_resource_directory. + (pe_print_rsrc): Rename to rsrc_print_section. Corrupt + computation of RVA bias. + (rsrc_count_entries): New function. + (rsrc_count_directory): New function. + (rsrc_parse_entry): New function. + (rsrc_parse_entries): New function. + (rsrc_parse_directory): New function. + (rsrc_write_string): New function. + (rsrc_compute_rva): New function. + (rsrc_write_leaf): New function. + (rsrc_write_entry): New function. + (rsrc_write_directory): New function. + (u16_mbtouc): New function. + (rsrc_cmp): New function. + (rsrc_print_name): New function. + (rsrc_resource_name): New function. + (rsrc_merge_string_entries): New function. + (rsrc_sort_entries): New function. + (rsrc_attach_chain): New function. + (rsrc_merge): New function. + (rsrc_process_section): New function - merges the contents of a + .rsrc section. + (_bfd_XXi_final_link_postscript): Call rsrc_process_section. + * configure.in (AC_CHECK_HEADERS): Add wchar.h + * config.in: Regenerate. + * configure: Regenerate. + 2013-12-16 Andreas Schwab <schwab@suse.de> * elf64-ppc.c (ppc64_elf_relocate_section): Add newline to error diff --git a/bfd/config.in b/bfd/config.in index 65fb044..3106c28 100644 --- a/bfd/config.in +++ b/bfd/config.in @@ -255,6 +255,9 @@ /* Define to 1 if you have the <unistd.h> header file. */ #undef HAVE_UNISTD_H +/* Define to 1 if you have the <wchar.h> header file. */ +#undef HAVE_WCHAR_H + /* Define if <sys/procfs.h> has win32_pstatus_t. */ #undef HAVE_WIN32_PSTATUS_T diff --git a/bfd/configure b/bfd/configure index 382dd01..bef7295 100755 --- a/bfd/configure +++ b/bfd/configure @@ -12900,7 +12900,7 @@ $as_echo "$bfd_cv_build_exeext" >&6; } fi -for ac_header in alloca.h stddef.h string.h strings.h stdlib.h time.h unistd.h +for ac_header in alloca.h stddef.h string.h strings.h stdlib.h time.h unistd.h wchar.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" diff --git a/bfd/configure.in b/bfd/configure.in index 0d41867..6a029f7 100644 --- a/bfd/configure.in +++ b/bfd/configure.in @@ -210,7 +210,7 @@ AC_SUBST(BFD_HOSTPTR_T) BFD_CC_FOR_BUILD -AC_CHECK_HEADERS(alloca.h stddef.h string.h strings.h stdlib.h time.h unistd.h) +AC_CHECK_HEADERS(alloca.h stddef.h string.h strings.h stdlib.h time.h unistd.h wchar.h) AC_CHECK_HEADERS(fcntl.h sys/file.h sys/time.h sys/stat.h sys/resource.h) GCC_HEADER_STDINT(bfd_stdint.h) AC_HEADER_TIME diff --git a/bfd/peXXigen.c b/bfd/peXXigen.c index b720668..cddb38f 100644 --- a/bfd/peXXigen.c +++ b/bfd/peXXigen.c @@ -62,6 +62,9 @@ #include "libbfd.h" #include "coff/internal.h" #include "bfdver.h" +#ifdef HAVE_WCHAR_H +#include <wchar.h> +#endif /* NOTE: it's strange to be including an architecture specific header in what's supposed to be general (to PE/PEI) code. However, that's @@ -80,6 +83,7 @@ #include "coff/pe.h" #include "libcoff.h" #include "libpei.h" +#include "safe-ctype.h" #if defined COFF_WITH_pep || defined COFF_WITH_pex64 # undef AOUTSZ @@ -87,6 +91,10 @@ # define PEAOUTHDR PEPAOUTHDR #endif +#define HighBitSet(val) ((val) & 0x80000000) +#define SetHighBit(val) ((val) | 0x80000000) +#define WithoutHighBit(val) ((val) & 0x7fffffff) + /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests worked when the code was in peicode.h, but no longer work now that the code is in peigen.c. PowerPC NT is said to be dead. If @@ -1285,9 +1293,10 @@ pe_print_idata (bfd * abfd, void * vfile) if (!member && !member_high) break; - if (member_high & 0x80000000) + if (HighBitSet (member_high)) fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>", - member_high,member, member_high & 0x7fffffff, member); + member_high, member, + WithoutHighBit (member_high), member); else { int ordinal; @@ -1317,9 +1326,9 @@ pe_print_idata (bfd * abfd, void * vfile) if (member == 0) break; - if (member & 0x80000000) + if (HighBitSet (member)) fprintf (file, "\t%04lx\t %4lu <none>", - member, member & 0x7fffffff); + member, WithoutHighBit (member)); else { int ordinal; @@ -1990,20 +1999,21 @@ pe_print_reloc (bfd * abfd, void * vfile) return TRUE; } + static bfd_byte * -pe_print_resource_directory (FILE * , bfd *, unsigned int, - bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma); +rsrc_print_resource_directory (FILE * , bfd *, unsigned int, + bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma); static bfd_byte * -pe_print_resource_entries (FILE * file, - bfd * abfd, - unsigned int indent, - bfd_boolean is_name, - bfd_byte * data, - bfd_byte * datastart, - bfd_byte * dataend, - bfd_vma rva_bias) +rsrc_print_resource_entries (FILE * file, + bfd * abfd, + unsigned int indent, + bfd_boolean is_name, + bfd_byte * datastart, + bfd_byte * data, + bfd_byte * dataend, + bfd_vma rva_bias) { unsigned long entry, addr, size; @@ -2015,65 +2025,81 @@ pe_print_resource_entries (FILE * file, entry = (long) bfd_get_32 (abfd, data); if (is_name) { - if (datastart + entry < dataend) + bfd_byte * name; + + /* Note - the documenation says that this field is an RVA value + but windres appears to produce a section relative offset with + the top bit set. Support both styles for now. */ + if (HighBitSet (entry)) + name = datastart + WithoutHighBit (entry); + else + name = datastart + entry - rva_bias; + + if (name + 2 < dataend) { unsigned int len; - len = bfd_get_16 (abfd, datastart + entry); + len = bfd_get_16 (abfd, name); - fprintf (file, _("name: %08lx [%d:]"), entry, len); - if (datastart + entry - rva_bias + 2 + len < dataend) - fprintf (file, "%.*s", len, (char *) (datastart + entry - rva_bias + 2)); + fprintf (file, _("name: [val: %08lx len %d]: "), entry, len); + if (name + 2 + len * 2 < dataend) + { + /* This strange loop is to cope with multibyte characters. */ + while (len --) + { + name += 2; + fprintf (file, "%.1s", name); + } + } else - fprintf (file, _("<corrupt>")); + fprintf (file, _("<corrupt string length: %#x>"), len); } else - fprintf (file, _("<corrupt>")); + fprintf (file, _("<corrupt string offset: %#lx>"), entry); } else fprintf (file, _("ID: %#08lx"), entry); entry = (long) bfd_get_32 (abfd, data + 4); - fprintf (file, _(", Value: %#08lx"), entry); + fprintf (file, _(", Value: %#08lx\n"), entry); - if (entry & 0x80000000) - { - fprintf (file, _(" sub-table:\n")); - return pe_print_resource_directory (file, abfd, indent + 1, - datastart + (entry & 0x7fffffff), - datastart, dataend, rva_bias); - } + if (HighBitSet (entry)) + return rsrc_print_resource_directory (file, abfd, indent + 1, + datastart, + datastart + WithoutHighBit (entry), + dataend, rva_bias); if (datastart + entry + 16 >= dataend) - { - fprintf (file, "\n"); - return dataend + 1; - } + return dataend + 1; - fprintf (file, _(" leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"), + fprintf (file, _("%*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"), + indent, " ", addr = (long) bfd_get_32 (abfd, datastart + entry), size = (long) bfd_get_32 (abfd, datastart + entry + 4), (int) bfd_get_32 (abfd, datastart + entry + 8)); - + /* Check that the reserved entry is 0. */ if (bfd_get_32 (abfd, datastart + entry + 12) != 0 /* And that the data address/size is valid too. */ - || (datastart + addr - rva_bias + size > dataend)) + || (datastart + (addr - rva_bias) + size > dataend)) return dataend + 1; - return datastart + addr - rva_bias + size; + return datastart + (addr - rva_bias) + size; } +#define max(a,b) ((a) > (b) ? (a) : (b)) +#define min(a,b) ((a) < (b) ? (a) : (b)) + static bfd_byte * -pe_print_resource_directory (FILE * file, - bfd * abfd, - unsigned int indent, - bfd_byte * data, - bfd_byte * datastart, - bfd_byte * dataend, - bfd_vma rva_bias) +rsrc_print_resource_directory (FILE * file, + bfd * abfd, + unsigned int indent, + bfd_byte * datastart, + bfd_byte * data, + bfd_byte * dataend, + bfd_vma rva_bias) { unsigned int num_names, num_ids; - bfd_byte * enddata = data; + bfd_byte * highest_data = data; if (data + 16 >= dataend) return dataend + 1; @@ -2096,37 +2122,31 @@ pe_print_resource_directory (FILE * file, num_ids = (int) bfd_get_16 (abfd, data + 14)); data += 16; - if (num_names) + while (num_names --) { - while (num_names --) - { - bfd_byte * ndata; - ndata = pe_print_resource_entries (file, abfd, indent + 1, TRUE, - data, datastart, dataend, rva_bias); - data += 8; - if (ndata > enddata) - enddata = ndata; - if (ndata >= dataend) - break; - } + bfd_byte * entry_end; + + entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE, + datastart, data, dataend, rva_bias); + data += 8; + highest_data = max (highest_data, entry_end); + if (entry_end >= dataend) + return entry_end; } - if (num_ids) + while (num_ids --) { - while (num_ids --) - { - bfd_byte * ndata; - ndata = pe_print_resource_entries (file, abfd, indent + 1, FALSE, - data, datastart, dataend, rva_bias); - data += 8; - if (ndata > enddata) - enddata = ndata; - if (ndata >= dataend) - break; - } + bfd_byte * entry_end; + + entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE, + datastart, data, dataend, rva_bias); + data += 8; + highest_data = max (highest_data, entry_end); + if (entry_end >= dataend) + return entry_end; } - return enddata > data ? enddata : data; + return max (highest_data, data); } /* Display the contents of a .rsrc section. We do not try to @@ -2134,7 +2154,7 @@ pe_print_resource_directory (FILE * file, the tables in a human readable format. */ static bfd_boolean -pe_print_rsrc (bfd * abfd, void * vfile) +rsrc_print_section (bfd * abfd, void * vfile) { bfd_vma rva_bias; pe_data_type * pe; @@ -2147,20 +2167,20 @@ pe_print_rsrc (bfd * abfd, void * vfile) pe = pe_data (abfd); - if (pe == NULL) + if (pe == NULL) return TRUE; - section = bfd_get_section_by_name (abfd, ".rsrc"); - if (section == NULL) + section = bfd_get_section_by_name (abfd, ".rsrc"); + if (section == NULL) return TRUE; rva_bias = section->vma - pe->pe_opthdr.ImageBase; - + datasize = section->size; if (datasize == 0) return TRUE; - if (! bfd_malloc_and_get_section (abfd, section, &data)) + if (! bfd_malloc_and_get_section (abfd, section, & data)) { if (data != NULL) free (data); @@ -2174,7 +2194,9 @@ pe_print_rsrc (bfd * abfd, void * vfile) while (data < dataend) { - data = pe_print_resource_directory (file, abfd, 0, data, data, dataend, rva_bias); + bfd_byte * p = data; + + data = rsrc_print_resource_directory (file, abfd, 0, data, data, dataend, rva_bias); if (data == dataend + 1) fprintf (file, _("Corrupt .rsrc section detected!\n")); @@ -2182,8 +2204,9 @@ pe_print_rsrc (bfd * abfd, void * vfile) { /* Align data before continuing. */ int align = (1 << section->alignment_power) - 1; + data = (bfd_byte *) (((long) (data + align)) & ~ align); - rva_bias += data - datastart; + rva_bias += data - p; /* For reasons that are unclear .rsrc sections are sometimes created aligned to a 1^3 boundary even when their alignment is set at @@ -2196,6 +2219,7 @@ pe_print_rsrc (bfd * abfd, void * vfile) } } + free (datastart); return TRUE; } @@ -2373,7 +2397,7 @@ _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile) pe_print_pdata (abfd, vfile); pe_print_reloc (abfd, vfile); - pe_print_rsrc (abfd, vfile); + rsrc_print_section (abfd, vfile); return TRUE; } @@ -2479,6 +2503,1096 @@ sort_x64_pdata (const void *l, const void *r) return 0; } #endif + +/* Functions to process a .rsrc section. */ + +static unsigned int sizeof_leaves; +static unsigned int sizeof_strings; +static unsigned int sizeof_tables_and_entries; + +static bfd_byte * +rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma); + +static bfd_byte * +rsrc_count_entries (bfd * abfd, + bfd_boolean is_name, + bfd_byte * datastart, + bfd_byte * data, + bfd_byte * dataend, + bfd_vma rva_bias) +{ + unsigned long entry, addr, size; + + if (data + 8 >= dataend) + return dataend + 1; + + if (is_name) + { + bfd_byte * name; + + entry = (long) bfd_get_32 (abfd, data); + + if (HighBitSet (entry)) + name = datastart + WithoutHighBit (entry); + else + name = datastart + entry - rva_bias; + + if (name + 2 >= dataend) + return dataend + 1; + + unsigned int len = bfd_get_16 (abfd, name); + if (len == 0 || len > 256) + return dataend + 1; + + sizeof_strings += (len + 1) * 2; + } + + entry = (long) bfd_get_32 (abfd, data + 4); + + if (HighBitSet (entry)) + return rsrc_count_directory (abfd, + datastart, + datastart + WithoutHighBit (entry), + dataend, rva_bias); + + if (datastart + entry + 16 >= dataend) + return dataend + 1; + + addr = (long) bfd_get_32 (abfd, datastart + entry); + size = (long) bfd_get_32 (abfd, datastart + entry + 4); + + sizeof_leaves += 16; + + return datastart + addr - rva_bias + size; +} + +static bfd_byte * +rsrc_count_directory (bfd * abfd, + bfd_byte * datastart, + bfd_byte * data, + bfd_byte * dataend, + bfd_vma rva_bias) +{ + unsigned int num_entries, num_ids; + bfd_byte * highest_data = data; + + if (data + 16 >= dataend) + return dataend + 1; + + num_entries = (int) bfd_get_16 (abfd, data + 12); + num_ids = (int) bfd_get_16 (abfd, data + 14); + + num_entries += num_ids; + + data += 16; + sizeof_tables_and_entries += 16; + + while (num_entries --) + { + bfd_byte * entry_end; + + entry_end = rsrc_count_entries (abfd, num_entries >= num_ids, + datastart, data, dataend, rva_bias); + data += 8; + sizeof_tables_and_entries += 8; + highest_data = max (highest_data, entry_end); + if (entry_end >= dataend) + break; + } + + return max (highest_data, data); +} + +typedef struct rsrc_dir_chain +{ + unsigned int num_entries; + struct rsrc_entry * first_entry; + struct rsrc_entry * last_entry; +} rsrc_dir_chain; + +typedef struct rsrc_directory +{ + unsigned int characteristics; + unsigned int time; + unsigned int major; + unsigned int minor; + + rsrc_dir_chain names; + rsrc_dir_chain ids; + + struct rsrc_entry * entry; +} rsrc_directory; + +typedef struct rsrc_string +{ + unsigned int len; + bfd_byte * string; +} rsrc_string; + +typedef struct rsrc_leaf +{ + unsigned int size; + unsigned int codepage; + bfd_byte * data; +} rsrc_leaf; + +typedef struct rsrc_entry +{ + bfd_boolean is_name; + union + { + unsigned int id; + struct rsrc_string name; + } name_id; + + bfd_boolean is_dir; + union + { + struct rsrc_directory * directory; + struct rsrc_leaf * leaf; + } value; + + struct rsrc_entry * next_entry; + struct rsrc_directory * parent; +} rsrc_entry; + +static bfd_byte * +rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *, + bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *); + +static bfd_byte * +rsrc_parse_entry (bfd * abfd, + bfd_boolean is_name, + rsrc_entry * entry, + bfd_byte * datastart, + bfd_byte * data, + bfd_byte * dataend, + bfd_vma rva_bias, + rsrc_directory * parent) +{ + unsigned long val, addr, size; + + val = bfd_get_32 (abfd, data); + + entry->parent = parent; + entry->is_name = is_name; + + if (is_name) + { + /* FIXME: Add range checking ? */ + if (HighBitSet (val)) + { + val = WithoutHighBit (val); + + entry->name_id.name.len = bfd_get_16 (abfd, datastart + val); + entry->name_id.name.string = datastart + val + 2; + } + else + { + entry->name_id.name.len = bfd_get_16 (abfd, datastart + val - rva_bias); + entry->name_id.name.string = datastart + val - rva_bias + 2; + } + } + else + entry->name_id.id = val; + + val = bfd_get_32 (abfd, data + 4); + + if (HighBitSet (val)) + { + entry->is_dir = TRUE; + entry->value.directory = bfd_malloc (sizeof * entry->value.directory); + if (entry->value.directory == NULL) + return dataend; + + return rsrc_parse_directory (abfd, entry->value.directory, + datastart, + datastart + WithoutHighBit (val), + dataend, rva_bias, entry); + } + + entry->is_dir = FALSE; + entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf); + if (entry->value.leaf == NULL) + return dataend; + + addr = bfd_get_32 (abfd, datastart + val); + size = entry->value.leaf->size = bfd_get_32 (abfd, datastart + val + 4); + entry->value.leaf->codepage = bfd_get_32 (abfd, datastart + val + 8); + + entry->value.leaf->data = bfd_malloc (size); + if (entry->value.leaf->data == NULL) + return dataend; + + memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size); + return datastart + (addr - rva_bias) + size; +} + +static bfd_byte * +rsrc_parse_entries (bfd * abfd, + rsrc_dir_chain * chain, + bfd_boolean is_name, + bfd_byte * highest_data, + bfd_byte * datastart, + bfd_byte * data, + bfd_byte * dataend, + bfd_vma rva_bias, + rsrc_directory * parent) +{ + rsrc_entry * entry; + + if (chain->num_entries == 0) + { + chain->first_entry = chain->last_entry = NULL; + return highest_data; + } + + entry = bfd_malloc (sizeof * entry); + if (entry == NULL) + return dataend; + + chain->first_entry = entry; + + unsigned int i; + for (i = chain->num_entries; i--;) + { + bfd_byte * entry_end; + + entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart, + data, dataend, rva_bias, parent); + data += 8; + highest_data = max (entry_end, highest_data); + if (entry_end > dataend) + return dataend; + + if (i) + { + entry->next_entry = bfd_malloc (sizeof * entry); + entry = entry->next_entry; + if (entry == NULL) + return dataend; + } + else + entry->next_entry = NULL; + } + + chain->last_entry = entry; + + return highest_data; +} + +static bfd_byte * +rsrc_parse_directory (bfd * abfd, + rsrc_directory * table, + bfd_byte * datastart, + bfd_byte * data, + bfd_byte * dataend, + bfd_vma rva_bias, + rsrc_entry * entry) +{ + bfd_byte * highest_data = data; + + if (table == NULL) + return dataend; + + table->characteristics = bfd_get_32 (abfd, data); + table->time = bfd_get_32 (abfd, data + 4); + table->major = bfd_get_16 (abfd, data + 8); + table->minor = bfd_get_16 (abfd, data + 10); + table->names.num_entries = bfd_get_16 (abfd, data + 12); + table->ids.num_entries = bfd_get_16 (abfd, data + 14); + table->entry = entry; + + data += 16; + + highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data, + datastart, data, dataend, rva_bias, table); + data += table->names.num_entries * 8; + + highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data, + datastart, data, dataend, rva_bias, table); + data += table->ids.num_entries * 8; + + return max (highest_data, data); +} + +typedef struct rsrc_write_data +{ + bfd * abfd; + bfd_byte * datastart; + bfd_byte * next_table; + bfd_byte * next_leaf; + bfd_byte * next_string; + bfd_byte * next_data; + bfd_vma rva_bias; +} rsrc_write_data; + +static void +rsrc_write_string (rsrc_write_data * data, + rsrc_string * string) +{ + bfd_put_16 (data->abfd, string->len, data->next_string); + memcpy (data->next_string + 2, string->string, string->len * 2); + data->next_string += (string->len + 1) * 2; +} + +static inline unsigned int +rsrc_compute_rva (rsrc_write_data * data, + bfd_byte * addr) +{ + return (addr - data->datastart) + data->rva_bias; +} + +static void +rsrc_write_leaf (rsrc_write_data * data, + rsrc_leaf * leaf) +{ + bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data), data->next_leaf); + bfd_put_32 (data->abfd, leaf->size, data->next_leaf + 4); + bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8); + bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12); + data->next_leaf += 16; + + memcpy (data->next_data, leaf->data, leaf->size); + data->next_data += leaf->size; +} + +static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *); + +static void +rsrc_write_entry (rsrc_write_data * data, + bfd_byte * where, + rsrc_entry * entry) +{ + if (entry->is_name) + { + bfd_put_32 (data->abfd, + SetHighBit (data->next_string - data->datastart), + where); + rsrc_write_string (data, & entry->name_id.name); + } + else + bfd_put_32 (data->abfd, entry->name_id.id, where); + + if (entry->is_dir) + { + bfd_put_32 (data->abfd, + SetHighBit (data->next_table - data->datastart), + where + 4); + rsrc_write_directory (data, entry->value.directory); + } + else + { + bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4); + rsrc_write_leaf (data, entry->value.leaf); + } +} + +static void +rsrc_write_directory (rsrc_write_data * data, + rsrc_directory * dir) +{ + rsrc_entry * entry; + unsigned int i; + + bfd_put_32 (data->abfd, dir->characteristics, data->next_table); + bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4); + bfd_put_16 (data->abfd, dir->major, data->next_table + 8); + bfd_put_16 (data->abfd, dir->minor, data->next_table + 10); + bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12); + bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14); + + /* Compute where the entries and the next table will be placed. */ + bfd_byte * next_entry = data->next_table + 16; + data->next_table = next_entry + (dir->names.num_entries * 8) + (dir->ids.num_entries * 8); + bfd_byte * nt = data->next_table; + + /* Write the entries. */ + for (i = dir->names.num_entries, entry = dir->names.first_entry; + i > 0 && entry != NULL; + i--, entry = entry->next_entry) + { + rsrc_write_entry (data, next_entry, entry); + next_entry += 8; + } + BFD_ASSERT (i == 0); + BFD_ASSERT (entry == NULL); + + for (i = dir->ids.num_entries, entry = dir->ids.first_entry; + i > 0 && entry != NULL; + i--, entry = entry->next_entry) + { + rsrc_write_entry (data, next_entry, entry); + next_entry += 8; + } + BFD_ASSERT (i == 0); + BFD_ASSERT (entry == NULL); + BFD_ASSERT (nt == next_entry); +} + +#ifdef HAVE_WCHAR_H +/* Return the length (number of units) of the first character in S, + putting its 'ucs4_t' representation in *PUC. */ + +static unsigned int +u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n) +{ + unsigned short c = * s; + + if (c < 0xd800 || c >= 0xe000) + { + *puc = c; + return 1; + } + + if (c < 0xdc00) + { + if (n >= 2) + { + if (s[1] >= 0xdc00 && s[1] < 0xe000) + { + *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00); + return 2; + } + } + else + { + /* Incomplete multibyte character. */ + *puc = 0xfffd; + return n; + } + } + + /* Invalid multibyte character. */ + *puc = 0xfffd; + return 1; +} +#endif /* HAVE_WCHAR_H */ + +/* Perform a comparison of two entries. */ +static signed int +rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b) +{ + if (! is_name) + return a->name_id.id - b->name_id.id; + + /* We have to perform a case insenstive, unicode string comparison... */ + int res; + +#ifdef __CYGWIN__ + /* Under Cygwin unicode == UTF-16 == wchar_t. + FIXME: The same is true for MingGW - we should test for that too. */ + res = wcsncasecmp ((const wchar_t *) astring + 2, (const wchar_t *) bstring + 2, min (alen, blen)); +#elif defined HAVE_WCHAR_H + unsigned int i; + bfd_byte * astring = a->name_id.name.string; + unsigned int alen = a->name_id.name.len; + bfd_byte * bstring = b->name_id.name.string; + unsigned int blen = b->name_id.name.len; + + res = 0; + for (i = min (alen, blen); i--; astring += 2, bstring += 2) + { + wchar_t awc; + wchar_t bwc; + + /* Convert UTF-16 unicode characters into wchar_t characters so + that we can then perform a case insensitive comparison. */ + int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2); + int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2); + + if (Alen != Blen) + return Alen - Blen; + res = wcsncasecmp (& awc, & bwc, 1); + if (res) + break; + } +#else + res = memcmp (astring + 2, bstring + 2, min (alen, blen) * 2); +#endif + + if (res == 0) + res = alen - blen; + + return res; +} + +static void +rsrc_print_name (char * buffer, rsrc_string string) +{ + unsigned int i; + bfd_byte * name = string.string; + + for (i = string.len; i--; name += 2) + sprintf (buffer + strlen (buffer), "%.1s", name); +} + +static const char * +rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir) +{ + static char buffer [256]; + bfd_boolean is_string = FALSE; + + buffer[0] = 0; + + if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL && dir->entry->parent->entry != NULL) + { + strcpy (buffer, "type: "); + if (dir->entry->parent->entry->is_name) + rsrc_print_name (buffer + strlen (buffer), dir->entry->parent->entry->name_id.name); + else + { + unsigned int id = dir->entry->parent->entry->name_id.id; + + sprintf (buffer + strlen (buffer), "%x", id); + switch (id) + { + case 1: strcat (buffer, " (CURSOR)"); break; + case 2: strcat (buffer, " (BITMAP)"); break; + case 3: strcat (buffer, " (ICON)"); break; + case 4: strcat (buffer, " (MENU)"); break; + case 5: strcat (buffer, " (DIALOG)"); break; + case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break; + case 7: strcat (buffer, " (FONTDIR)"); break; + case 8: strcat (buffer, " (FONT)"); break; + case 9: strcat (buffer, " (ACCELERATOR)"); break; + case 10: strcat (buffer, " (RCDATA)"); break; + case 11: strcat (buffer, " (MESSAGETABLE)"); break; + case 12: strcat (buffer, " (GROUP_CURSOR)"); break; + case 14: strcat (buffer, " (GROUP_ICON)"); break; + case 16: strcat (buffer, " (VERSION)"); break; + case 17: strcat (buffer, " (DLGINCLUDE)"); break; + case 19: strcat (buffer, " (PLUGPLAY)"); break; + case 20: strcat (buffer, " (VXD)"); break; + case 21: strcat (buffer, " (ANICURSOR)"); break; + case 22: strcat (buffer, " (ANIICON)"); break; + case 23: strcat (buffer, " (HTML)"); break; + case 24: strcat (buffer, " (MANIFEST)"); break; + case 240: strcat (buffer, " (DLGINIT)"); break; + case 241: strcat (buffer, " (TOOLBAR)"); break; + } + } + } + + if (dir != NULL && dir->entry != NULL) + { + strcat (buffer, " name: "); + if (dir->entry->is_name) + rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name); + else + { + unsigned int id = dir->entry->name_id.id; + + sprintf (buffer + strlen (buffer), "%x", id); + + if (is_string) + sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)", + (id - 1) << 4, (id << 4) - 1); + } + } + + if (entry != NULL) + { + strcat (buffer, " lang: "); + + if (entry->is_name) + rsrc_print_name (buffer + strlen (buffer), entry->name_id.name); + else + sprintf (buffer + strlen (buffer), "%x", entry->name_id.id); + } + + return buffer; +} + +/* *sigh* Windows resource strings are special. Only the top 28-bits of + their ID is stored in the NAME entry. The bottom four bits are used as + an index into unicode string table that makes up the data of the leaf. + So identical type-name-lang string resources may not actually be + identical at all. + + This function is called when we have detected two string resources with + match top-28-bit IDs. We have to scan the string tables inside the leaves + and discover if there are any real collisions. If there are then we report + them and return FALSE. Otherwise we copy any strings from B into A and then + return TRUE. */ + +static bfd_boolean +rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED, + rsrc_entry * b ATTRIBUTE_UNUSED) +{ + unsigned int copy_needed = 0; + unsigned int i; + + /* Step one: Find out what we have to do. */ + BFD_ASSERT (! a->is_dir); + bfd_byte * astring = a->value.leaf->data; + + BFD_ASSERT (! b->is_dir); + bfd_byte * bstring = b->value.leaf->data; + + for (i = 0; i < 16; i++) + { + unsigned int alen = astring[0] + (astring[1] << 8); + unsigned int blen = bstring[0] + (bstring[1] << 8); + + if (alen == 0) + { + copy_needed += blen * 2; + } + else if (blen == 0) + ; + else if (alen != blen) + /* FIXME: Should we continue the loop in order to report other duplicates ? */ + break; + /* alen == blen != 0. We might have two identical strings. If so we + can ignore the second one. There is no need for wchar_t vs UTF-16 + theatrics here - we are only interested in (case sensitive) equality. */ + else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0) + break; + + astring += (alen + 1) * 2; + bstring += (blen + 1) * 2; + } + + if (i != 16) + { + if (a->parent != NULL + && a->parent->entry != NULL + && a->parent->entry->is_name == FALSE) + _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"), + ((a->parent->entry->name_id.id - 1) << 4) + i); + return FALSE; + } + + if (copy_needed == 0) + return TRUE; + + /* If we reach here then A and B must both have non-colliding strings. + (We never get string resources with fully empty string tables). + We need to allocate an extra COPY_NEEDED bytes in A and then bring + in B's strings. */ + bfd_byte * new_data = bfd_malloc (a->value.leaf->size + copy_needed); + if (new_data == NULL) + return FALSE; + + bfd_byte * nstring = new_data; + astring = a->value.leaf->data; + bstring = b->value.leaf->data; + + for (i = 0; i < 16; i++) + { + unsigned int alen = astring[0] + (astring[1] << 8); + unsigned int blen = bstring[0] + (bstring[1] << 8); + + if (alen != 0) + { + memcpy (nstring, astring, (alen + 1) * 2); + nstring += (alen + 1) * 2; + } + else if (blen != 0) + { + memcpy (nstring, bstring, (blen + 1) * 2); + nstring += (blen + 1) * 2; + } + else + { + * nstring++ = 0; + * nstring++ = 0; + } + + astring += (alen + 1) * 2; + bstring += (blen + 1) * 2; + } + + BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed)); + + free (a->value.leaf->data); + a->value.leaf->data = new_data; + a->value.leaf->size += copy_needed; + + return TRUE; +} + +static void rsrc_merge (rsrc_entry *, rsrc_entry *); + +/* Sort the entries in given part of the directory. + We use an old fashioned bubble sort because we are dealing + with lists and we want to handle matches specially. */ + +static void +rsrc_sort_entries (rsrc_dir_chain * chain, + bfd_boolean is_name, + rsrc_directory * dir) +{ + rsrc_entry * entry; + rsrc_entry * next; + rsrc_entry ** points_to_entry; + bfd_boolean swapped; + + if (chain->num_entries < 2) + return; + + do + { + swapped = FALSE; + points_to_entry = & chain->first_entry; + entry = * points_to_entry; + next = entry->next_entry; + + do + { + signed int cmp = rsrc_cmp (is_name, entry, next); + + if (cmp > 0) + { + entry->next_entry = next->next_entry; + next->next_entry = entry; + * points_to_entry = next; + points_to_entry = & next->next_entry; + next = entry->next_entry; + swapped = TRUE; + } + else if (cmp == 0) + { + if (entry->is_dir && next->is_dir) + { + /* When we encounter identical directory entries we have to + merge them together. The exception to this rule is for + resource manifests - there can only be one of these, + even if they differ in language. Zero-language manifests + are assumed to be default manifests (provided by the + cygwin build system) and these can be silently dropped, + unless that would reduce the number of manifests to zero. + There should only ever be one non-zero lang manifest - + if there are more it is an error. A non-zero lang + manifest takes precedence over a default manifest. */ + if (entry->is_name == FALSE + && entry->name_id.id == 1 + && dir != NULL + && dir->entry != NULL + && dir->entry->is_name == FALSE + && dir->entry->name_id.id == 0x18) + { + if (next->value.directory->names.num_entries == 0 + && next->value.directory->ids.num_entries == 1 + && next->value.directory->ids.first_entry->is_name == FALSE + && next->value.directory->ids.first_entry->name_id.id == 0) + /* Fall through so that NEXT is dropped. */ + ; + else if (entry->value.directory->names.num_entries == 0 + && entry->value.directory->ids.num_entries == 1 + && entry->value.directory->ids.first_entry->is_name == FALSE + && entry->value.directory->ids.first_entry->name_id.id == 0) + { + /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */ + entry->next_entry = next->next_entry; + next->next_entry = entry; + * points_to_entry = next; + points_to_entry = & next->next_entry; + next = entry->next_entry; + swapped = TRUE; + } + else + { + _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests")); + bfd_set_error (bfd_error_file_truncated); + return; + } + + /* Unhook NEXT from the chain. */ + /* FIXME: memory loss here. */ + entry->next_entry = next->next_entry; + chain->num_entries --; + if (chain->num_entries < 2) + return; + next = next->next_entry; + } + else + rsrc_merge (entry, next); + } + else if (entry->is_dir != next->is_dir) + { + _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf")); + bfd_set_error (bfd_error_file_truncated); + return; + } + else + { + /* Otherwise with identical leaves we issue an error + message - because there should never be duplicates. + The exception is Type 18/Name 1/Lang 0 which is the + defaul manifest - this can just be dropped. */ + if (entry->is_name == FALSE + && entry->name_id.id == 0 + && dir != NULL + && dir->entry != NULL + && dir->entry->is_name == FALSE + && dir->entry->name_id.id == 1 + && dir->entry->parent != NULL + && dir->entry->parent->entry != NULL + && dir->entry->parent->entry->is_name == FALSE + && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */) + ; + else if (dir != NULL + && dir->entry != NULL + && dir->entry->parent != NULL + && dir->entry->parent->entry != NULL + && dir->entry->parent->entry->is_name == FALSE + && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */) + { + /* Strings need special handling. */ + if (! rsrc_merge_string_entries (entry, next)) + { + /* _bfd_error_handler should have been called inside merge_strings. */ + bfd_set_error (bfd_error_file_truncated); + return; + } + } + else + { + if (dir == NULL + || dir->entry == NULL + || dir->entry->parent == NULL + || dir->entry->parent->entry == NULL) + _bfd_error_handler (_(".rsrc merge failure: duplicate leaf")); + else + _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"), + rsrc_resource_name (entry, dir)); + bfd_set_error (bfd_error_file_truncated); + return; + } + } + + /* Unhook NEXT from the chain. */ + entry->next_entry = next->next_entry; + chain->num_entries --; + if (chain->num_entries < 2) + return; + next = next->next_entry; + } + else + { + points_to_entry = & entry->next_entry; + entry = next; + next = next->next_entry; + } + } + while (next); + + chain->last_entry = entry; + } + while (swapped); +} + +/* Attach B's chain onto A. */ +static void +rsrc_attach_chain (struct rsrc_dir_chain * achain, struct rsrc_dir_chain * bchain) +{ + if (bchain->num_entries == 0) + return; + + achain->num_entries += bchain->num_entries; + + if (achain->first_entry == NULL) + { + achain->first_entry = bchain->first_entry; + achain->last_entry = bchain->last_entry; + } + else + { + achain->last_entry->next_entry = bchain->first_entry; + achain->last_entry = bchain->last_entry; + } + + bchain->num_entries = 0; + bchain->first_entry = bchain->last_entry = NULL; +} + +static void +rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b) +{ + BFD_ASSERT (a->is_dir); + BFD_ASSERT (b->is_dir); + + rsrc_directory * adir = a->value.directory; + rsrc_directory * bdir = b->value.directory; + + if (adir->characteristics != bdir->characteristics) + { + _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n")); + bfd_set_error (bfd_error_file_truncated); + return; + } + + if (adir->major != bdir->major || adir->minor != bdir->minor) + { + _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n")); + bfd_set_error (bfd_error_file_truncated); + return; + } + + /* Attach B's name chain to A. */ + rsrc_attach_chain (& adir->names, & bdir->names); + + /* Attach B's ID chain to A. */ + rsrc_attach_chain (& adir->ids, & bdir->ids); + + /* Now sort A's entries. */ + rsrc_sort_entries (& adir->names, TRUE, adir); + rsrc_sort_entries (& adir->ids, FALSE, adir); +} + +/* Check the .rsrc section. If it contains multiple concatenated + resources then we must merge them properly. Otherwise Windows + will ignore all but the first set. */ + +static void +rsrc_process_section (bfd * abfd, + struct coff_final_link_info * pfinfo) +{ + rsrc_directory new_table; + bfd_size_type size; + asection * sec; + + new_table.names.num_entries = 0; + new_table.ids.num_entries = 0; + + sec = bfd_get_section_by_name (abfd, ".rsrc"); + if (sec == NULL || (size = sec->rawsize) == 0) + return; + + pe_data_type * pe = pe_data (abfd); + if (pe == NULL) + return; + + bfd_vma rva_bias; + rva_bias = sec->vma - pe->pe_opthdr.ImageBase; + + bfd_byte * data = bfd_malloc (size); + if (data == NULL) + return; + + bfd_byte * datastart = data; + + if (! bfd_get_section_contents (abfd, sec, data, 0, size)) + goto end; + + /* Step one: Walk the section, computing the size of the tables, + leaves and data and decide if we need to do anything. */ + bfd_byte * dataend = data + size; + unsigned int num_resource_sets = 0; + sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0; + + while (data < dataend) + { + bfd_byte * p = data; + + data = rsrc_count_directory (abfd, data, data, dataend, rva_bias); + if (data > dataend) + { + /* Corrupted .rsrc section - cannot merge. */ + _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"), + bfd_get_filename (abfd)); + bfd_set_error (bfd_error_file_truncated); + goto end; + } + + /* Align the data pointer - we assume 1^2 alignment. */ + data = (bfd_byte *) (((long) (data + 3)) & ~ 3); + rva_bias += data - p; + + if (data == (dataend - 4)) + data = dataend; + + ++ num_resource_sets; + } + + if (num_resource_sets < 2) + /* No merging necessary. */ + goto end; + + /* Step two: Walk the data again, building trees of the resources. */ + data = datastart; + rva_bias = sec->vma - pe->pe_opthdr.ImageBase; + + rsrc_directory * type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables); + if (type_tables == NULL) + goto end; + + unsigned int index = 0; + while (data < dataend) + { + bfd_byte * p = data; + + data = rsrc_parse_directory (abfd, type_tables + index, data, data, dataend, + rva_bias, NULL); + data = (bfd_byte *) (((long) (data + 3)) & ~ 3); + rva_bias += data - p; + if (data == (dataend - 4)) + data = dataend; + index ++; + } + BFD_ASSERT (index == num_resource_sets); + + /* Step three: Merge the top level tables (there can be only one). + + We must ensure that the merged entries are in ascending order. + + We also thread the top level table entries from the old tree onto + the new table, so that they can be pulled off later. */ + + /* FIXME: Should we verify that all type tables are the same ? */ + new_table.characteristics = type_tables[0].characteristics; + new_table.time = type_tables[0].time; + new_table.major = type_tables[0].major; + new_table.minor = type_tables[0].minor; + + /* Chain the NAME entries onto the table. */ + new_table.names.first_entry = NULL; + new_table.names.last_entry = NULL; + + for (index = 0; index < num_resource_sets; index++) + rsrc_attach_chain (& new_table.names, & type_tables[index].names); + + rsrc_sort_entries (& new_table.names, TRUE, & new_table); + + /* Chain the ID entries onto the table. */ + new_table.ids.first_entry = NULL; + new_table.ids.last_entry = NULL; + + for (index = 0; index < num_resource_sets; index++) + rsrc_attach_chain (& new_table.ids, & type_tables[index].ids); + + rsrc_sort_entries (& new_table.ids, FALSE, & new_table); + + /* Step four: Create new contents for the .rsrc section. */ + bfd_byte * new_data = bfd_malloc (size); + if (new_data == NULL) + goto end; + + rsrc_write_data write_data; + + write_data.abfd = abfd; + write_data.datastart = new_data; + write_data.next_table = new_data; + write_data.next_leaf = new_data + sizeof_tables_and_entries; + write_data.next_string = write_data.next_leaf + sizeof_leaves; + write_data.next_data = write_data.next_string + sizeof_strings; + + write_data.rva_bias = sec->vma - pe->pe_opthdr.ImageBase; + + rsrc_write_directory (& write_data, & new_table); + + /* Step five: Replace the old contents with the new. + We recompute the size as we may have lost entries due to mergeing. */ + size = ((write_data.next_data - new_data) + 3) & ~3; + bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size); + sec->size = sec->rawsize = size; + + end: + /* FIXME: Free the resource tree, if we have one. */ + free (datastart); +} /* Handle the .idata section and other things that need symbol table access. */ @@ -2689,6 +3803,8 @@ _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo) } #endif + rsrc_process_section (abfd, pfinfo); + /* If we couldn't find idata$2, we either have an excessively trivial program or are in DEEP trouble; we have to assume trivial program.... */ |