X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fpeicode.h;h=4a022f2ea5a7010f23638735da4fc318f9f8bdda;hb=ee91ed797277ee8076592db26cd22a296701da81;hp=84dfe57372d2d41f52c4baf8726c9f2d2d191d5b;hpb=cb665cd3e27a53bdc921ba8df64d44dfce65291d;p=binutils-gdb.git diff --git a/bfd/peicode.h b/bfd/peicode.h index 84dfe57372d..4a022f2ea5a 100644 --- a/bfd/peicode.h +++ b/bfd/peicode.h @@ -1,5 +1,5 @@ /* Support for the generic parts of PE/PEI, for BFD. - Copyright 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc. + Copyright 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. Written by Cygnus Solutions. This file is part of BFD, the Binary File Descriptor library. @@ -69,7 +69,6 @@ static boolean (*pe_saved_coff_bfd_print_private_bfd_data) static boolean pe_print_private_bfd_data PARAMS ((bfd *, PTR)); #define coff_bfd_print_private_bfd_data pe_print_private_bfd_data - static boolean (*pe_saved_coff_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *)) = #ifndef coff_bfd_copy_private_bfd_data @@ -85,15 +84,68 @@ static boolean pe_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *)); #define coff_mkobject pe_mkobject #define coff_mkobject_hook pe_mkobject_hook +#ifndef NO_COFF_RELOCS static void coff_swap_reloc_in PARAMS ((bfd *, PTR, PTR)); static unsigned int coff_swap_reloc_out PARAMS ((bfd *, PTR, PTR)); +#endif static void coff_swap_filehdr_in PARAMS ((bfd *, PTR, PTR)); static void coff_swap_scnhdr_in PARAMS ((bfd *, PTR, PTR)); static boolean pe_mkobject PARAMS ((bfd *)); static PTR pe_mkobject_hook PARAMS ((bfd *, PTR, PTR)); +#ifdef COFF_IMAGE_WITH_PE +/* This structure contains static variables used by the ILF code. */ +typedef asection * asection_ptr; + +typedef struct +{ + bfd * abfd; + bfd_byte * data; + struct bfd_in_memory * bim; + unsigned short magic; + + arelent * reltab; + unsigned int relcount; + + coff_symbol_type * sym_cache; + coff_symbol_type * sym_ptr; + unsigned int sym_index; + + unsigned int * sym_table; + unsigned int * table_ptr; + + combined_entry_type * native_syms; + combined_entry_type * native_ptr; + + coff_symbol_type ** sym_ptr_table; + coff_symbol_type ** sym_ptr_ptr; + + unsigned int sec_index; + + char * string_table; + char * string_ptr; + char * end_string_ptr; + + SYMENT * esym_table; + SYMENT * esym_ptr; + + struct internal_reloc * int_reltab; +} +pe_ILF_vars; + +static asection_ptr pe_ILF_make_a_section PARAMS ((pe_ILF_vars *, const char *, unsigned int, flagword)); +static void pe_ILF_make_a_reloc PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, asection_ptr)); +static void pe_ILF_make_a_symbol PARAMS ((pe_ILF_vars *, const char *, const char *, asection_ptr, flagword)); +static void pe_ILF_save_relocs PARAMS ((pe_ILF_vars *, asection_ptr)); +static void pe_ILF_make_a_symbol_reloc PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, struct symbol_cache_entry **, unsigned int)); +static boolean pe_ILF_build_a_bfd PARAMS ((bfd *, unsigned short, bfd_byte *, bfd_byte *, unsigned int, unsigned int)); +static const bfd_target * pe_ILF_object_p PARAMS ((bfd *)); +static const bfd_target * pe_bfd_object_p PARAMS ((bfd *)); +#endif /* COFF_IMAGE_WITH_PE */ + /**********************************************************************/ +#ifndef NO_COFF_RELOCS static void coff_swap_reloc_in (abfd, src, dst) bfd *abfd; @@ -114,7 +166,6 @@ coff_swap_reloc_in (abfd, src, dst) #endif } - static unsigned int coff_swap_reloc_out (abfd, src, dst) bfd *abfd; @@ -139,7 +190,7 @@ coff_swap_reloc_out (abfd, src, dst) #endif return RELSZ; } - +#endif /* not NO_COFF_RELOCS */ static void coff_swap_filehdr_in (abfd, src, dst) @@ -168,8 +219,13 @@ coff_swap_filehdr_in (abfd, src, dst) 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 0 + /* We can't assume that the PE header is at offset 0x80. When it + isn't, the DOS header isn't read correctly, so we can't assume + e_magic is set even for valid PE files. */ if (bfd_h_get_16 (abfd, (bfd_byte *) filehdr_src->e_magic) != DOSMAGIC) filehdr_dst->f_magic = -1; +#endif #endif /* Other people's tools sometimes generate headers with an nsyms but @@ -180,7 +236,7 @@ coff_swap_filehdr_in (abfd, src, dst) filehdr_dst->f_flags |= F_LSYMS; } - filehdr_dst->f_opthdr = bfd_h_get_16(abfd, + filehdr_dst->f_opthdr = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_opthdr); } @@ -190,7 +246,6 @@ coff_swap_filehdr_in (abfd, src, dst) #define coff_swap_filehdr_out _bfd_pe_only_swap_filehdr_out #endif - static void coff_swap_scnhdr_in (abfd, ext, in) bfd *abfd; @@ -200,7 +255,7 @@ coff_swap_scnhdr_in (abfd, ext, in) SCNHDR *scnhdr_ext = (SCNHDR *) ext; struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; - memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name)); + memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof (scnhdr_int->s_name)); scnhdr_int->s_vaddr = GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr); scnhdr_int->s_paddr = @@ -230,12 +285,13 @@ coff_swap_scnhdr_in (abfd, ext, in) (bfd_byte *) scnhdr_ext->s_nlnno); #endif - if (scnhdr_int->s_vaddr != 0) + if (scnhdr_int->s_vaddr != 0) { scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase; scnhdr_int->s_vaddr &= 0xffffffff; } +#ifndef COFF_NO_HACK_SCNHDR_SIZE /* If this section holds uninitialized data, use the virtual size (stored in s_paddr) instead of the physical size. */ if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0) @@ -246,6 +302,7 @@ coff_swap_scnhdr_in (abfd, ext, in) only works if it correctly holds the virtual size of the section. */ } +#endif } static boolean @@ -253,7 +310,7 @@ pe_mkobject (abfd) bfd * abfd; { pe_data_type *pe; - abfd->tdata.pe_obj_data = + abfd->tdata.pe_obj_data = (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type)); if (abfd->tdata.pe_obj_data == 0) @@ -309,15 +366,15 @@ pe_mkobject_hook (abfd, filehdr, aouthdr) abfd->flags |= HAS_DEBUG; #ifdef COFF_IMAGE_WITH_PE - if (aouthdr) + if (aouthdr) pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe; #endif -#ifdef ARM +#ifdef ARM if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) coff_data (abfd) ->flags = 0; #endif - + return (PTR) pe; } @@ -362,9 +419,841 @@ pe_bfd_copy_private_bfd_data (ibfd, obfd) #define coff_get_symbol_info _bfd_pe_get_symbol_info +#ifdef COFF_IMAGE_WITH_PE + +/* Code to handle Microsoft's Image Library Format. + Also known as LINK6 format. + Documentation about this format can be found at: + + http://msdn.microsoft.com/library/specs/pecoff_section8.htm */ + +/* The following constants specify the sizes of the various data + structures that we have to create in order to build a bfd describing + an ILF object file. The final "+ 1" in the definitions of SIZEOF_IDATA6 + and SIZEOF_IDATA7 below is to allow for the possibility that we might + need a padding byte in order to ensure 16 bit alignment for the section's + contents. + + The value for SIZEOF_ILF_STRINGS is computed as follows: + + There will be NUM_ILF_SECTIONS section symbols. Allow 9 characters + per symbol for their names (longest section name is .idata$x). + + There will be two symbols for the imported value, one the symbol name + and one with _imp__ prefixed. Allowing for the terminating nul's this + is strlen (symbol_name) * 2 + 8 + 21 + strlen (source_dll). + + The strings in the string table must start STRING__SIZE_SIZE bytes into + 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 SIZEOF_ILF_SYMS (NUM_ILF_SYMS * sizeof (* vars.sym_cache)) +#define SIZEOF_ILF_SYM_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_table)) +#define SIZEOF_ILF_NATIVE_SYMS (NUM_ILF_SYMS * sizeof (* vars.native_syms)) +#define SIZEOF_ILF_SYM_PTR_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_ptr_table)) +#define SIZEOF_ILF_EXT_SYMS (NUM_ILF_SYMS * sizeof (* vars.esym_table)) +#define SIZEOF_ILF_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.reltab)) +#define SIZEOF_ILF_INT_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.int_reltab)) +#define SIZEOF_ILF_STRINGS (strlen (symbol_name) * 2 + 8 \ + + 21 + strlen (source_dll) \ + + NUM_ILF_SECTIONS * 9 \ + + STRING_SIZE_SIZE) +#define SIZEOF_IDATA2 (5 * 4) +#define SIZEOF_IDATA4 (1 * 4) +#define SIZEOF_IDATA5 (1 * 4) +#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 ILF_DATA_SIZE \ + sizeof (* vars.bim) \ + + SIZEOF_ILF_SYMS \ + + SIZEOF_ILF_SYM_TABLE \ + + SIZEOF_ILF_NATIVE_SYMS \ + + SIZEOF_ILF_SYM_PTR_TABLE \ + + SIZEOF_ILF_EXT_SYMS \ + + SIZEOF_ILF_RELOCS \ + + SIZEOF_ILF_INT_RELOCS \ + + SIZEOF_ILF_STRINGS \ + + SIZEOF_IDATA2 \ + + SIZEOF_IDATA4 \ + + SIZEOF_IDATA5 \ + + SIZEOF_IDATA6 \ + + SIZEOF_IDATA7 \ + + SIZEOF_ILF_SECTIONS \ + + MAX_TEXT_SECTION_SIZE + +/* 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 symbol_cache_entry ** sym, + unsigned int sym_index) +{ + arelent * entry; + struct internal_reloc * internal; + + entry = vars->reltab + vars->relcount; + internal = vars->int_reltab + vars->relcount; + + entry->address = address; + entry->addend = 0; + entry->howto = bfd_reloc_type_lookup (vars->abfd, reloc); + entry->sym_ptr_ptr = sym; + + internal->r_vaddr = address; + internal->r_symndx = sym_index; + internal->r_type = entry->howto->type; +#if 0 /* These fields do not need to be initialised. */ + internal->r_size = 0; + internal->r_extern = 0; + internal->r_offset = 0; +#endif + + vars->relcount ++; + + BFD_ASSERT (vars->relcount <= NUM_ILF_RELOCS); +} + +/* Create an empty relocation against the given section. */ +static void +pe_ILF_make_a_reloc (pe_ILF_vars * vars, + bfd_vma address, + bfd_reloc_code_real_type reloc, + asection_ptr sec) +{ + pe_ILF_make_a_symbol_reloc (vars, address, reloc, sec->symbol_ptr_ptr, + coff_section_data (vars->abfd, sec)->i); +} + +/* Move the queued relocs into the given section. */ +static void +pe_ILF_save_relocs (pe_ILF_vars * vars, + asection_ptr sec) +{ + /* Make sure that there is somewhere to store the internal relocs. */ + if (coff_section_data (vars->abfd, sec) == NULL) + /* We should probably return an error indication here. */ + abort (); + + coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab; + coff_section_data (vars->abfd, sec)->keep_relocs = true; + + sec->relocation = vars->reltab; + sec->reloc_count = vars->relcount; + sec->flags |= SEC_RELOC; + + vars->reltab += vars->relcount; + vars->int_reltab += vars->relcount; + vars->relcount = 0; + + BFD_ASSERT ((bfd_byte *)vars->int_reltab < (bfd_byte *)vars->string_table); +} + +/* Create a global symbol and add it to the relevant tables. */ +static void +pe_ILF_make_a_symbol (pe_ILF_vars * vars, + const char * prefix, + const char * symbol_name, + asection_ptr section, + flagword extra_flags) +{ + coff_symbol_type * sym; + combined_entry_type * ent; + SYMENT * esym; + unsigned short sclass; + + if (extra_flags & BSF_LOCAL) + sclass = C_STAT; + else + sclass = C_EXT; + +#ifdef THUMBPEMAGIC + if (vars->magic == THUMBPEMAGIC) + { + if (extra_flags & BSF_FUNCTION) + sclass = C_THUMBEXTFUNC; + else if (extra_flags & BSF_LOCAL) + sclass = C_THUMBSTAT; + else + sclass = C_THUMBEXT; + } +#endif + + BFD_ASSERT (vars->sym_index < NUM_ILF_SYMS); + + sym = vars->sym_ptr; + ent = vars->native_ptr; + esym = vars->esym_ptr; + + /* Copy the symbol's name into the string table. */ + sprintf (vars->string_ptr, "%s%s", prefix, symbol_name); + + if (section == NULL) + section = (asection_ptr) & bfd_und_section; + + /* Initialise the external symbol. */ + bfd_h_put_32 (vars->abfd, vars->string_ptr - vars->string_table, (bfd_byte *) esym->e.e.e_offset); + bfd_h_put_16 (vars->abfd, section->target_index, (bfd_byte *) esym->e_scnum); + esym->e_sclass[0] = sclass; + + /* The following initialisations are unnecessary - the memory is + zero initialised. They are just kept here as reminders. */ +#if 0 + esym->e.e.e_zeroes = 0; + esym->e_value = 0; + esym->e_type = T_NULL; + esym->e_numaux = 0; +#endif + + /* Initialise the internal symbol structure. */ + ent->u.syment.n_sclass = sclass; + ent->u.syment.n_scnum = section->target_index; + ent->u.syment._n._n_n._n_offset = (long) sym; + +#if 0 /* See comment above. */ + ent->u.syment.n_value = 0; + ent->u.syment.n_flags = 0; + ent->u.syment.n_type = T_NULL; + ent->u.syment.n_numaux = 0; + ent->fix_value = 0; +#endif + + sym->symbol.the_bfd = vars->abfd; + sym->symbol.name = vars->string_ptr; + sym->symbol.flags = BSF_EXPORT | BSF_GLOBAL | extra_flags; + sym->symbol.section = section; + sym->native = ent; + +#if 0 /* See comment above. */ + sym->symbol.value = 0; + sym->symbol.udata.i = 0; + sym->done_lineno = false; + sym->lineno = NULL; +#endif + + * vars->table_ptr = vars->sym_index; + * vars->sym_ptr_ptr = sym; + + /* Adjust pointers for the next symbol. */ + vars->sym_index ++; + vars->sym_ptr ++; + vars->sym_ptr_ptr ++; + vars->table_ptr ++; + vars->native_ptr ++; + vars->esym_ptr ++; + vars->string_ptr += strlen (symbol_name) + strlen (prefix) + 1; + + BFD_ASSERT (vars->string_ptr < vars->end_string_ptr); +} + +/* Create a section. */ +static asection_ptr +pe_ILF_make_a_section (pe_ILF_vars * vars, + const char * name, + unsigned int size, + flagword extra_flags) +{ + asection_ptr sec; + flagword flags; + + sec = bfd_make_section_old_way (vars->abfd, name); + if (sec == NULL) + return NULL; + + flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY; + + bfd_set_section_flags (vars->abfd, sec, flags | extra_flags); + + bfd_set_section_alignment (vars->abfd, sec, 2); + + /* Check that we will not run out of space. */ + BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size); + + /* Set the section size and contents. The actual + contents are filled in by our parent. */ + bfd_set_section_size (vars->abfd, sec, size); + sec->contents = vars->data; + sec->target_index = vars->sec_index ++; + + /* Advance data pointer in the vars structure. */ + vars->data += size; + + /* Skip the padding byte if it was not needed. + The logic here is that if the string length is odd, + then the entire string length, including the null byte, + is even and so the extra, padding byte, is not needed. */ + if (size & 1) + vars->data --; + + /* 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); + + BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size); + + /* Create a symbol to refer to this section. */ + pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL); + + /* Cache the index to the symbol in the coff_section_data structure. */ + coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1; + + return sec; +} + +/* This structure contains the code that goes into the .text section + in order to perform a jump into the DLL lookup table. The entries + in the table are index by the magic number used to represent the + machine type in the PE file. The contents of the data[] arrays in + these entries are stolen from the jtab[] arrays in ld/pe-dll.c. + The SIZE field says how many bytes in the DATA array are actually + used. The OFFSET field says where in the data array the address + of the .idata$5 section should be placed. */ +#define MAX_TEXT_SECTION_SIZE 32 + +typedef struct +{ + unsigned short magic; + unsigned char data[MAX_TEXT_SECTION_SIZE]; + unsigned int size; + unsigned int offset; +} +jump_table; + +static jump_table jtab[] = +{ +#ifdef I386MAGIC + { I386MAGIC, + { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 }, + 8, 2 + }, +#endif + +#ifdef MC68MAGIC + { MC68MAGIC, { /* XXX fill me in */ }, 0, 0 }, +#endif +#ifdef MIPS_ARCH_MAGIC_WINCE + { MIPS_ARCH_MAGIC_WINCE, + { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d, + 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 }, + 16, 0 + }, +#endif + +#ifdef SH_ARCH_MAGIC_WINCE + { SH_ARCH_MAGIC_WINCE, + { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, + 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 }, + 12, 8 + }, +#endif + +#ifdef ARMPEMAGIC + { ARMPEMAGIC, + { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0, + 0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00}, + 12, 8 + }, +#endif + +#ifdef THUMBPEMAGIC + { THUMBPEMAGIC, + { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46, + 0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 }, + 16, 12 + }, +#endif + { 0, { 0 }, 0, 0 } +}; + +#ifndef NUM_ENTRIES +#define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0]) +#endif + +/* Build a full BFD from the information supplied in a ILF object. */ +static boolean +pe_ILF_build_a_bfd (bfd * abfd, + unsigned short magic, + bfd_byte * symbol_name, + bfd_byte * source_dll, + unsigned int ordinal, + unsigned int types) +{ + 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; + + /* Decode and verify the types field of the ILF structure. */ + import_type = types & 0x3; + import_name_type = (types & 0x1c) >> 2; + + switch (import_type) + { + case IMPORT_CODE: + case IMPORT_DATA: + break; + + case IMPORT_CONST: + /* XXX code yet to be written. */ + _bfd_error_handler (_("%s: Unhandled import type; %x"), + bfd_get_filename (abfd), import_type); + return false; + + default: + _bfd_error_handler (_("%s: Unrecognised import type; %x"), + bfd_get_filename (abfd), import_type); + return false; + } + + switch (import_name_type) + { + case IMPORT_ORDINAL: + case IMPORT_NAME: + case IMPORT_NAME_NOPREFIX: + case IMPORT_NAME_UNDECORATE: + break; + + default: + _bfd_error_handler (_("%s: Unrecognised import name type; %x"), + bfd_get_filename (abfd), import_name_type); + return false; + } + + /* Initialise local variables. + + Note these are kept in a structure rather than being + declared as statics since bfd frowns on global variables. + + We are going to construct the contents of the BFD in memory, + so allocate all the space that we will need right now. */ + ptr = bfd_zalloc (abfd, ILF_DATA_SIZE); + if (ptr == NULL) + return false; + + /* Create a bfd_in_memory structure. */ + vars.bim = (struct bfd_in_memory *) ptr; + vars.bim->buffer = ptr; + vars.bim->size = ILF_DATA_SIZE; + ptr += sizeof (* vars.bim); + + /* Initialise the pointers to regions of the memory and the + other contents of the pe_ILF_vars structure as well. */ + vars.sym_cache = (coff_symbol_type *) ptr; + vars.sym_ptr = (coff_symbol_type *) ptr; + vars.sym_index = 0; + ptr += SIZEOF_ILF_SYMS; + + vars.sym_table = (unsigned int *) ptr; + vars.table_ptr = (unsigned int *) ptr; + ptr += SIZEOF_ILF_SYM_TABLE; + + vars.native_syms = (combined_entry_type *) ptr; + vars.native_ptr = (combined_entry_type *) ptr; + ptr += SIZEOF_ILF_NATIVE_SYMS; + + vars.sym_ptr_table = (coff_symbol_type **) ptr; + vars.sym_ptr_ptr = (coff_symbol_type **) ptr; + ptr += SIZEOF_ILF_SYM_PTR_TABLE; + + vars.esym_table = (SYMENT *) ptr; + vars.esym_ptr = (SYMENT *) ptr; + ptr += SIZEOF_ILF_EXT_SYMS; + + vars.reltab = (arelent *) ptr; + vars.relcount = 0; + ptr += SIZEOF_ILF_RELOCS; + + vars.int_reltab = (struct internal_reloc *) ptr; + ptr += SIZEOF_ILF_INT_RELOCS; + + vars.string_table = ptr; + vars.string_ptr = ptr + STRING_SIZE_SIZE; + ptr += SIZEOF_ILF_STRINGS; + vars.end_string_ptr = ptr; + + /* The remaining space in bim->buffer is used + by the pe_ILF_make_a_section() function. */ + vars.data = ptr; + vars.abfd = abfd; + vars.sec_index = 0; + vars.magic = magic; + + /* Create the initial .idata$ sections: + [.idata$2: Import Directory Table -- not needed] + .idata$4: Import Lookup Table + .idata$5: Import Address Table + + Note we do not create a .idata$3 section as this is + created for us by the linker script. */ + id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0); + id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0); + if (id4 == NULL || id5 == NULL) + return false; + + /* Fill in the contents of these sections. */ + if (import_name_type == IMPORT_ORDINAL) + { + if (ordinal == 0) + /* XXX - treat as IMPORT_NAME ??? */ + abort (); + + * (unsigned int *) id4->contents = ordinal | 0x80000000; + * (unsigned int *) id5->contents = ordinal | 0x80000000; + } + else + { + char * symbol; + + /* Create .idata$6 - the Hint Name Table. */ + id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0); + if (id6 == NULL) + return false; + + /* If necessary, trim the import symbol name. */ + symbol = symbol_name; + + if (import_name_type != IMPORT_NAME) + /* Skip any prefix in symbol_name. */ + while (*symbol == '@' || * symbol == '?' || * symbol == '_') + ++ symbol; + + if (import_name_type == IMPORT_NAME_UNDECORATE) + { + /* Truncate at the first '@' */ + while (* symbol != 0 && * symbol != '@') + symbol ++; + + * symbol = 0; + } + + id6->contents[0] = ordinal & 0xff; + id6->contents[1] = ordinal >> 8; + + strcpy (id6->contents + 2, symbol); + } + + if (import_name_type != IMPORT_ORDINAL) + { + pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6); + pe_ILF_save_relocs (& vars, id4); + + pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6); + pe_ILF_save_relocs (& vars, id5); + } + + /* 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. + First we need to look up its contents in the jump table. */ + for (i = NUM_ENTRIES (jtab); i--;) + { + if (jtab[i].size == 0) + continue; + if (jtab[i].magic == magic) + break; + } + /* If we did not find a matching entry something is wrong. */ + if (i < 0) + abort (); + + /* Create the .text section. */ + text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE); + if (text == NULL) + return false; + + /* 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) + { + pe_ILF_make_a_symbol_reloc (& vars, 0, BFD_RELOC_HI16_S, + (struct symbol_cache_entry **) imp_sym, imp_index); + pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_LO16, text); + pe_ILF_make_a_symbol_reloc (& vars, 4, BFD_RELOC_LO16, + (struct symbol_cache_entry **) imp_sym, imp_index); + } + else +#endif + pe_ILF_make_a_symbol_reloc (& vars, jtab[i].offset, BFD_RELOC_32, + (asymbol **) imp_sym, imp_index); + + pe_ILF_save_relocs (& vars, text); + break; + + case IMPORT_DATA: + break; + + default: + /* XXX code not yet written. */ + abort (); + } + + /* Initialise the bfd. */ + memset (& internal_f, 0, sizeof (internal_f)); + + internal_f.f_magic = magic; + internal_f.f_symptr = 0; + internal_f.f_nsyms = 0; + internal_f.f_flags = F_AR32WR | F_LNNO; /* XXX is this correct ? */ + + if ( ! bfd_set_start_address (abfd, 0) + || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f)) + return false; + + if (bfd_coff_mkobject_hook (abfd, (PTR) & internal_f, NULL) == NULL) + return false; + + coff_data (abfd)->pe = 1; +#ifdef THUMBPEMAGIC + if (vars.magic == THUMBPEMAGIC) + /* Stop some linker warnings about thumb code not supporting interworking. */ + coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET; +#endif + + /* Switch from file contents to memory contents. */ + bfd_cache_close (abfd); + + abfd->iostream = (PTR) vars.bim; + abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */; + abfd->where = 0; + obj_sym_filepos (abfd) = 0; + + /* Now create a symbol describing the imported value. */ + switch (import_type) + { + bfd_byte * ptr; + + case IMPORT_CODE: + 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 = 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: + /* Nothing to do here. */ + break; + + default: + /* XXX code not yet written. */ + abort (); + } + + /* Point the bfd at the symbol table. */ + obj_symbols (abfd) = vars.sym_cache; + bfd_get_symcount (abfd) = vars.sym_index; + + obj_raw_syments (abfd) = vars.native_syms; + obj_raw_syment_count (abfd) = vars.sym_index; + + obj_coff_external_syms (abfd) = (PTR) vars.esym_table; + obj_coff_keep_syms (abfd) = true; + + obj_convert (abfd) = vars.sym_table; + obj_conv_table_size (abfd) = vars.sym_index; + + obj_coff_strings (abfd) = vars.string_table; + obj_coff_keep_strings (abfd) = true; + + abfd->flags |= HAS_SYMS; + + return true; +} + +/* We have detected a Image Library Format archive element. + Decode the element and return the appropriate target. */ static const bfd_target * -pe_bfd_object_p (abfd) - bfd * abfd; +pe_ILF_object_p (bfd * abfd) +{ + bfd_byte buffer[16]; + bfd_byte * ptr; + bfd_byte * symbol_name; + bfd_byte * source_dll; + unsigned int machine; + unsigned long size; + unsigned int ordinal; + unsigned int types; + unsigned short magic; + + /* Upon entry the first four buyes of the ILF header have + already been read. Now read the rest of the header. */ + if (bfd_read (buffer, 1, 16, abfd) != 16) + return NULL; + + ptr = buffer; + + /* We do not bother to check the version number. + version = bfd_h_get_16 (abfd, ptr); */ + ptr += 2; + + machine = bfd_h_get_16 (abfd, ptr); + ptr += 2; + + /* Check that the machine type is recognised. */ + magic = 0; + + switch (machine) + { + case IMAGE_FILE_MACHINE_UNKNOWN: + case IMAGE_FILE_MACHINE_ALPHA: + case IMAGE_FILE_MACHINE_ALPHA64: + case IMAGE_FILE_MACHINE_IA64: + break; + + case IMAGE_FILE_MACHINE_I386: +#ifdef I386MAGIC + magic = I386MAGIC; +#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: + + case IMAGE_FILE_MACHINE_MIPS16: + case IMAGE_FILE_MACHINE_MIPSFPU: + case IMAGE_FILE_MACHINE_MIPSFPU16: +#ifdef MIPS_ARCH_MAGIC_WINCE + magic = MIPS_ARCH_MAGIC_WINCE; +#endif + break; + + case IMAGE_FILE_MACHINE_SH3: + case IMAGE_FILE_MACHINE_SH4: +#ifdef SH_ARCH_MAGIC_WINCE + magic = SH_ARCH_MAGIC_WINCE; +#endif + break; + + case IMAGE_FILE_MACHINE_ARM: +#ifdef ARMPEMAGIC + magic = ARMPEMAGIC; +#endif + break; + + case IMAGE_FILE_MACHINE_THUMB: +#ifdef THUMBPEMAGIC + { + extern const bfd_target TARGET_LITTLE_SYM; + + if (abfd->xvec == & TARGET_LITTLE_SYM) + magic = THUMBPEMAGIC; + } +#endif + break; + + case IMAGE_FILE_MACHINE_POWERPC: + /* We no longer support PowerPC. */ + default: + _bfd_error_handler + ( +_("%s: Unrecognised machine type (0x%x) in Import Library Format archive"), + bfd_get_filename (abfd), machine); + bfd_set_error (bfd_error_malformed_archive); + + return NULL; + break; + } + + if (magic == 0) + { + _bfd_error_handler + ( +_("%s: Recognised but unhandled machine type (0x%x) in Import Library Format archive"), + bfd_get_filename (abfd), machine); + bfd_set_error (bfd_error_wrong_format); + + return NULL; + } + + /* We do not bother to check the date. + date = bfd_h_get_32 (abfd, ptr); */ + ptr += 4; + + size = bfd_h_get_32 (abfd, ptr); + ptr += 4; + + if (size == 0) + { + _bfd_error_handler + (_("%s: size field is zero in Import Library Format header"), + bfd_get_filename (abfd)); + bfd_set_error (bfd_error_malformed_archive); + + return NULL; + } + + ordinal = bfd_h_get_16 (abfd, ptr); + ptr += 2; + + types = bfd_h_get_16 (abfd, ptr); + /* ptr += 2; */ + + /* Now read in the two strings that follow. */ + ptr = bfd_alloc (abfd, size); + if (ptr == NULL) + return NULL; + + if (bfd_read (ptr, 1, size, abfd) != size) + return NULL; + + symbol_name = ptr; + source_dll = ptr + strlen (ptr) + 1; + + /* Verify that the strings are null terminated. */ + if (ptr[size - 1] != 0 || ((unsigned long) (source_dll - ptr) >= size)) + { + _bfd_error_handler + (_("%s: string not null terminated in ILF object file."), + bfd_get_filename (abfd)); + bfd_set_error (bfd_error_malformed_archive); + + return NULL; + } + + /* Now construct the bfd. */ + if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name, + source_dll, ordinal, types)) + return NULL; + + return abfd->xvec; +} + +static const bfd_target * +pe_bfd_object_p (bfd * abfd) { /* We need to handle a PE image correctly. In PE images created by the GNU linker, the offset to the COFF header is always the size. @@ -385,18 +1274,12 @@ pe_bfd_object_p (abfd) bfd_set_error (bfd_error_wrong_format); return NULL; } - + signature = bfd_h_get_32 (abfd, buffer); - + if (signature == 0xffff0000) - { - _bfd_error_handler (_("%s: Import Library Format archives are not currently supported"), - bfd_get_filename (abfd)); - bfd_set_error (bfd_error_wrong_format); - - return NULL; - } - + return pe_ILF_object_p (abfd); + if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0 || bfd_read (buffer, 1, 4, abfd) != 4) { @@ -422,7 +1305,7 @@ pe_bfd_object_p (abfd) bfd_set_error (bfd_error_wrong_format); return NULL; } - + /* Here is the hack. coff_object_p wants to read filhsz bytes to pick up the COFF header. We adjust so that that will work. 20 is the size of the i386 COFF filehdr. */ @@ -442,3 +1325,4 @@ pe_bfd_object_p (abfd) } #define coff_object_p pe_bfd_object_p +#endif /* COFF_IMAGE_WITH_PE */