/* Support for the generic parts of PE/PEI, for BFD.
- Copyright (C) 1995-2014 Free Software Foundation, Inc.
+ Copyright (C) 1995-2019 Free Software Foundation, Inc.
Written by Cygnus Solutions.
This file is part of BFD, the Binary File Descriptor library.
sac@cygnus.com
PE/PEI rearrangement (and code added): Donn Terry
- Softway Systems, Inc. */
+ Softway Systems, Inc. */
/* Hey look, some documentation [and in a place you expect to find it]!
#undef coff_bfd_print_private_bfd_data
#endif
-static bfd_boolean pe_print_private_bfd_data (bfd *, void *);
+static bfd_boolean pe_print_private_bfd_data (bfd *, void *);
#define coff_bfd_print_private_bfd_data pe_print_private_bfd_data
static bfd_boolean (*pe_saved_coff_bfd_copy_private_bfd_data) (bfd *, bfd *) =
#undef coff_bfd_copy_private_bfd_data
#endif
-static bfd_boolean pe_bfd_copy_private_bfd_data (bfd *, bfd *);
+static bfd_boolean pe_bfd_copy_private_bfd_data (bfd *, bfd *);
#define coff_bfd_copy_private_bfd_data pe_bfd_copy_private_bfd_data
-#define coff_mkobject pe_mkobject
+#define coff_mkobject pe_mkobject
#define coff_mkobject_hook pe_mkobject_hook
#ifdef COFF_IMAGE_WITH_PE
bfd * abfd;
bfd_byte * data;
struct bfd_in_memory * bim;
- unsigned short magic;
+ unsigned short magic;
arelent * reltab;
- unsigned int relcount;
+ unsigned int relcount;
- coff_symbol_type * sym_cache;
- coff_symbol_type * sym_ptr;
- unsigned int sym_index;
+ coff_symbol_type * sym_cache;
+ coff_symbol_type * sym_ptr;
+ unsigned int sym_index;
- unsigned int * sym_table;
- unsigned int * table_ptr;
+ unsigned int * sym_table;
+ unsigned int * table_ptr;
combined_entry_type * native_syms;
combined_entry_type * native_ptr;
unsigned int sec_index;
- char * string_table;
- char * string_ptr;
+ char * string_table;
+ char * string_ptr;
char * end_string_ptr;
- SYMENT * esym_table;
- SYMENT * esym_ptr;
+ SYMENT * esym_table;
+ SYMENT * esym_ptr;
struct internal_reloc * int_reltab;
}
if (scnhdr_int->s_paddr > 0
&& (((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0
&& (! bfd_pei_p (abfd) || scnhdr_int->s_size == 0))
- || (bfd_pei_p (abfd) && (scnhdr_int->s_size > scnhdr_int->s_paddr))))
+ || (bfd_pei_p (abfd) && (scnhdr_int->s_size > scnhdr_int->s_paddr))))
/* This code used to set scnhdr_int->s_paddr to 0. However,
coff_set_alignment_hook stores s_paddr in virt_size, which
only works if it correctly holds the virtual size of the
the table in order to for the string lookup code in coffgen/coffcode to
work. */
#define NUM_ILF_RELOCS 8
-#define NUM_ILF_SECTIONS 6
-#define NUM_ILF_SYMS (2 + NUM_ILF_SECTIONS)
+#define NUM_ILF_SECTIONS 6
+#define NUM_ILF_SYMS (2 + NUM_ILF_SECTIONS)
#define SIZEOF_ILF_SYMS (NUM_ILF_SYMS * sizeof (* vars.sym_cache))
#define SIZEOF_ILF_SYM_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_table))
#define SIZEOF_IDATA6 (2 + strlen (symbol_name) + 1 + 1)
#define SIZEOF_IDATA7 (strlen (source_dll) + 1 + 1)
-#define SIZEOF_ILF_SECTIONS (NUM_ILF_SECTIONS * sizeof (struct coff_section_tdata))
+#define SIZEOF_ILF_SECTIONS (NUM_ILF_SECTIONS * sizeof (struct coff_section_tdata))
#define ILF_DATA_SIZE \
+ SIZEOF_ILF_SYMS \
/* Create an empty relocation against the given symbol. */
static void
-pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars,
- bfd_vma address,
- bfd_reloc_code_real_type reloc,
- struct bfd_symbol ** sym,
- unsigned int sym_index)
+pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars,
+ bfd_vma address,
+ bfd_reloc_code_real_type reloc,
+ struct bfd_symbol ** sym,
+ unsigned int sym_index)
{
arelent * entry;
struct internal_reloc * internal;
/* Create an empty relocation against the given section. */
static void
-pe_ILF_make_a_reloc (pe_ILF_vars * vars,
- bfd_vma address,
+pe_ILF_make_a_reloc (pe_ILF_vars * vars,
+ bfd_vma address,
bfd_reloc_code_real_type reloc,
- asection_ptr sec)
+ asection_ptr sec)
{
pe_ILF_make_a_symbol_reloc (vars, address, reloc, sec->symbol_ptr_ptr,
coff_section_data (vars->abfd, sec)->i);
zero initialised. They are just kept here as reminders. */
/* Initialise the internal symbol structure. */
- ent->u.syment.n_sclass = sclass;
- ent->u.syment.n_scnum = section->target_index;
+ ent->u.syment.n_sclass = sclass;
+ ent->u.syment.n_scnum = section->target_index;
ent->u.syment._n._n_n._n_offset = (bfd_hostptr_t) sym;
ent->is_sym = TRUE;
sym->symbol.name = vars->string_ptr;
sym->symbol.flags = BSF_EXPORT | BSF_GLOBAL | extra_flags;
sym->symbol.section = section;
- sym->native = ent;
+ sym->native = ent;
* vars->table_ptr = vars->sym_index;
* vars->sym_ptr_ptr = sym;
if (size & 1)
vars->data --;
+# if (GCC_VERSION >= 3000)
+ /* PR 18758: See note in pe_ILF_buid_a_bfd. We must make sure that we
+ preserve host alignment requirements. We test 'size' rather than
+ vars.data as we cannot perform binary arithmetic on pointers. We assume
+ that vars.data was sufficiently aligned upon entry to this function.
+ The BFD_ASSERTs in this functions will warn us if we run out of room,
+ but we should already have enough padding built in to ILF_DATA_SIZE. */
+ {
+ unsigned int alignment = __alignof__ (struct coff_section_tdata);
+
+ if (size & (alignment - 1))
+ vars->data += alignment - (size & (alignment - 1));
+ }
+#endif
/* Create a coff_section_tdata structure for our use. */
sec->used_by_bfd = (struct coff_section_tdata *) vars->data;
vars->data += sizeof (struct coff_section_tdata);
/* Build a full BFD from the information supplied in a ILF object. */
static bfd_boolean
-pe_ILF_build_a_bfd (bfd * abfd,
+pe_ILF_build_a_bfd (bfd * abfd,
unsigned int magic,
- char * symbol_name,
- char * source_dll,
+ char * symbol_name,
+ char * source_dll,
unsigned int ordinal,
unsigned int types)
{
- bfd_byte * ptr;
- pe_ILF_vars vars;
+ bfd_byte * ptr;
+ pe_ILF_vars vars;
struct internal_filehdr internal_f;
- unsigned int import_type;
- unsigned int import_name_type;
- asection_ptr id4, id5, id6 = NULL, text = NULL;
- coff_symbol_type ** imp_sym;
- unsigned int imp_index;
+ unsigned int import_type;
+ unsigned int import_name_type;
+ asection_ptr id4, id5, id6 = NULL, text = NULL;
+ coff_symbol_type ** imp_sym;
+ unsigned int imp_index;
/* Decode and verify the types field of the ILF structure. */
import_type = types & 0x3;
case IMPORT_CONST:
/* XXX code yet to be written. */
- _bfd_error_handler (_("%B: Unhandled import type; %x"),
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unhandled import type; %x"),
abfd, import_type);
return FALSE;
default:
- _bfd_error_handler (_("%B: Unrecognised import type; %x"),
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unrecognized import type; %x"),
abfd, import_type);
return FALSE;
}
break;
default:
- _bfd_error_handler (_("%B: Unrecognised import name type; %x"),
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unrecognized import name type; %x"),
abfd, import_name_type);
return FALSE;
}
/* The remaining space in bim->buffer is used
by the pe_ILF_make_a_section() function. */
+# if (GCC_VERSION >= 3000)
+ /* PR 18758: Make sure that the data area is sufficiently aligned for
+ pointers on the host. __alignof__ is a gcc extension, hence the test
+ above. For other compilers we will have to assume that the alignment is
+ unimportant, or else extra code can be added here and in
+ pe_ILF_make_a_section.
+
+ Note - we cannot test 'ptr' directly as it is illegal to perform binary
+ arithmetic on pointers, but we know that the strings section is the only
+ one that might end on an unaligned boundary. */
+ {
+ unsigned int alignment = __alignof__ (char *);
+
+ if (SIZEOF_ILF_STRINGS & (alignment - 1))
+ ptr += alignment - (SIZEOF_ILF_STRINGS & (alignment - 1));
+ }
+#endif
+
vars.data = ptr;
vars.abfd = abfd;
vars.sec_index = 0;
if (import_name_type == IMPORT_ORDINAL)
{
if (ordinal == 0)
- /* XXX - treat as IMPORT_NAME ??? */
- abort ();
+ /* See PR 20907 for a reproducer. */
+ goto error_return;
#ifdef COFF_WITH_pex64
((unsigned int *) id4->contents)[0] = ordinal;
pe_ILF_save_relocs (&vars, id5);
}
+ /* Create an import symbol. */
+ pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0);
+ imp_sym = vars.sym_ptr_ptr - 1;
+ imp_index = vars.sym_index - 1;
+
/* Create extra sections depending upon the type of import we are dealing with. */
switch (import_type)
{
int i;
case IMPORT_CODE:
- /* Create a .text section.
+ /* CODE functions are special, in that they get a trampoline that
+ jumps to the main import symbol. Create a .text section to hold it.
First we need to look up its contents in the jump table. */
for (i = NUM_ENTRIES (jtab); i--;)
{
/* Copy in the jump code. */
memcpy (text->contents, jtab[i].data, jtab[i].size);
- /* Create an import symbol. */
- pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0);
- imp_sym = vars.sym_ptr_ptr - 1;
- imp_index = vars.sym_index - 1;
-
/* Create a reloc for the data in the text section. */
#ifdef MIPS_ARCH_MAGIC_WINCE
if (magic == MIPS_ARCH_MAGIC_WINCE)
imp_index);
}
else
+#endif
+#ifdef AMD64MAGIC
+ if (magic == AMD64MAGIC)
+ {
+ pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset,
+ BFD_RELOC_32_PCREL, (asymbol **) imp_sym,
+ imp_index);
+ }
+ else
#endif
pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset,
BFD_RELOC_32, (asymbol **) imp_sym,
pe_ILF_make_a_symbol (& vars, "", symbol_name, text,
BSF_NOT_AT_END | BSF_FUNCTION);
- /* Create an import symbol for the DLL, without the
- .dll suffix. */
- ptr = (bfd_byte *) strrchr (source_dll, '.');
- if (ptr)
- * ptr = 0;
- pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);
- if (ptr)
- * ptr = '.';
break;
case IMPORT_DATA:
abort ();
}
+ /* Create an import symbol for the DLL, without the .dll suffix. */
+ ptr = (bfd_byte *) strrchr (source_dll, '.');
+ if (ptr)
+ * ptr = 0;
+ pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);
+ if (ptr)
+ * ptr = '.';
+
/* Point the bfd at the symbol table. */
obj_symbols (abfd) = vars.sym_cache;
bfd_get_symcount (abfd) = vars.sym_index;
static const bfd_target *
pe_ILF_object_p (bfd * abfd)
{
- bfd_byte buffer[14];
- bfd_byte * ptr;
- char * symbol_name;
- char * source_dll;
- unsigned int machine;
- bfd_size_type size;
- unsigned int ordinal;
- unsigned int types;
- unsigned int magic;
+ bfd_byte buffer[14];
+ bfd_byte * ptr;
+ char * symbol_name;
+ char * source_dll;
+ unsigned int machine;
+ bfd_size_type size;
+ unsigned int ordinal;
+ unsigned int types;
+ unsigned int magic;
/* Upon entry the first six bytes of the ILF header have
already been read. Now read the rest of the header. */
#endif
break;
- case IMAGE_FILE_MACHINE_M68K:
-#ifdef MC68AGIC
- magic = MC68MAGIC;
-#endif
- break;
-
case IMAGE_FILE_MACHINE_R3000:
case IMAGE_FILE_MACHINE_R4000:
case IMAGE_FILE_MACHINE_R10000:
/* We no longer support PowerPC. */
default:
_bfd_error_handler
- (_("%B: Unrecognised machine type (0x%x)"
+ /* xgettext:c-format */
+ (_("%pB: unrecognised machine type (0x%x)"
" in Import Library Format archive"),
abfd, machine);
bfd_set_error (bfd_error_malformed_archive);
if (magic == 0)
{
_bfd_error_handler
- (_("%B: Recognised but unhandled machine type (0x%x)"
+ /* xgettext:c-format */
+ (_("%pB: recognised but unhandled machine type (0x%x)"
" in Import Library Format archive"),
abfd, machine);
bfd_set_error (bfd_error_wrong_format);
if (size == 0)
{
_bfd_error_handler
- (_("%B: size field is zero in Import Library Format header"), abfd);
+ (_("%pB: size field is zero in Import Library Format header"), abfd);
bfd_set_error (bfd_error_malformed_archive);
return NULL;
}
symbol_name = (char *) ptr;
- source_dll = symbol_name + strlen (symbol_name) + 1;
+ /* See PR 20905 for an example of where the strnlen is necessary. */
+ source_dll = symbol_name + strnlen (symbol_name, size - 1) + 1;
/* Verify that the strings are null terminated. */
if (ptr[size - 1] != 0
|| (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size)
{
_bfd_error_handler
- (_("%B: string not null terminated in ILF object file."), abfd);
+ (_("%pB: string not null terminated in ILF object file"), abfd);
bfd_set_error (bfd_error_malformed_archive);
bfd_release (abfd, ptr);
return NULL;
return abfd->xvec;
}
+static void
+pe_bfd_read_buildid (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_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
+ bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
+
+ if (size == 0)
+ return;
+
+ addr += extra->ImageBase;
+
+ /* Search for the section containing the DebugDirectory. */
+ for (section = abfd->sections; section != NULL; section = section->next)
+ {
+ if ((addr >= section->vma) && (addr < (section->vma + section->size)))
+ break;
+ }
+
+ if (section == NULL)
+ return;
+
+ if (!(section->flags & SEC_HAS_CONTENTS))
+ return;
+
+ dataoff = addr - section->vma;
+
+ /* PR 20605 and 22373: Make sure that the data is really there.
+ Note - since we are dealing with unsigned quantities we have
+ to be careful to check for potential overflows. */
+ if (dataoff >= section->size
+ || size > section->size - dataoff)
+ {
+ _bfd_error_handler
+ (_("%pB: error: debug data ends beyond end of debug directory"),
+ abfd);
+ return;
+ }
+
+ /* Read the whole section. */
+ if (!bfd_malloc_and_get_section (abfd, section, &data))
+ {
+ if (data != NULL)
+ free (data);
+ return;
+ }
+
+ /* Search for a CodeView entry in the DebugDirectory */
+ 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_CODEVIEW)
+ {
+ char buffer[256 + 1];
+ 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))
+ {
+ struct bfd_build_id* build_id = bfd_alloc (abfd,
+ sizeof (struct bfd_build_id) + cvinfo->SignatureLength);
+ if (build_id)
+ {
+ build_id->size = cvinfo->SignatureLength;
+ memcpy(build_id->data, cvinfo->Signature,
+ cvinfo->SignatureLength);
+ abfd->build_id = build_id;
+ }
+ }
+ break;
+ }
+ }
+}
+
static const bfd_target *
pe_bfd_object_p (bfd * abfd)
{
bfd_byte buffer[6];
- struct external_PEI_DOS_hdr dos_hdr;
+ struct external_DOS_hdr dos_hdr;
struct external_PEI_IMAGE_hdr image_hdr;
struct internal_filehdr internal_f;
struct internal_aouthdr internal_a;
file_ptr opt_hdr_size;
file_ptr offset;
+ const bfd_target *result;
/* Detect if this a Microsoft Import Library Format element. */
/* First read the beginning of the header. */
/* There are really two magic numbers involved; the magic number
that says this is a NT executable (PEI) and the magic number that
- determines the architecture. The former is DOSMAGIC, stored in
+ determines the architecture. The former is IMAGE_DOS_SIGNATURE, stored in
the e_magic field. The latter is stored in the f_magic field.
If the NT magic number isn't valid, the architecture magic number
could be mimicked by some other field (specifically, the number
correctly for a PEI file, check the e_magic number here, and, if
it doesn't match, clobber the f_magic number so that we don't get
a false match. */
- if (H_GET_16 (abfd, dos_hdr.e_magic) != DOSMAGIC)
+ if (H_GET_16 (abfd, dos_hdr.e_magic) != IMAGE_DOS_SIGNATURE)
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
!= (bfd_size_type) opt_hdr_size)
return NULL;
+ bfd_set_error (bfd_error_no_error);
bfd_coff_swap_aouthdr_in (abfd, opthdr, & internal_a);
+ if (bfd_get_error () != bfd_error_no_error)
+ return NULL;
+ }
+
+
+ result = coff_real_object_p (abfd, internal_f.f_nscns, &internal_f,
+ (opt_hdr_size != 0
+ ? &internal_a
+ : (struct internal_aouthdr *) NULL));
+
+
+ if (result)
+ {
+ /* Now the whole header has been processed, see if there is a build-id */
+ pe_bfd_read_buildid(abfd);
}
- return coff_real_object_p (abfd, internal_f.f_nscns, &internal_f,
- (opt_hdr_size != 0
- ? &internal_a
- : (struct internal_aouthdr *) NULL));
+ return result;
}
#define coff_object_p pe_bfd_object_p