/* Support for the generic parts of PE/PEI; the common executable parts.
- Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 1995-2014 Free Software Foundation, Inc.
Written by Cygnus Solutions.
This file is part of BFD, the Binary File Descriptor library.
#include "bfd.h"
#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
#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
# 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
they will be handled somewhat correctly in the bfd code. */
if (in->n_sclass == C_SECTION)
{
+ char namebuf[SYMNMLEN + 1];
+ const char *name = NULL;
+
in->n_value = 0x0;
/* Create synthetic empty sections as needed. DJ */
{
asection *sec;
- for (sec = abfd->sections; sec; sec = sec->next)
- {
- if (strcmp (sec->name, in->n_name) == 0)
- {
- in->n_scnum = sec->target_index;
- break;
- }
- }
+ name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
+ if (name == NULL)
+ /* FIXME: Return error. */
+ abort ();
+ sec = bfd_get_section_by_name (abfd, name);
+ if (sec != NULL)
+ in->n_scnum = sec->target_index;
}
if (in->n_scnum == 0)
{
int unused_section_number = 0;
asection *sec;
- char *name;
flagword flags;
for (sec = abfd->sections; sec; sec = sec->next)
if (unused_section_number <= sec->target_index)
unused_section_number = sec->target_index + 1;
- name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
- if (name == NULL)
- return;
- strcpy (name, in->n_name);
+ if (name == namebuf)
+ {
+ name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
+ if (name == NULL)
+ /* FIXME: Return error. */
+ abort ();
+ strcpy ((char *) name, namebuf);
+ }
flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
+ if (sec == NULL)
+ /* FIXME: Return error. */
+ abort ();
sec->vma = 0;
sec->lma = 0;
_bfd_XXi_swap_aux_in (bfd * abfd,
void * ext1,
int type,
- int class,
+ int in_class,
int indx ATTRIBUTE_UNUSED,
int numaux ATTRIBUTE_UNUSED,
void * in1)
AUXENT *ext = (AUXENT *) ext1;
union internal_auxent *in = (union internal_auxent *) in1;
- switch (class)
+ switch (in_class)
{
case C_FILE:
if (ext->x_file.x_fname[0] == 0)
in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
- if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
+ if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
+ || ISTAG (in_class))
{
in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
_bfd_XXi_swap_aux_out (bfd * abfd,
void * inp,
int type,
- int class,
+ int in_class,
int indx ATTRIBUTE_UNUSED,
int numaux ATTRIBUTE_UNUSED,
void * extp)
memset (ext, 0, AUXESZ);
- switch (class)
+ switch (in_class)
{
case C_FILE:
if (in->x_file.x_fname[0] == 0)
H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
- if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
+ if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
+ || ISTAG (in_class))
{
PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
{
int idx;
- for (idx = 0; idx < 16; idx++)
+ for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
{
/* If data directory is empty, rva also should be 0. */
int size =
PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
bfd_vma sa, fa, ib;
IMAGE_DATA_DIRECTORY idata2, idata5, tls;
-
- if (pe->force_minimum_alignment)
- {
- if (!extra->FileAlignment)
- extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
- if (!extra->SectionAlignment)
- extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
- }
-
- if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
- extra->Subsystem = pe->target_subsystem;
sa = extra->SectionAlignment;
fa = extra->FileAlignment;
idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
-
+
if (aouthdr_in->tsize)
{
aouthdr_in->text_start -= ib;
extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
- /* First null out all data directory entries. */
- memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
-
add_data_entry (abfd, extra, 0, ".edata", ib);
add_data_entry (abfd, extra, 2, ".rsrc", ib);
add_data_entry (abfd, extra, 3, ".pdata", ib);
/* Until other .idata fixes are made (pending patch), the entry for
.idata is needed for backwards compatibility. FIXME. */
add_data_entry (abfd, extra, 1, ".idata", ib);
-
+
/* For some reason, the virtual size (which is what's set by
add_data_entry) for .reloc is not the same as the size recorded
in this slot by MSVC; it doesn't seem to cause problems (so far),
H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
-#define LINKER_VERSION 256 /* That is, 2.56 */
+/* e.g. 219510000 is linker version 2.19 */
+#define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
/* This piece of magic sets the "linker version" field to
LINKER_VERSION. */
struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
- if (pe_data (abfd)->has_reloc_section)
+ if (pe_data (abfd)->has_reloc_section
+ || pe_data (abfd)->dont_strip_reloc)
filehdr_in->f_flags &= ~F_RELFLG;
if (pe_data (abfd)->dll)
H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
- H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
+ /* Only use a real timestamp if the option was chosen. */
+ if ((pe_data (abfd)->insert_timestamp))
+ H_PUT_32 (abfd, time(0), filehdr_out->f_timdat);
+
PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
filehdr_out->f_symptr);
H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
(0x02000000). Also, the resource data should also be read and
writable. */
- /* FIXME: Alignment is also encoded in this field, at least on PPC and
+ /* FIXME: Alignment is also encoded in this field, at least on PPC and
ARM-WINCE. Although - how do we get the original alignment field
back ? */
unsigned long must_have;
}
pe_required_section_flags;
-
+
pe_required_section_flags known_sections [] =
{
{ ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
section->name, (unsigned long) addr);
dataoff = addr - section->vma;
- datasize -= dataoff;
#ifdef POWERPC_LE_PE
if (rel_section != 0 && rel_section->size != 0)
adj = section->vma - extra->ImageBase;
/* Print all image import descriptors. */
- for (i = 0; i < datasize; i += onaline)
+ for (i = dataoff; i + onaline <= datasize; i += onaline)
{
bfd_vma hint_addr;
bfd_vma time_stamp;
char *dll;
/* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
- fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
- hint_addr = bfd_get_32 (abfd, data + i + dataoff);
- time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
- forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
- dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
- first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
+ fprintf (file, " %08lx\t", (unsigned long) (i + adj));
+ hint_addr = bfd_get_32 (abfd, data + i);
+ time_stamp = bfd_get_32 (abfd, data + i + 4);
+ forward_chain = bfd_get_32 (abfd, data + i + 8);
+ dll_name = bfd_get_32 (abfd, data + i + 12);
+ first_thunk = bfd_get_32 (abfd, data + i + 16);
fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
(unsigned long) hint_addr,
bfd_vma ft_addr;
bfd_size_type ft_datasize;
int ft_idx;
- int ft_allocated = 0;
+ int ft_allocated;
fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
idx = hint_addr - adj;
-
+
ft_addr = first_thunk + extra->ImageBase;
- ft_data = data;
ft_idx = first_thunk - adj;
- ft_allocated = 0;
+ ft_data = data + ft_idx;
+ ft_datasize = datasize - ft_idx;
+ ft_allocated = 0;
if (first_thunk != hint_addr)
{
ft_section != NULL;
ft_section = ft_section->next)
{
- ft_datasize = ft_section->size;
if (ft_addr >= ft_section->vma
- && ft_addr < ft_section->vma + ft_datasize)
+ && ft_addr < ft_section->vma + ft_section->size)
break;
}
/* Now check to see if this section is the same as our current
section. If it is not then we will have to load its data in. */
- if (ft_section == section)
- {
- ft_data = data;
- ft_idx = first_thunk - adj;
- }
- else
+ if (ft_section != section)
{
ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
- ft_data = bfd_malloc (datasize);
+ ft_datasize = ft_section->size - ft_idx;
+ ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
if (ft_data == NULL)
continue;
- /* Read datasize bfd_bytes starting at offset ft_idx. */
- if (! bfd_get_section_contents
- (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
+ /* Read ft_datasize bytes starting at offset ft_idx. */
+ if (!bfd_get_section_contents (abfd, ft_section, ft_data,
+ (bfd_vma) ft_idx, ft_datasize))
{
free (ft_data);
continue;
}
-
- ft_idx = 0;
ft_allocated = 1;
}
}
/* Print HintName vector entries. */
#ifdef COFF_WITH_pex64
- for (j = 0; j < datasize; j += 8)
+ for (j = 0; idx + j + 8 <= datasize; j += 8)
{
unsigned long member = bfd_get_32 (abfd, data + idx + j);
unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
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;
table holds actual addresses. */
if (time_stamp != 0
&& first_thunk != 0
- && first_thunk != hint_addr)
+ && first_thunk != hint_addr
+ && j + 4 <= ft_datasize)
fprintf (file, "\t%04lx",
- (unsigned long) bfd_get_32 (abfd, ft_data + ft_idx + j));
+ (unsigned long) bfd_get_32 (abfd, ft_data + j));
fprintf (file, "\n");
}
#else
- for (j = 0; j < datasize; j += 4)
+ for (j = 0; idx + j + 4 <= datasize; j += 4)
{
unsigned long member = bfd_get_32 (abfd, data + idx + j);
- /* Print single IMAGE_IMPORT_BY_NAME vector. */
+ /* Print single IMAGE_IMPORT_BY_NAME vector. */
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;
table holds actual addresses. */
if (time_stamp != 0
&& first_thunk != 0
- && first_thunk != hint_addr)
+ && first_thunk != hint_addr
+ && j + 4 <= ft_datasize)
fprintf (file, "\t%04lx",
- (unsigned long) bfd_get_32 (abfd, ft_data + ft_idx + j));
+ (unsigned long) bfd_get_32 (abfd, ft_data + j));
fprintf (file, "\n");
}
fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
section->name, (unsigned long) addr);
- data = bfd_malloc (datasize);
+ data = (bfd_byte *) bfd_malloc (datasize);
if (data == NULL)
return FALSE;
fprintf (file,
_("Name \t\t\t\t"));
- fprintf_vma (file, edt.name);
+ bfd_fprintf_vma (abfd, file, edt.name);
fprintf (file,
" %s\n", data + edt.name - adj);
fprintf (file,
_("\tExport Address Table \t\t"));
- fprintf_vma (file, edt.eat_addr);
+ bfd_fprintf_vma (abfd, file, edt.eat_addr);
fprintf (file, "\n");
fprintf (file,
_("\tName Pointer Table \t\t"));
- fprintf_vma (file, edt.npt_addr);
+ bfd_fprintf_vma (abfd, file, edt.npt_addr);
fprintf (file, "\n");
fprintf (file,
_("\tOrdinal Table \t\t\t"));
- fprintf_vma (file, edt.ot_addr);
+ bfd_fprintf_vma (abfd, file, edt.ot_addr);
fprintf (file, "\n");
/* The next table to find is the Export Address Table. It's basically
/* This really is architecture dependent. On IA-64, a .pdata entry
consists of three dwords containing relative virtual addresses that
specify the start and end address of the code range the entry
- covers and the address of the corresponding unwind info data.
+ covers and the address of the corresponding unwind info data.
On ARM and SH-4, a compressed PDATA structure is used :
_IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
bfd_vma eh_handler;
bfd_vma eh_data;
bfd_vma prolog_end_addr;
+#if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
int em_data;
+#endif
if (i + PDATA_ROW_SIZE > stop)
break;
/* We are probably into the padding of the section now. */
break;
+#if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
+#endif
eh_handler &= ~(bfd_vma) 0x3;
prolog_end_addr &= ~(bfd_vma) 0x3;
fputc (' ', file);
- fprintf_vma (file, i + section->vma); fputc ('\t', file);
- fprintf_vma (file, begin_addr); fputc (' ', file);
- fprintf_vma (file, end_addr); fputc (' ', file);
- fprintf_vma (file, eh_handler);
+ bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
+ bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
+ bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
+ bfd_fprintf_vma (abfd, file, eh_handler);
#if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
fputc (' ', file);
- fprintf_vma (file, eh_data); fputc (' ', file);
- fprintf_vma (file, prolog_end_addr);
+ bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
+ bfd_fprintf_vma (abfd, file, prolog_end_addr);
fprintf (file, " %x", em_data);
#endif
if (storage < 0)
return NULL;
if (storage)
- sy = bfd_malloc (storage);
+ sy = (asymbol **) bfd_malloc (storage);
psc->symcount = bfd_canonicalize_symtab (abfd, sy);
if (psc->symcount < 0)
bfd_size_type i;
bfd_size_type start, stop;
int onaline = PDATA_ROW_SIZE;
- struct sym_cache sym_cache = {0, 0} ;
+ struct sym_cache cache = {0, 0} ;
if (section == NULL
|| coff_section_data (abfd, section) == NULL
bfd_vma other_data;
bfd_vma prolog_length, function_length;
int flag32bit, exception_flag;
- bfd_byte *tdata = 0;
asection *tsection;
if (i + PDATA_ROW_SIZE > stop)
exception_flag = (int)((other_data & 0x80000000) >> 31);
fputc (' ', file);
- fprintf_vma (file, i + section->vma); fputc ('\t', file);
- fprintf_vma (file, begin_addr); fputc (' ', file);
- fprintf_vma (file, prolog_length); fputc (' ', file);
- fprintf_vma (file, function_length); fputc (' ', file);
+ bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
+ bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
+ bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
+ bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
fprintf (file, "%2d %2d ", flag32bit, exception_flag);
/* Get the exception handler's address and the data passed from the
if (tsection && coff_section_data (abfd, tsection)
&& pei_section_data (abfd, tsection))
{
- if (bfd_malloc_and_get_section (abfd, tsection, & tdata))
- {
- int xx = (begin_addr - 8) - tsection->vma;
+ bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
+ bfd_byte *tdata;
- tdata = bfd_malloc (8);
- if (bfd_get_section_contents (abfd, tsection, tdata, (bfd_vma) xx, 8))
+ tdata = (bfd_byte *) bfd_malloc (8);
+ if (tdata)
+ {
+ if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
{
bfd_vma eh, eh_data;
fprintf (file, "%08x", (unsigned int) eh_data);
if (eh != 0)
{
- const char *s = my_symbol_for_address (abfd, eh, &sym_cache);
+ const char *s = my_symbol_for_address (abfd, eh, &cache);
if (s)
fprintf (file, " (%s) ", s);
}
free (tdata);
}
- else
- {
- if (tdata)
- free (tdata);
- }
}
fprintf (file, "\n");
free (data);
- cleanup_syms (& sym_cache);
+ cleanup_syms (& cache);
return TRUE;
#undef PDATA_ROW_SIZE
}
-#ifdef COFF_WITH_pex64
-/* The PE+ x64 variant. */
-bfd_boolean
-_bfd_pex64_print_pdata (bfd *abfd, void *vfile)
-{
-# define PDATA_ROW_SIZE (3 * 4)
- FILE *file = (FILE *) vfile;
- bfd_byte *data = NULL;
- asection *section = bfd_get_section_by_name (abfd, ".pdata");
- bfd_size_type datasize = 0;
- bfd_size_type i;
- bfd_size_type start, stop;
- int onaline = PDATA_ROW_SIZE;
- struct sym_cache sym_cache = {0, 0};
-
- if (section == NULL
- || coff_section_data (abfd, section) == NULL
- || pei_section_data (abfd, section) == NULL)
- return TRUE;
-
- stop = pei_section_data (abfd, section)->virt_size;
- if ((stop % onaline) != 0)
- fprintf (file,
- _("warning: .pdata section size (%ld) is not a multiple of %d\n"),
- (long) stop, onaline);
-
- fprintf (file,
- _("\nThe Function Table (interpreted .pdata section contents)\n"));
-
- fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t UnwindData\n"));
-
- datasize = section->size;
- if (datasize == 0)
- return TRUE;
-
- if (!bfd_malloc_and_get_section (abfd, section, &data))
- {
- if (data != NULL)
- free (data);
- return FALSE;
- }
-
- start = 0;
-
- for (i = start; i < stop; i += onaline)
- {
- bfd_vma begin_addr;
- bfd_vma end_addr;
- bfd_vma unwind_data_addr;
-
- if (i + PDATA_ROW_SIZE > stop)
- break;
-
- begin_addr = bfd_get_32 (abfd, data + i);
- end_addr = bfd_get_32 (abfd, data + i + 4);
- unwind_data_addr = bfd_get_32 (abfd, data + i + 8);
-
- if (begin_addr == 0 && end_addr == 0 && unwind_data_addr == 0)
- /* We are probably into the padding of the section now. */
- break;
-
- fputc (' ', file);
- fprintf_vma (file, i + section->vma);
- fprintf (file, ":\t");
- fprintf_vma (file, begin_addr);
- fputc (' ', file);
- fprintf_vma (file, end_addr);
- fputc (' ', file);
- fprintf_vma (file, unwind_data_addr);
-
- fprintf (file, "\n");
- }
-
- free (data);
-
- cleanup_syms (&sym_cache);
-
- return TRUE;
-#undef PDATA_ROW_SIZE
-}
-#endif
\f
#define IMAGE_REL_BASED_HIGHADJ 4
static const char * const tbl[] =
FILE *file = (FILE *) vfile;
bfd_byte *data = 0;
asection *section = bfd_get_section_by_name (abfd, ".reloc");
- bfd_size_type datasize;
bfd_size_type i;
bfd_size_type start, stop;
fprintf (file,
_("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
- datasize = section->size;
if (! bfd_malloc_and_get_section (abfd, section, &data))
{
if (data != NULL)
return TRUE;
}
+\f
+
+static bfd_byte *
+rsrc_print_resource_directory (FILE * , bfd *, unsigned int,
+ bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
+
+static bfd_byte *
+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;
+
+ if (data + 8 >= dataend)
+ return dataend + 1;
+
+ fprintf (file, _("%*.s Entry: "), indent, " ");
+
+ entry = (long) bfd_get_32 (abfd, data);
+ if (is_name)
+ {
+ 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, name);
+
+ 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 string length: %#x>"), len);
+ }
+ else
+ 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\n"), entry);
+
+ if (HighBitSet (entry))
+ return rsrc_print_resource_directory (file, abfd, indent + 1,
+ datastart,
+ datastart + WithoutHighBit (entry),
+ dataend, rva_bias);
+
+ if (datastart + entry + 16 >= dataend)
+ return dataend + 1;
+
+ 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))
+ return dataend + 1;
+
+ 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 *
+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 * highest_data = data;
+
+ if (data + 16 >= dataend)
+ return dataend + 1;
+
+ fprintf (file, "%*.s ", indent, " ");
+ switch (indent)
+ {
+ case 0: fprintf (file, "Type"); break;
+ case 2: fprintf (file, "Name"); break;
+ case 4: fprintf (file, "Language"); break;
+ default: fprintf (file, "<unknown>"); break;
+ }
+
+ fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
+ (int) bfd_get_32 (abfd, data),
+ (long) bfd_get_32 (abfd, data + 4),
+ (int) bfd_get_16 (abfd, data + 8),
+ (int) bfd_get_16 (abfd, data + 10),
+ num_names = (int) bfd_get_16 (abfd, data + 12),
+ num_ids = (int) bfd_get_16 (abfd, data + 14));
+ data += 16;
+
+ while (num_names --)
+ {
+ 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;
+ }
+
+ while (num_ids --)
+ {
+ 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 max (highest_data, data);
+}
+
+/* Display the contents of a .rsrc section. We do not try to
+ reproduce the resources, windres does that. Instead we dump
+ the tables in a human readable format. */
+
+static bfd_boolean
+rsrc_print_section (bfd * abfd, void * vfile)
+{
+ bfd_vma rva_bias;
+ pe_data_type * pe;
+ FILE * file = (FILE *) vfile;
+ bfd_size_type datasize;
+ asection * section;
+ bfd_byte * data;
+ bfd_byte * dataend;
+ bfd_byte * datastart;
+
+
+ pe = pe_data (abfd);
+ if (pe == NULL)
+ return TRUE;
+
+ 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 (data != NULL)
+ free (data);
+ return FALSE;
+ }
+ datastart = data;
+ dataend = data + datasize;
+
+ fflush (file);
+ fprintf (file, "\nThe .rsrc Resource Directory section:\n");
+
+ while (data < dataend)
+ {
+ 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"));
+ 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 == (dataend - 4))
+ data = dataend;
+ else if (data < dataend)
+ fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
+ }
+ }
+
+ free (datastart);
+ return TRUE;
+}
/* Print out the program headers. */
fprintf (file, "SizeOfUninitializedData\t%08lx\n",
(unsigned long) i->SizeOfUninitializedData);
fprintf (file, "AddressOfEntryPoint\t");
- fprintf_vma (file, i->AddressOfEntryPoint);
+ bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
fprintf (file, "\nBaseOfCode\t\t");
- fprintf_vma (file, i->BaseOfCode);
+ 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");
- fprintf_vma (file, i->BaseOfData);
+ bfd_fprintf_vma (abfd, file, i->BaseOfData);
#endif
fprintf (file, "\nImageBase\t\t");
- fprintf_vma (file, i->ImageBase);
+ bfd_fprintf_vma (abfd, file, i->ImageBase);
fprintf (file, "\nSectionAlignment\t");
- fprintf_vma (file, i->SectionAlignment);
+ bfd_fprintf_vma (abfd, file, i->SectionAlignment);
fprintf (file, "\nFileAlignment\t\t");
- fprintf_vma (file, i->FileAlignment);
+ bfd_fprintf_vma (abfd, file, i->FileAlignment);
fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
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_RUNTIME_DRIVER:
subsystem_name = "EFI runtime driver";
break;
- // These are from revision 8.0 of the MS PE/COFF spec
- case IMAGE_SUBSYSTEM_EFI_ROM:
- subsystem_name = "EFI ROM";
+ 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;
fprintf (file, "\t(%s)", subsystem_name);
fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
fprintf (file, "SizeOfStackReserve\t");
- fprintf_vma (file, i->SizeOfStackReserve);
+ bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
fprintf (file, "\nSizeOfStackCommit\t");
- fprintf_vma (file, i->SizeOfStackCommit);
+ bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
fprintf (file, "\nSizeOfHeapReserve\t");
- fprintf_vma (file, i->SizeOfHeapReserve);
+ bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
fprintf (file, "\nSizeOfHeapCommit\t");
- fprintf_vma (file, i->SizeOfHeapCommit);
+ 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);
for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
{
fprintf (file, "Entry %1x ", j);
- fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
+ 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_pdata (abfd, vfile);
pe_print_reloc (abfd, vfile);
+ rsrc_print_section (abfd, vfile);
+
return TRUE;
}
ipe = pe_data (ibfd);
ope = pe_data (obfd);
-
- ope->pe_opthdr = ipe->pe_opthdr;
+
+ /* pe_opthdr is copied in copy_object. */
ope->dll = ipe->dll;
/* Don't copy input subsystem if output is different from input. */
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;
+
return TRUE;
}
coff_get_symbol_info (abfd, symbol, ret);
}
-/* Handle the .idata section and other things that need symbol table
- access. */
-
-bfd_boolean
-_bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
+#if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
+static int
+sort_x64_pdata (const void *l, const void *r)
{
- struct coff_link_hash_entry *h1;
- struct bfd_link_info *info = pfinfo->info;
- bfd_boolean result = TRUE;
-
- /* There are a few fields that need to be filled in now while we
- have symbol table access.
+ 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;
- The .idata subsections aren't directly available as sections, but
- they are in the symbol table, so get them from there. */
+ if (data + 8 >= dataend)
+ return dataend + 1;
- /* The import directory. This is the address of .idata$2, with size
- of .idata$2 + .idata$3. */
- h1 = coff_link_hash_lookup (coff_hash_table (info),
- ".idata$2", FALSE, FALSE, TRUE);
- if (h1 != NULL)
+ if (is_name)
{
- /* PR ld/2729: We cannot rely upon all the output sections having been
- created properly, so check before referencing them. Issue a warning
- message for any sections tht could not be found. */
- if ((h1->root.type == bfd_link_hash_defined
- || h1->root.type == bfd_link_hash_defweak)
- && h1->root.u.def.section != NULL
- && h1->root.u.def.section->output_section != NULL)
- pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
- (h1->root.u.def.value
- + h1->root.u.def.section->output_section->vma
- + h1->root.u.def.section->output_offset);
- else
- {
- _bfd_error_handler
- (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
- abfd);
- result = FALSE;
- }
+ bfd_byte * name;
- h1 = coff_link_hash_lookup (coff_hash_table (info),
- ".idata$4", FALSE, FALSE, TRUE);
- if (h1 != NULL
- && (h1->root.type == bfd_link_hash_defined
- || h1->root.type == bfd_link_hash_defweak)
- && h1->root.u.def.section != NULL
- && h1->root.u.def.section->output_section != NULL)
- pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
- ((h1->root.u.def.value
- + h1->root.u.def.section->output_section->vma
- + h1->root.u.def.section->output_offset)
- - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
- else
- {
- _bfd_error_handler
- (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
- abfd);
- result = FALSE;
- }
+ entry = (long) bfd_get_32 (abfd, data);
- /* The import address table. This is the size/address of
- .idata$5. */
- h1 = coff_link_hash_lookup (coff_hash_table (info),
- ".idata$5", FALSE, FALSE, TRUE);
- if (h1 != NULL
- && (h1->root.type == bfd_link_hash_defined
- || h1->root.type == bfd_link_hash_defweak)
- && h1->root.u.def.section != NULL
- && h1->root.u.def.section->output_section != NULL)
- pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
- (h1->root.u.def.value
- + h1->root.u.def.section->output_section->vma
- + h1->root.u.def.section->output_offset);
+ if (HighBitSet (entry))
+ name = datastart + WithoutHighBit (entry);
else
- {
- _bfd_error_handler
- (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
- abfd);
- result = FALSE;
- }
+ 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)
+{
+ 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);
+ 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_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)
+ {
+ 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);
+}
+
+#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
+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 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)
+ {
+ 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
+ /* Do the best we can - a case sensitive, untranslated comparison. */
+ res = memcmp (astring, bstring, 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;
+ bfd_byte * astring;
+ bfd_byte * bstring;
+ bfd_byte * new_data;
+ bfd_byte * nstring;
+
+ /* Step one: Find out what we have to do. */
+ BFD_ASSERT (! a->is_dir);
+ astring = a->value.leaf->data;
+
+ BFD_ASSERT (! b->is_dir);
+ 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. */
+ new_data = bfd_malloc (a->value.leaf->size + copy_needed);
+ if (new_data == NULL)
+ return FALSE;
+
+ 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 (rsrc_dir_chain * achain, 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)
+{
+ rsrc_directory * adir;
+ rsrc_directory * bdir;
+
+ BFD_ASSERT (a->is_dir);
+ BFD_ASSERT (b->is_dir);
+
+ adir = a->value.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;
+ pe_data_type * pe;
+ bfd_vma rva_bias;
+ bfd_byte * data;
+ bfd_byte * datastart;
+ bfd_byte * dataend;
+ bfd_byte * new_data;
+ unsigned int num_resource_sets;
+ rsrc_directory * type_tables;
+ rsrc_write_data write_data;
+ unsigned int indx;
+
+ 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 = pe_data (abfd);
+ if (pe == NULL)
+ return;
+
+ rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
+
+ data = bfd_malloc (size);
+ if (data == NULL)
+ return;
+ 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. */
+ dataend = data + size;
+ 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 *) (((ptrdiff_t) (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;
+
+ type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
+ if (type_tables == NULL)
+ goto end;
+
+ indx = 0;
+ while (data < dataend)
+ {
+ bfd_byte * p = data;
+
+ data = rsrc_parse_directory (abfd, type_tables + indx, data, data,
+ dataend, rva_bias, NULL);
+ data = (bfd_byte *) (((ptrdiff_t) (data + 3)) & ~ 3);
+ rva_bias += data - p;
+ if (data == (dataend - 4))
+ data = dataend;
+ indx ++;
+ }
+ BFD_ASSERT (indx == 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 (indx = 0; indx < num_resource_sets; indx++)
+ rsrc_attach_chain (& new_table.names, & type_tables[indx].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 (indx = 0; indx < num_resource_sets; indx++)
+ rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
+
+ rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
+
+ /* Step four: Create new contents for the .rsrc section. */
+ new_data = bfd_malloc (size);
+ if (new_data == NULL)
+ goto end;
+
+ 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. */
+
+bfd_boolean
+_bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
+{
+ struct coff_link_hash_entry *h1;
+ struct bfd_link_info *info = pfinfo->info;
+ bfd_boolean result = TRUE;
+
+ /* There are a few fields that need to be filled in now while we
+ have symbol table access.
+
+ The .idata subsections aren't directly available as sections, but
+ they are in the symbol table, so get them from there. */
+
+ /* The import directory. This is the address of .idata$2, with size
+ of .idata$2 + .idata$3. */
+ h1 = coff_link_hash_lookup (coff_hash_table (info),
+ ".idata$2", FALSE, FALSE, TRUE);
+ if (h1 != NULL)
+ {
+ /* PR ld/2729: We cannot rely upon all the output sections having been
+ created properly, so check before referencing them. Issue a warning
+ message for any sections tht could not be found. */
+ if ((h1->root.type == bfd_link_hash_defined
+ || h1->root.type == bfd_link_hash_defweak)
+ && h1->root.u.def.section != NULL
+ && h1->root.u.def.section->output_section != NULL)
+ pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
+ (h1->root.u.def.value
+ + h1->root.u.def.section->output_section->vma
+ + h1->root.u.def.section->output_offset);
+ else
+ {
+ _bfd_error_handler
+ (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
+ abfd);
+ result = FALSE;
+ }
+
+ h1 = coff_link_hash_lookup (coff_hash_table (info),
+ ".idata$4", FALSE, FALSE, TRUE);
+ if (h1 != NULL
+ && (h1->root.type == bfd_link_hash_defined
+ || h1->root.type == bfd_link_hash_defweak)
+ && h1->root.u.def.section != NULL
+ && h1->root.u.def.section->output_section != NULL)
+ pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
+ ((h1->root.u.def.value
+ + h1->root.u.def.section->output_section->vma
+ + h1->root.u.def.section->output_offset)
+ - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
+ else
+ {
+ _bfd_error_handler
+ (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
+ abfd);
+ result = FALSE;
+ }
+
+ /* The import address table. This is the size/address of
+ .idata$5. */
+ h1 = coff_link_hash_lookup (coff_hash_table (info),
+ ".idata$5", FALSE, FALSE, TRUE);
+ if (h1 != NULL
+ && (h1->root.type == bfd_link_hash_defined
+ || h1->root.type == bfd_link_hash_defweak)
+ && h1->root.u.def.section != NULL
+ && h1->root.u.def.section->output_section != NULL)
+ pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
+ (h1->root.u.def.value
+ + h1->root.u.def.section->output_section->vma
+ + h1->root.u.def.section->output_offset);
+ else
+ {
+ _bfd_error_handler
+ (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
+ abfd);
+ result = FALSE;
+ }
h1 = coff_link_hash_lookup (coff_hash_table (info),
".idata$6", FALSE, FALSE, TRUE);
((h1->root.u.def.value
+ h1->root.u.def.section->output_section->vma
+ h1->root.u.def.section->output_offset)
- - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
+ - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
else
{
_bfd_error_handler
- (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
+ (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
abfd);
result = FALSE;
}
}
+ else
+ {
+ h1 = coff_link_hash_lookup (coff_hash_table (info),
+ "__IAT_start__", FALSE, FALSE, TRUE);
+ if (h1 != NULL
+ && (h1->root.type == bfd_link_hash_defined
+ || h1->root.type == bfd_link_hash_defweak)
+ && h1->root.u.def.section != NULL
+ && h1->root.u.def.section->output_section != NULL)
+ {
+ bfd_vma iat_va;
+
+ iat_va =
+ (h1->root.u.def.value
+ + h1->root.u.def.section->output_section->vma
+ + h1->root.u.def.section->output_offset);
+
+ h1 = coff_link_hash_lookup (coff_hash_table (info),
+ "__IAT_end__", FALSE, FALSE, TRUE);
+ if (h1 != NULL
+ && (h1->root.type == bfd_link_hash_defined
+ || h1->root.type == bfd_link_hash_defweak)
+ && h1->root.u.def.section != NULL
+ && h1->root.u.def.section->output_section != NULL)
+ {
+ pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
+ ((h1->root.u.def.value
+ + h1->root.u.def.section->output_section->vma
+ + h1->root.u.def.section->output_offset)
+ - iat_va);
+ if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
+ pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
+ iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
+ }
+ else
+ {
+ _bfd_error_handler
+ (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
+ " because .idata$6 is missing"), abfd);
+ result = FALSE;
+ }
+ }
+ }
h1 = coff_link_hash_lookup (coff_hash_table (info),
- "__tls_used", FALSE, FALSE, TRUE);
+ (bfd_get_symbol_leading_char(abfd) != 0
+ ? "__tls_used" : "_tls_used"),
+ FALSE, FALSE, TRUE);
if (h1 != NULL)
{
if ((h1->root.type == bfd_link_hash_defined
else
{
_bfd_error_handler
- (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
+ (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
abfd);
result = FALSE;
}
-
+ /* According to PECOFF sepcifications by Microsoft version 8.2
+ the TLS data directory consists of 4 pointers, followed
+ by two 4-byte integer. This implies that the total size
+ is different for 32-bit and 64-bit executables. */
+#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
+#else
+ pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
+#endif
}
+/* If there is a .pdata section and we have linked pdata finally, we
+ need to sort the entries ascending. */
+#if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
+ {
+ asection *sec = bfd_get_section_by_name (abfd, ".pdata");
+
+ if (sec)
+ {
+ bfd_size_type x = sec->rawsize;
+ bfd_byte *tmp_data = NULL;
+
+ if (x)
+ tmp_data = bfd_malloc (x);
+
+ if (tmp_data != NULL)
+ {
+ if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
+ {
+ qsort (tmp_data,
+ (size_t) (x / 12),
+ 12, sort_x64_pdata);
+ bfd_set_section_contents (pfinfo->output_bfd, sec,
+ tmp_data, 0, x);
+ }
+ free (tmp_data);
+ }
+ }
+ }
+#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.... */