+ bfd_vma rva_bias;
+ pe_data_type * pe;
+ FILE * file = (FILE *) vfile;
+ bfd_size_type datasize;
+ asection * section;
+ bfd_byte * data;
+ rsrc_regions regions;
+
+ pe = pe_data (abfd);
+ if (pe == NULL)
+ return TRUE;
+
+ section = bfd_get_section_by_name (abfd, ".rsrc");
+ if (section == NULL)
+ return TRUE;
+ if (!(section->flags & SEC_HAS_CONTENTS))
+ return TRUE;
+
+ datasize = section->size;
+ if (datasize == 0)
+ return TRUE;
+
+ rva_bias = section->vma - pe->pe_opthdr.ImageBase;
+
+ if (! bfd_malloc_and_get_section (abfd, section, & data))
+ {
+ free (data);
+ return FALSE;
+ }
+
+ regions.section_start = data;
+ regions.section_end = data + datasize;
+ regions.strings_start = NULL;
+ regions.resource_start = NULL;
+
+ fflush (file);
+ fprintf (file, "\nThe .rsrc Resource Directory section:\n");
+
+ while (data < regions.section_end)
+ {
+ bfd_byte * p = data;
+
+ data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
+
+ if (data == regions.section_end + 1)
+ fprintf (file, _("Corrupt .rsrc section detected!\n"));
+ else
+ {
+ /* Align data before continuing. */
+ int align = (1 << section->alignment_power) - 1;
+
+ data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
+ 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
+ 1^2. Catch that case here before we issue a spurious warning
+ message. */
+ if (data == (regions.section_end - 4))
+ data = regions.section_end;
+ else if (data < regions.section_end)
+ {
+ /* If the extra data is all zeros then do not complain.
+ This is just padding so that the section meets the
+ page size requirements. */
+ while (++ data < regions.section_end)
+ if (*data != 0)
+ break;
+ if (data < regions.section_end)
+ fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
+ }
+ }
+ }
+
+ if (regions.strings_start != NULL)
+ fprintf (file, _(" String table starts at offset: %#03x\n"),
+ (int) (regions.strings_start - regions.section_start));
+ if (regions.resource_start != NULL)
+ fprintf (file, _(" Resources start at offset: %#03x\n"),
+ (int) (regions.resource_start - regions.section_start));
+
+ free (regions.section_start);
+ return TRUE;
+}
+
+#define IMAGE_NUMBEROF_DEBUG_TYPES 17
+
+static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
+{
+ "Unknown",
+ "COFF",
+ "CodeView",
+ "FPO",
+ "Misc",
+ "Exception",
+ "Fixup",
+ "OMAP-to-SRC",
+ "OMAP-from-SRC",
+ "Borland",
+ "Reserved",
+ "CLSID",
+ "Feature",
+ "CoffGrp",
+ "ILTCG",
+ "MPX",
+ "Repro",
+};
+
+static bfd_boolean
+pe_print_debugdata (bfd * abfd, void * vfile)
+{
+ FILE *file = (FILE *) vfile;
+ pe_data_type *pe = pe_data (abfd);
+ struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
+ asection *section;
+ bfd_byte *data = 0;
+ bfd_size_type dataoff;
+ unsigned int i, j;
+
+ bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
+ bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
+
+ if (size == 0)
+ return TRUE;
+
+ addr += extra->ImageBase;
+ for (section = abfd->sections; section != NULL; section = section->next)
+ {
+ if ((addr >= section->vma) && (addr < (section->vma + section->size)))
+ break;
+ }
+
+ if (section == NULL)
+ {
+ fprintf (file,
+ _("\nThere is a debug directory, but the section containing it could not be found\n"));
+ return TRUE;
+ }
+ else if (!(section->flags & SEC_HAS_CONTENTS))
+ {
+ fprintf (file,
+ _("\nThere is a debug directory in %s, but that section has no contents\n"),
+ section->name);
+ return TRUE;
+ }
+ else if (section->size < size)
+ {
+ fprintf (file,
+ _("\nError: section %s contains the debug data starting address but it is too small\n"),
+ section->name);
+ return FALSE;
+ }
+
+ fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
+ section->name, (unsigned long) addr);
+
+ dataoff = addr - section->vma;
+
+ if (size > (section->size - dataoff))
+ {
+ fprintf (file, _("The debug data size field in the data directory is too big for the section"));
+ return FALSE;
+ }
+
+ fprintf (file,
+ _("Type Size Rva Offset\n"));
+
+ /* Read the whole section. */
+ if (!bfd_malloc_and_get_section (abfd, section, &data))
+ {
+ free (data);
+ return FALSE;
+ }
+
+ for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
+ {
+ const char *type_name;
+ struct external_IMAGE_DEBUG_DIRECTORY *ext
+ = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
+ struct internal_IMAGE_DEBUG_DIRECTORY idd;
+
+ _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
+
+ if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
+ type_name = debug_type_names[0];
+ else
+ type_name = debug_type_names[idd.Type];
+
+ fprintf (file, " %2ld %14s %08lx %08lx %08lx\n",
+ idd.Type, type_name, idd.SizeOfData,
+ idd.AddressOfRawData, idd.PointerToRawData);
+
+ if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
+ {
+ char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
+ /* PR 17512: file: 065-29434-0.001:0.1
+ We need to use a 32-bit aligned buffer
+ to safely read in a codeview record. */
+ char buffer[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO);
+
+ CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
+
+ /* The debug entry doesn't have to have to be in a section,
+ in which case AddressOfRawData is 0, so always use PointerToRawData. */
+ if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
+ idd.SizeOfData, cvinfo))
+ continue;
+
+ for (j = 0; j < cvinfo->SignatureLength; j++)
+ sprintf (&signature[j*2], "%02x", cvinfo->Signature[j] & 0xff);
+
+ /* xgettext:c-format */
+ fprintf (file, _("(format %c%c%c%c signature %s age %ld)\n"),
+ buffer[0], buffer[1], buffer[2], buffer[3],
+ signature, cvinfo->Age);
+ }
+ }
+
+ free(data);
+
+ if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
+ fprintf (file,
+ _("The debug directory size is not a multiple of the debug directory entry size\n"));
+
+ return TRUE;
+}
+
+static bfd_boolean
+pe_is_repro (bfd * abfd)
+{
+ pe_data_type *pe = pe_data (abfd);
+ struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
+ asection *section;
+ bfd_byte *data = 0;
+ bfd_size_type dataoff;
+ unsigned int i;
+ bfd_boolean res = FALSE;
+
+ bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
+ bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
+
+ if (size == 0)
+ return FALSE;
+
+ addr += extra->ImageBase;
+ for (section = abfd->sections; section != NULL; section = section->next)
+ {
+ if ((addr >= section->vma) && (addr < (section->vma + section->size)))
+ break;
+ }
+
+ if ((section == NULL)
+ || (!(section->flags & SEC_HAS_CONTENTS))
+ || (section->size < size))
+ {
+ return FALSE;
+ }
+
+ dataoff = addr - section->vma;
+
+ if (size > (section->size - dataoff))
+ {
+ return FALSE;
+ }
+
+ if (!bfd_malloc_and_get_section (abfd, section, &data))
+ {
+ free (data);
+ return FALSE;
+ }
+
+ for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
+ {
+ struct external_IMAGE_DEBUG_DIRECTORY *ext
+ = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
+ struct internal_IMAGE_DEBUG_DIRECTORY idd;
+
+ _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
+
+ if (idd.Type == PE_IMAGE_DEBUG_TYPE_REPRO)
+ {
+ res = TRUE;
+ break;
+ }
+ }
+
+ free(data);
+
+ return res;
+}
+
+/* Print out the program headers. */
+
+bfd_boolean
+_bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
+{
+ FILE *file = (FILE *) vfile;
+ int j;
+ pe_data_type *pe = pe_data (abfd);
+ struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
+ const char *subsystem_name = NULL;
+ const char *name;
+
+ /* The MS dumpbin program reportedly ands with 0xff0f before
+ printing the characteristics field. Not sure why. No reason to
+ emulate it here. */
+ fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
+#undef PF
+#define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
+ PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
+ PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
+ PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
+ PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
+ PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
+ PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
+ PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
+ PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
+ PF (IMAGE_FILE_SYSTEM, "system file");
+ PF (IMAGE_FILE_DLL, "DLL");
+ PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
+#undef PF
+
+ /*
+ If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
+ timestamp is to be interpreted as the hash of a reproducible build.
+ */
+ if (pe_is_repro (abfd))
+ {
+ fprintf (file, "\nTime/Date\t\t%08lx", pe->coff.timestamp);
+ fprintf (file, "\t(This is a reproducible build file hash, not a timestamp)\n");
+ }
+ else
+ {
+ /* ctime implies '\n'. */
+ time_t t = pe->coff.timestamp;
+ fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
+ }
+
+#ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
+# define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
+#endif
+#ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
+# define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
+#endif
+#ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
+# define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
+#endif
+
+ switch (i->Magic)
+ {
+ case IMAGE_NT_OPTIONAL_HDR_MAGIC:
+ name = "PE32";
+ break;
+ case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
+ name = "PE32+";
+ break;
+ case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
+ name = "ROM";
+ break;
+ default:
+ name = NULL;
+ break;
+ }
+ fprintf (file, "Magic\t\t\t%04x", i->Magic);
+ if (name)
+ fprintf (file, "\t(%s)",name);
+ fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
+ fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
+ fprintf (file, "SizeOfCode\t\t");
+ bfd_fprintf_vma (abfd, file, i->SizeOfCode);
+ fprintf (file, "\nSizeOfInitializedData\t");
+ bfd_fprintf_vma (abfd, file, i->SizeOfInitializedData);
+ fprintf (file, "\nSizeOfUninitializedData\t");
+ bfd_fprintf_vma (abfd, file, i->SizeOfUninitializedData);
+ fprintf (file, "\nAddressOfEntryPoint\t");
+ bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
+ fprintf (file, "\nBaseOfCode\t\t");
+ bfd_fprintf_vma (abfd, file, i->BaseOfCode);
+#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
+ /* PE32+ does not have BaseOfData member! */
+ fprintf (file, "\nBaseOfData\t\t");
+ bfd_fprintf_vma (abfd, file, i->BaseOfData);
+#endif
+
+ fprintf (file, "\nImageBase\t\t");
+ bfd_fprintf_vma (abfd, file, i->ImageBase);
+ fprintf (file, "\nSectionAlignment\t%08x\n", i->SectionAlignment);
+ fprintf (file, "FileAlignment\t\t%08x\n", i->FileAlignment);
+ fprintf (file, "MajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
+ fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
+ fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
+ fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
+ fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
+ fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
+ fprintf (file, "Win32Version\t\t%08x\n", i->Reserved1);
+ fprintf (file, "SizeOfImage\t\t%08x\n", i->SizeOfImage);
+ fprintf (file, "SizeOfHeaders\t\t%08x\n", i->SizeOfHeaders);
+ fprintf (file, "CheckSum\t\t%08x\n", i->CheckSum);
+
+ switch (i->Subsystem)
+ {
+ case IMAGE_SUBSYSTEM_UNKNOWN:
+ subsystem_name = "unspecified";
+ break;
+ case IMAGE_SUBSYSTEM_NATIVE:
+ subsystem_name = "NT native";
+ break;
+ case IMAGE_SUBSYSTEM_WINDOWS_GUI:
+ subsystem_name = "Windows GUI";
+ break;
+ case IMAGE_SUBSYSTEM_WINDOWS_CUI:
+ subsystem_name = "Windows CUI";
+ break;
+ case IMAGE_SUBSYSTEM_POSIX_CUI:
+ subsystem_name = "POSIX CUI";
+ break;
+ case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
+ subsystem_name = "Wince CUI";
+ break;
+ // These are from UEFI Platform Initialization Specification 1.1.
+ case IMAGE_SUBSYSTEM_EFI_APPLICATION:
+ subsystem_name = "EFI application";
+ break;
+ case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
+ subsystem_name = "EFI boot service driver";
+ break;
+ case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
+ subsystem_name = "EFI runtime driver";
+ break;
+ case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
+ subsystem_name = "SAL runtime driver";
+ break;
+ // This is from revision 8.0 of the MS PE/COFF spec
+ case IMAGE_SUBSYSTEM_XBOX:
+ subsystem_name = "XBOX";
+ break;
+ // Added default case for clarity - subsystem_name is NULL anyway.
+ default:
+ subsystem_name = NULL;
+ }
+
+ fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
+ if (subsystem_name)
+ fprintf (file, "\t(%s)", subsystem_name);
+ fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
+ fprintf (file, "SizeOfStackReserve\t");
+ bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
+ fprintf (file, "\nSizeOfStackCommit\t");
+ bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
+ fprintf (file, "\nSizeOfHeapReserve\t");
+ bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
+ fprintf (file, "\nSizeOfHeapCommit\t");
+ bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
+ fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
+ fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
+ (unsigned long) i->NumberOfRvaAndSizes);
+
+ fprintf (file, "\nThe Data Directory\n");
+ for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
+ {
+ fprintf (file, "Entry %1x ", j);
+ bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
+ fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
+ fprintf (file, "%s\n", dir_names[j]);
+ }
+
+ pe_print_idata (abfd, vfile);
+ pe_print_edata (abfd, vfile);
+ if (bfd_coff_have_print_pdata (abfd))
+ bfd_coff_print_pdata (abfd, vfile);
+ else
+ pe_print_pdata (abfd, vfile);
+ pe_print_reloc (abfd, vfile);
+ pe_print_debugdata (abfd, file);
+
+ rsrc_print_section (abfd, vfile);
+
+ return TRUE;
+}
+
+static bfd_boolean
+is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
+{
+ bfd_vma addr = * (bfd_vma *) obj;
+ return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
+}
+
+static asection *
+find_section_by_vma (bfd *abfd, bfd_vma addr)
+{
+ return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
+}
+
+/* Copy any private info we understand from the input bfd
+ to the output bfd. */
+
+bfd_boolean
+_bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
+{
+ pe_data_type *ipe, *ope;
+
+ /* One day we may try to grok other private data. */
+ if (ibfd->xvec->flavour != bfd_target_coff_flavour
+ || obfd->xvec->flavour != bfd_target_coff_flavour)
+ return TRUE;
+
+ ipe = pe_data (ibfd);
+ ope = pe_data (obfd);
+
+ /* pe_opthdr is copied in copy_object. */
+ ope->dll = ipe->dll;
+
+ /* Don't copy input subsystem if output is different from input. */
+ if (obfd->xvec != ibfd->xvec)
+ ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
+
+ /* For strip: if we removed .reloc, we'll make a real mess of things
+ if we don't remove this entry as well. */
+ if (! pe_data (obfd)->has_reloc_section)
+ {
+ pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
+ pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
+ }
+
+ /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
+ But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
+ won't be added. */
+ if (! pe_data (ibfd)->has_reloc_section
+ && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
+ pe_data (obfd)->dont_strip_reloc = 1;
+
+ memcpy (ope->dos_message, ipe->dos_message, sizeof (ope->dos_message));
+
+ /* The file offsets contained in the debug directory need rewriting. */
+ if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
+ {
+ bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
+ + ope->pe_opthdr.ImageBase;
+ asection *section = find_section_by_vma (obfd, addr);
+ bfd_byte *data;
+
+ if (section && bfd_malloc_and_get_section (obfd, section, &data))
+ {
+ unsigned int i;
+ struct external_IMAGE_DEBUG_DIRECTORY *dd =
+ (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
+
+ /* PR 17512: file: 0f15796a. */
+ if ((unsigned long) ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
+ > section->size - (addr - section->vma))
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler
+ (_("%pB: Data Directory size (%lx) "
+ "exceeds space left in section (%" PRIx64 ")"),
+ obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size,
+ (uint64_t) (section->size - (addr - section->vma)));
+ free (data);
+ return FALSE;
+ }
+
+ for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
+ / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
+ {
+ asection *ddsection;
+ struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
+ struct internal_IMAGE_DEBUG_DIRECTORY idd;
+
+ _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
+
+ if (idd.AddressOfRawData == 0)
+ continue; /* RVA 0 means only offset is valid, not handled yet. */
+
+ ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
+ if (!ddsection)
+ continue; /* Not in a section! */
+
+ idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
+ + ope->pe_opthdr.ImageBase) - ddsection->vma;
+
+ _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
+ }
+
+ if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
+ {
+ _bfd_error_handler (_("failed to update file offsets in debug directory"));
+ free (data);
+ return FALSE;
+ }
+ free (data);
+ }
+ else if (section)
+ {
+ _bfd_error_handler (_("%pB: failed to read debug data section"), obfd);
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+/* Copy private section data. */
+
+bfd_boolean
+_bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
+ asection *isec,
+ bfd *obfd,
+ asection *osec)
+{
+ if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
+ || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
+ return TRUE;
+
+ if (coff_section_data (ibfd, isec) != NULL
+ && pei_section_data (ibfd, isec) != NULL)
+ {
+ if (coff_section_data (obfd, osec) == NULL)
+ {
+ size_t amt = sizeof (struct coff_section_tdata);
+ osec->used_by_bfd = bfd_zalloc (obfd, amt);
+ if (osec->used_by_bfd == NULL)
+ return FALSE;
+ }
+
+ if (pei_section_data (obfd, osec) == NULL)
+ {
+ size_t amt = sizeof (struct pei_section_tdata);
+ coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
+ if (coff_section_data (obfd, osec)->tdata == NULL)
+ return FALSE;
+ }
+
+ pei_section_data (obfd, osec)->virt_size =
+ pei_section_data (ibfd, isec)->virt_size;
+ pei_section_data (obfd, osec)->pe_flags =
+ pei_section_data (ibfd, isec)->pe_flags;
+ }
+
+ return TRUE;
+}
+
+void
+_bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
+{
+ coff_get_symbol_info (abfd, symbol, ret);
+}
+
+#if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
+static int
+sort_x64_pdata (const void *l, const void *r)
+{
+ const char *lp = (const char *) l;
+ const char *rp = (const char *) r;
+ bfd_vma vl, vr;
+ vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
+ if (vl != vr)
+ return (vl < vr ? -1 : 1);
+ /* We compare just begin address. */
+ return 0;
+}
+#endif
+\f
+/* 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 || name < datastart)
+ return dataend + 1;
+
+ unsigned int len = bfd_get_16 (abfd, name);
+ if (len == 0 || len > 256)
+ return dataend + 1;
+ }
+
+ entry = (long) bfd_get_32 (abfd, data + 4);
+
+ if (HighBitSet (entry))
+ {
+ data = datastart + WithoutHighBit (entry);
+
+ if (data <= datastart || data >= dataend)
+ return dataend + 1;
+
+ return rsrc_count_directory (abfd, datastart, data, 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);
+
+ 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;
+
+ while (num_entries --)
+ {
+ bfd_byte * entry_end;
+
+ entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
+ datastart, data, dataend, rva_bias);
+ data += 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)
+ {
+ bfd_byte * address;
+
+ if (HighBitSet (val))
+ {
+ val = WithoutHighBit (val);
+
+ address = datastart + val;
+ }
+ else
+ {
+ address = datastart + val - rva_bias;
+ }
+
+ if (address + 3 > dataend)
+ return dataend;
+
+ entry->name_id.name.len = bfd_get_16 (abfd, address);
+ entry->name_id.name.string = address + 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;
+
+ data = datastart + val;
+ if (data < datastart || data >= dataend)
+ return dataend;
+
+ addr = bfd_get_32 (abfd, data);
+ size = entry->value.leaf->size = bfd_get_32 (abfd, data + 4);
+ entry->value.leaf->codepage = bfd_get_32 (abfd, data + 8);
+ /* FIXME: We assume that the reserved field (data + 12) is OK. */
+
+ 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)
+{
+ unsigned int i;
+ 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;
+
+ 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);
+ /* An undocumented feature of Windows resources is that each unit
+ of raw data is 8-byte aligned... */
+ data->next_data += ((leaf->size + 7) & ~7);
+}
+
+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_compute_region_sizes (rsrc_directory * dir)
+{
+ struct rsrc_entry * entry;
+
+ if (dir == NULL)
+ return;
+
+ sizeof_tables_and_entries += 16;
+
+ for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
+ {
+ sizeof_tables_and_entries += 8;
+
+ sizeof_strings += (entry->name_id.name.len + 1) * 2;
+
+ if (entry->is_dir)
+ rsrc_compute_region_sizes (entry->value.directory);
+ else
+ sizeof_leaves += 16;
+ }
+
+ for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
+ {
+ sizeof_tables_and_entries += 8;
+
+ if (entry->is_dir)
+ rsrc_compute_region_sizes (entry->value.directory);
+ else
+ sizeof_leaves += 16;
+ }
+}
+
+static void
+rsrc_write_directory (rsrc_write_data * data,
+ rsrc_directory * dir)
+{
+ rsrc_entry * entry;
+ unsigned int i;
+ bfd_byte * next_entry;
+ bfd_byte * nt;
+
+ 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. */
+ next_entry = data->next_table + 16;
+ data->next_table = next_entry + (dir->names.num_entries * 8)
+ + (dir->ids.num_entries * 8);
+ 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)
+ {
+ BFD_ASSERT (entry->is_name);
+ 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)
+ {
+ BFD_ASSERT (! entry->is_name);
+ rsrc_write_entry (data, next_entry, entry);
+ next_entry += 8;
+ }
+ BFD_ASSERT (i == 0);
+ BFD_ASSERT (entry == NULL);
+ BFD_ASSERT (nt == next_entry);
+}
+
+#if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
+/* Return the length (number of units) of the first character in S,
+ putting its 'ucs4_t' representation in *PUC. */
+
+static unsigned int
+#if defined HAVE_WCTYPE_H
+u16_mbtouc (wint_t * puc, const unsigned short * s, unsigned int n)
+#else
+u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
+#endif
+{
+ 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 and not Cygwin/Mingw */
+
+/* Perform a comparison of two entries. */
+static signed int
+rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
+{
+ signed int res;
+ bfd_byte * astring;
+ unsigned int alen;
+ bfd_byte * bstring;
+ unsigned int blen;
+
+ if (! is_name)
+ return a->name_id.id - b->name_id.id;
+
+ /* We have to perform a case insenstive, unicode string comparison... */
+ astring = a->name_id.name.string;
+ alen = a->name_id.name.len;
+ bstring = b->name_id.name.string;
+ blen = b->name_id.name.len;
+
+#if defined __CYGWIN__ || defined __MINGW32__
+ /* Under Windows hosts (both Cygwin and Mingw types),
+ unicode == UTF-16 == wchar_t. The case insensitive string comparison
+ function however goes by different names in the two environments... */
+
+#undef rscpcmp
+#ifdef __CYGWIN__
+#define rscpcmp wcsncasecmp
+#endif
+#ifdef __MINGW32__
+#define rscpcmp wcsnicmp
+#endif
+
+ res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
+ min (alen, blen));
+
+#elif defined HAVE_WCHAR_H
+ {
+ unsigned int i;
+
+ res = 0;
+ for (i = min (alen, blen); i--; astring += 2, bstring += 2)
+ {
+#if defined HAVE_WCTYPE_H
+ wint_t awc;
+ wint_t bwc;
+#else
+ wchar_t awc;
+ wchar_t bwc;
+#endif
+
+ /* Convert UTF-16 unicode characters into wchar_t characters
+ so that we can then perform a case insensitive comparison. */
+ unsigned int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
+ unsigned int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
+
+ if (Alen != Blen)
+ return Alen - Blen;
+
+#ifdef HAVE_WCTYPE_H
+ awc = towlower (awc);
+ bwc = towlower (bwc);
+
+ res = awc - bwc;
+#else
+ res = wcsncasecmp (& awc, & bwc, 1);
+#endif
+ if (res)
+ break;
+ }
+ }
+#else
+ /* Do the best we can - a case sensitive, untranslated comparison. */
+ res = memcmp (astring, bstring, min (alen, blen) * 2);