X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=ld%2Fpe-dll.c;h=6b8b1af007de0e7cf4a8032076e543fa9739b340;hb=a1934524a3fc1e93084d3148ddf590eb78eba875;hp=abfd9d4b5ea4048917b64a8d9ba59497a98c596c;hpb=69c4fd86f99b86d40dfee1c9f857f6127e56efd2;p=deliverable%2Fbinutils-gdb.git diff --git a/ld/pe-dll.c b/ld/pe-dll.c index abfd9d4b5e..6b8b1af007 100644 --- a/ld/pe-dll.c +++ b/ld/pe-dll.c @@ -1,5 +1,5 @@ /* Routines to help build PEI-format DLLs (Win32 etc) - Copyright (C) 1998 Free Software Foundation, Inc. + Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc. Written by DJ Delorie This file is part of GLD, the Gnu Linker. @@ -24,6 +24,9 @@ #include "bfdlink.h" #include "libiberty.h" +#include +#include + #include "ld.h" #include "ldexp.h" #include "ldlang.h" @@ -31,9 +34,11 @@ #include "ldmisc.h" #include "ldgram.h" #include "ldmain.h" +#include "ldemul.h" #include "coff/internal.h" #include "../bfd/libcoff.h" #include "deffile.h" +#include "pe-dll.h" /************************************************************************ @@ -48,13 +53,15 @@ ************************************************************************/ -/* from emultempl/pe.em */ +/* for emultempl/pe.em */ -extern def_file *pe_def_file; -extern int pe_dll_export_everything; -extern int pe_dll_do_default_excludes; -extern int pe_dll_kill_ats; -extern int pe_dll_stdcall_aliases; +def_file *pe_def_file = 0; +int pe_dll_export_everything = 0; +int pe_dll_do_default_excludes = 1; +int pe_dll_kill_ats = 0; +int pe_dll_stdcall_aliases = 0; +int pe_dll_warn_dup_exports = 0; +int pe_dll_compat_implib = 0; /************************************************************************ @@ -67,7 +74,76 @@ static bfd_vma image_base; static bfd *filler_bfd; static struct sec *edata_s, *reloc_s; static unsigned char *edata_d, *reloc_d; -static int edata_sz, reloc_sz; +static size_t edata_sz, reloc_sz; + +typedef struct { + char *target_name; + char *object_target; + unsigned int imagebase_reloc; + int pe_arch; + int bfd_arch; + int underscored; +} pe_details_type; + +#define PE_ARCH_i386 1 +#define PE_ARCH_sh 2 +#define PE_ARCH_mips 3 +#define PE_ARCH_arm 4 + +static pe_details_type pe_detail_list[] = { + { + "pei-i386", + "pe-i386", + 7 /* R_IMAGEBASE */, + PE_ARCH_i386, + bfd_arch_i386, + 1 + }, + { + "pei-shl", + "pe-shl", + 16 /* R_SH_IMAGEBASE */, + PE_ARCH_sh, + bfd_arch_sh, + 1 + }, + { + "pei-mips", + "pe-mips", + 34 /* MIPS_R_RVA */, + PE_ARCH_mips, + bfd_arch_mips, + 0 + }, + { + "pei-arm-little", + "pe-arm-little", + 11 /* ARM_RVA32 */, + PE_ARCH_arm, + bfd_arch_arm, + 0 + }, + { NULL, NULL, 0, 0, 0, 0 } +}; + +static pe_details_type *pe_details; + +#define U(str) (pe_details->underscored ? "_" str : str) + +void +pe_dll_id_target (target) + const char *target; +{ + int i; + for (i=0; pe_detail_list[i].target_name; i++) + if (strcmp (pe_detail_list[i].target_name, target) == 0) + { + pe_details = pe_detail_list+i; + return; + } + einfo (_("%XUnsupported PEI architecture: %s\n"), target); + exit (1); +} /************************************************************************ @@ -76,13 +152,19 @@ static int edata_sz, reloc_sz; ************************************************************************/ +typedef struct { + bfd_vma vma; + char type; + short extra; +} reloc_data_type; + static int reloc_sort (va, vb) const void *va, *vb; { - unsigned long a = *(unsigned long *) va; - unsigned long b = *(unsigned long *) vb; - return a - b; + bfd_vma a = ((reloc_data_type *) va)->vma; + bfd_vma b = ((reloc_data_type *) vb)->vma; + return (a > b) ? 1 : ((a < b) ? -1 : 0); } static int @@ -175,14 +257,14 @@ auto_export (d, n) static void process_def_file (abfd, info) - bfd *abfd; + bfd *abfd ATTRIBUTE_UNUSED; struct bfd_link_info *info; { int i, j; struct bfd_link_hash_entry *blhe; bfd *b; struct sec *s; - def_file_export *e; + def_file_export *e=0; if (!pe_def_file) pe_def_file = def_file_empty (); @@ -233,7 +315,6 @@ process_def_file (abfd, info) #undef NE #define NE pe_def_file->num_exports - e = pe_def_file->exports; /* convenience */ /* Canonicalize the export list */ @@ -241,13 +322,13 @@ process_def_file (abfd, info) { for (i = 0; i < NE; i++) { - if (strchr (e[i].name, '@')) + if (strchr (pe_def_file->exports[i].name, '@')) { /* This will preserve internal_name, which may have been pointing to the same memory as name, or might not have */ - char *tmp = xstrdup (e[i].name); + char *tmp = xstrdup (pe_def_file->exports[i].name); *(strchr (tmp, '@')) = 0; - e[i].name = tmp; + pe_def_file->exports[i].name = tmp; } } } @@ -256,18 +337,21 @@ process_def_file (abfd, info) { for (i = 0; i < NE; i++) { - if (strchr (e[i].name, '@')) + if (strchr (pe_def_file->exports[i].name, '@')) { - char *tmp = xstrdup (e[i].name); + char *tmp = xstrdup (pe_def_file->exports[i].name); *(strchr (tmp, '@')) = 0; if (auto_export (pe_def_file, tmp)) - def_file_add_export (pe_def_file, tmp, e[i].internal_name, -1); + def_file_add_export (pe_def_file, tmp, + pe_def_file->exports[i].internal_name, -1); else free (tmp); } } } + e = pe_def_file->exports; /* convenience, but watch out for it changing */ + exported_symbol_offsets = (bfd_vma *) xmalloc (NE * sizeof (bfd_vma)); exported_symbol_sections = (struct sec **) xmalloc (NE * sizeof (struct sec *)); @@ -283,20 +367,22 @@ process_def_file (abfd, info) { if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0) { - /* This is a duplicate */ + /* This is a duplicate. */ if (e[j - 1].ordinal != -1 && e[i].ordinal != -1 && e[j - 1].ordinal != e[i].ordinal) { - /* xgettext:c-format */ - einfo (_("%XError, duplicate EXPORT with oridinals: %s (%d vs %d)\n"), - e[j - 1].name, e[j - 1].ordinal, e[i].ordinal); + if (pe_dll_warn_dup_exports) + /* xgettext:c-format */ + einfo (_("%XError, duplicate EXPORT with oridinals: %s (%d vs %d)\n"), + e[j - 1].name, e[j - 1].ordinal, e[i].ordinal); } else { - /* xgettext:c-format */ - einfo (_("Warning, duplicate EXPORT: %s\n"), - e[j - 1].name); + if (pe_dll_warn_dup_exports) + /* xgettext:c-format */ + einfo (_("Warning, duplicate EXPORT: %s\n"), + e[j - 1].name); } if (e[i].ordinal) e[j - 1].ordinal = e[i].ordinal; @@ -317,20 +403,34 @@ process_def_file (abfd, info) for (i = 0; i < NE; i++) { char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2); - *name = '_'; - strcpy (name + 1, pe_def_file->exports[i].internal_name); + if (pe_details->underscored) + { + *name = '_'; + strcpy (name + 1, pe_def_file->exports[i].internal_name); + } + else + strcpy (name, pe_def_file->exports[i].internal_name); blhe = bfd_link_hash_lookup (info->hash, name, false, false, true); - if (blhe && (blhe->type == bfd_link_hash_defined)) + if (blhe + && (blhe->type == bfd_link_hash_defined + || (blhe->type == bfd_link_hash_common))) { count_exported++; if (!pe_def_file->exports[i].flag_noname) count_exported_byname++; - exported_symbol_offsets[i] = blhe->u.def.value; - exported_symbol_sections[i] = blhe->u.def.section; + + /* Only fill in the sections. The actual offsets are computed + in fill_exported_offsets() after common symbols are laid + out. */ + if (blhe->type == bfd_link_hash_defined) + exported_symbol_sections[i] = blhe->u.def.section; + else + exported_symbol_sections[i] = blhe->u.c.p->section; + if (pe_def_file->exports[i].ordinal != -1) { if (max_ordinal < pe_def_file->exports[i].ordinal) @@ -340,33 +440,27 @@ process_def_file (abfd, info) count_with_ordinals++; } } - else if (blhe) + else if (blhe && blhe->type == bfd_link_hash_undefined) { /* xgettext:c-format */ - einfo (_("%XCannot export %s: symbol wrong type\n"), + einfo (_("%XCannot export %s: symbol not defined\n"), pe_def_file->exports[i].internal_name); } + else if (blhe) + { + /* xgettext:c-format */ + einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"), + pe_def_file->exports[i].internal_name, + blhe->type, bfd_link_hash_defined); + } else { /* xgettext:c-format */ einfo (_("%XCannot export %s: symbol not found\n"), pe_def_file->exports[i].internal_name); } - free(name); - } - -#if 0 - /* For now, just export all global functions. Read DEF files later */ - for (i = 0; i < num_input_bfds; i++) - { - for (j = 0; j < symtab[i].nsyms; j++) - { - if ((symtab[i].symbols[j]->flags & (BSF_FUNCTION | BSF_GLOBAL)) - == (BSF_FUNCTION | BSF_GLOBAL)) - symtab[i].exported[j] = 1; - } + free (name); } -#endif } /************************************************************************ @@ -376,9 +470,10 @@ process_def_file (abfd, info) ************************************************************************/ static void -build_filler_bfd () +build_filler_bfd (include_edata) + int include_edata; { - static lang_input_statement_type *filler_file; + lang_input_statement_type *filler_file; filler_file = lang_add_input_file ("dll stuff", lang_input_file_is_fake_enum, NULL); @@ -392,19 +487,22 @@ build_filler_bfd () return; } - edata_s = bfd_make_section_old_way (filler_bfd, ".edata"); - if (edata_s == NULL - || !bfd_set_section_flags (filler_bfd, edata_s, - (SEC_HAS_CONTENTS - | SEC_ALLOC - | SEC_LOAD - | SEC_KEEP - | SEC_IN_MEMORY))) + if (include_edata) { - einfo ("%X%P: can not create .edata section: %E\n"); - return; + edata_s = bfd_make_section_old_way (filler_bfd, ".edata"); + if (edata_s == NULL + || !bfd_set_section_flags (filler_bfd, edata_s, + (SEC_HAS_CONTENTS + | SEC_ALLOC + | SEC_LOAD + | SEC_KEEP + | SEC_IN_MEMORY))) + { + einfo ("%X%P: can not create .edata section: %E\n"); + return; + } + bfd_set_section_size (filler_bfd, edata_s, edata_sz); } - bfd_set_section_size (filler_bfd, edata_s, edata_sz); reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc"); if (reloc_s == NULL @@ -432,9 +530,9 @@ build_filler_bfd () static void generate_edata (abfd, info) bfd *abfd; - struct bfd_link_info *info; + struct bfd_link_info *info ATTRIBUTE_UNUSED; { - int i, j, next_ordinal; + int i, next_ordinal; int name_table_size = 0; const char *dlnp; @@ -514,17 +612,54 @@ generate_edata (abfd, info) + name_table_size + strlen (dll_name) + 1); } +/* Fill the exported symbol offsets. The preliminary work has already + been done in process_def_file(). */ + static void -fill_edata (abfd, info) - bfd *abfd; +fill_exported_offsets (abfd, info) + bfd *abfd ATTRIBUTE_UNUSED; struct bfd_link_info *info; { int i; + struct bfd_link_hash_entry *blhe; + + for (i = 0; i < pe_def_file->num_exports; i++) + { + char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2); + if (pe_details->underscored) + { + *name = '_'; + strcpy (name + 1, pe_def_file->exports[i].internal_name); + } + else + strcpy (name, pe_def_file->exports[i].internal_name); + + blhe = bfd_link_hash_lookup (info->hash, + name, + false, false, true); + + if (blhe && (blhe->type == bfd_link_hash_defined)) + { + exported_symbol_offsets[i] = blhe->u.def.value; + } + free (name); + } +} + +static void +fill_edata (abfd, info) + bfd *abfd; + struct bfd_link_info *info ATTRIBUTE_UNUSED; +{ + int i, hint; unsigned char *edirectory; unsigned long *eaddresses; unsigned long *enameptrs; unsigned short *eordinals; unsigned char *enamestr; + time_t now; + + time (&now); edata_d = (unsigned char *) xmalloc (edata_sz); @@ -538,6 +673,7 @@ fill_edata (abfd, info) #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base) memset (edata_d, 0, 40); + bfd_put_32 (abfd, now, edata_d + 4); if (pe_def_file->version_major != -1) { bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8); @@ -553,7 +689,10 @@ fill_edata (abfd, info) bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32); bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36); + fill_exported_offsets (abfd, info); + /* Ok, now for the filling in part */ + hint = 0; for (i = 0; i < export_table_size; i++) { int s = exported_symbols[i]; @@ -569,10 +708,11 @@ fill_edata (abfd, info) { char *ename = pe_def_file->exports[s].name; bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs); - strcpy (enamestr, ename[0] == '_' ? ename + 1 : ename); + strcpy (enamestr, ename); enamestr += strlen (enamestr) + 1; bfd_put_16 (abfd, i, (void *) eordinals); enameptrs++; + pe_def_file->exports[s].hint = hint++; } eordinals++; } @@ -592,9 +732,9 @@ generate_reloc (abfd, info) { /* for .reloc stuff */ - bfd_vma *reloc_addresses; + reloc_data_type *reloc_data; int total_relocs = 0; - int i, j; + int i; unsigned long sec_page = (unsigned long) (-1); unsigned long page_ptr, page_count; int bi; @@ -606,7 +746,7 @@ generate_reloc (abfd, info) for (s = b->sections; s; s = s->next) total_relocs += s->reloc_count; - reloc_addresses = (unsigned long *) xmalloc (total_relocs * sizeof (unsigned long)); + reloc_data = (reloc_data_type *) xmalloc (total_relocs * sizeof (reloc_data_type)); total_relocs = 0; bi = 0; @@ -621,6 +761,24 @@ generate_reloc (abfd, info) asymbol **symbols; int nsyms, symsize; + /* if it's not loaded, we don't need to relocate it this way */ + if (!(s->output_section->flags & SEC_LOAD)) + continue; + + /* I don't know why there would be a reloc for these, but I've + seen it happen - DJ */ + if (s->output_section == &bfd_abs_section) + continue; + + if (s->output_section->vma == 0) + { + /* Huh? Shouldn't happen, but punt if it does */ + einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n", + s->output_section->name, s->output_section->index, + s->output_section->flags); + continue; + } + symsize = bfd_get_symtab_upper_bound (b); symbols = (asymbol **) xmalloc (symsize); nsyms = bfd_canonicalize_symtab (b, symbols); @@ -631,12 +789,42 @@ generate_reloc (abfd, info) for (i = 0; i < nrelocs; i++) { - if (!relocs[i]->howto->pc_relative) + if (!relocs[i]->howto->pc_relative + && relocs[i]->howto->type != pe_details->imagebase_reloc) { - switch (relocs[i]->howto->bitsize) + bfd_vma sym_vma; + struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr; + sym_vma = (relocs[i]->addend + + sym->value + + sym->section->vma + + sym->section->output_offset + + sym->section->output_section->vma); + reloc_data[total_relocs].vma = sec_vma + relocs[i]->address; + +#define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift) + + switch BITS_AND_SHIFT (relocs[i]->howto->bitsize, + relocs[i]->howto->rightshift) { - case 32: - reloc_addresses[total_relocs++] = sec_vma + relocs[i]->address; + case BITS_AND_SHIFT (32, 0): + reloc_data[total_relocs].type = 3; + total_relocs++; + break; + case BITS_AND_SHIFT (16, 0): + reloc_data[total_relocs].type = 2; + total_relocs++; + break; + case BITS_AND_SHIFT (16, 16): + reloc_data[total_relocs].type = 4; + /* FIXME: we can't know the symbol's right value yet, + but we probably can safely assume that CE will relocate + us in 64k blocks, so leaving it zero is safe. */ + reloc_data[total_relocs].extra = 0; + total_relocs++; + break; + case BITS_AND_SHIFT (26, 2): + reloc_data[total_relocs].type = 5; + total_relocs++; break; default: /* xgettext:c-format */ @@ -649,7 +837,7 @@ generate_reloc (abfd, info) free (relocs); /* Warning: the allocated symbols are remembered in BFD and reused later, so don't free them! */ - /* free(symbols); */ + /* free (symbols); */ } } @@ -657,18 +845,23 @@ generate_reloc (abfd, info) reloc_addresses, which are all suitable for the .reloc section. We must now create the new sections. */ - qsort (reloc_addresses, total_relocs, sizeof (unsigned long), reloc_sort); + qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort); for (i = 0; i < total_relocs; i++) { - unsigned long this_page = (reloc_addresses[i] >> 12); + unsigned long this_page = (reloc_data[i].vma >> 12); + if (this_page != sec_page) { reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align */ reloc_sz += 8; sec_page = this_page; } + reloc_sz += 2; + + if (reloc_data[i].type == 4) + reloc_sz += 2; } reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align */ @@ -680,7 +873,7 @@ generate_reloc (abfd, info) page_count = 0; for (i = 0; i < total_relocs; i++) { - unsigned long rva = reloc_addresses[i] - image_base; + unsigned long rva = reloc_data[i].vma - image_base; unsigned long this_page = (rva & ~0xfff); if (this_page != sec_page) { @@ -694,8 +887,14 @@ generate_reloc (abfd, info) sec_page = this_page; page_count = 0; } - bfd_put_16 (abfd, (rva & 0xfff) + 0x3000, reloc_d + reloc_sz); + bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type<<12), + reloc_d + reloc_sz); reloc_sz += 2; + if (reloc_data[i].type == 4) + { + bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz); + reloc_sz += 2; + } page_count++; } while (reloc_sz & 3) @@ -721,7 +920,11 @@ quoteput (s, f, needs_quotes) { char *cp; for (cp = s; *cp; cp++) - if (*cp == '\'' || *cp == '"' || *cp == '\\' || isspace (*cp) || *cp == ',' + if (*cp == '\'' + || *cp == '"' + || *cp == '\\' + || isspace ((unsigned char) *cp) + || *cp == ',' || *cp == ';') needs_quotes = 1; if (needs_quotes) @@ -742,7 +945,7 @@ quoteput (s, f, needs_quotes) void pe_dll_generate_def_file (pe_out_def_filename) - char *pe_out_def_filename; + const char *pe_out_def_filename; { int i; FILE *out = fopen (pe_out_def_filename, "w"); @@ -753,119 +956,125 @@ pe_dll_generate_def_file (pe_out_def_filename) program_name, pe_out_def_filename); } - if (pe_def_file->name) + if (pe_def_file) { - if (pe_def_file->is_dll) - fprintf (out, "LIBRARY "); - else - fprintf (out, "NAME "); - quoteput (pe_def_file->name, out, 1); - if (pe_def_file->base_address != (bfd_vma) (-1)) - fprintf (out, " BASE=0x%x", pe_def_file->base_address); - fprintf (out, "\n"); - } + if (pe_def_file->name) + { + if (pe_def_file->is_dll) + fprintf (out, "LIBRARY "); + else + fprintf (out, "NAME "); + quoteput (pe_def_file->name, out, 1); + if (pe_data (output_bfd)->pe_opthdr.ImageBase) + fprintf (out, " BASE=0x%lx", + (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase); + fprintf (out, "\n"); + } - if (pe_def_file->description) - { - fprintf (out, "DESCRIPTION "); - quoteput (pe_def_file->description, out, 1); - fprintf (out, "\n"); - } + if (pe_def_file->description) + { + fprintf (out, "DESCRIPTION "); + quoteput (pe_def_file->description, out, 1); + fprintf (out, "\n"); + } - if (pe_def_file->version_minor) - fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major, - pe_def_file->version_minor); - else - fprintf (out, "VERSION %d\n", pe_def_file->version_major); - - if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1) - fprintf (out, "\n"); - - if (pe_def_file->stack_commit != -1) - fprintf (out, "STACKSIZE 0x%x,0x%x\n", - pe_def_file->stack_reserve, pe_def_file->stack_commit); - else if (pe_def_file->stack_reserve != -1) - fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve); - if (pe_def_file->heap_commit != -1) - fprintf (out, "HEAPSIZE 0x%x,0x%x\n", - pe_def_file->heap_reserve, pe_def_file->heap_commit); - else if (pe_def_file->heap_reserve != -1) - fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve); - - if (pe_def_file->num_section_defs > 0) - { - fprintf (out, "\nSECTIONS\n\n"); - for (i = 0; i < pe_def_file->num_section_defs; i++) + if (pe_def_file->version_minor != -1) + fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major, + pe_def_file->version_minor); + else if (pe_def_file->version_major != -1) + fprintf (out, "VERSION %d\n", pe_def_file->version_major); + + if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1) + fprintf (out, "\n"); + + if (pe_def_file->stack_commit != -1) + fprintf (out, "STACKSIZE 0x%x,0x%x\n", + pe_def_file->stack_reserve, pe_def_file->stack_commit); + else if (pe_def_file->stack_reserve != -1) + fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve); + if (pe_def_file->heap_commit != -1) + fprintf (out, "HEAPSIZE 0x%x,0x%x\n", + pe_def_file->heap_reserve, pe_def_file->heap_commit); + else if (pe_def_file->heap_reserve != -1) + fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve); + + if (pe_def_file->num_section_defs > 0) { - fprintf (out, " "); - quoteput (pe_def_file->section_defs[i].name, out, 0); - if (pe_def_file->section_defs[i].class) + fprintf (out, "\nSECTIONS\n\n"); + for (i = 0; i < pe_def_file->num_section_defs; i++) { - fprintf (out, " CLASS "); - quoteput (pe_def_file->section_defs[i].class, out, 0); + fprintf (out, " "); + quoteput (pe_def_file->section_defs[i].name, out, 0); + if (pe_def_file->section_defs[i].class) + { + fprintf (out, " CLASS "); + quoteput (pe_def_file->section_defs[i].class, out, 0); + } + if (pe_def_file->section_defs[i].flag_read) + fprintf (out, " READ"); + if (pe_def_file->section_defs[i].flag_write) + fprintf (out, " WRITE"); + if (pe_def_file->section_defs[i].flag_execute) + fprintf (out, " EXECUTE"); + if (pe_def_file->section_defs[i].flag_shared) + fprintf (out, " SHARED"); + fprintf (out, "\n"); } - if (pe_def_file->section_defs[i].flag_read) - fprintf (out, " READ"); - if (pe_def_file->section_defs[i].flag_write) - fprintf (out, " WRITE"); - if (pe_def_file->section_defs[i].flag_execute) - fprintf (out, " EXECUTE"); - if (pe_def_file->section_defs[i].flag_shared) - fprintf (out, " SHARED"); - fprintf (out, "\n"); } - } - if (pe_def_file->num_exports > 0) - { - fprintf (out, "\nEXPORTS\n\n"); - for (i = 0; i < pe_def_file->num_exports; i++) + if (pe_def_file->num_exports > 0) { - def_file_export *e = pe_def_file->exports + i; - fprintf (out, " "); - quoteput (e->name, out, 0); - if (e->internal_name && strcmp (e->internal_name, e->name)) + fprintf (out, "\nEXPORTS\n\n"); + for (i = 0; i < pe_def_file->num_exports; i++) { - fprintf (out, " = "); - quoteput (e->internal_name, out, 0); + def_file_export *e = pe_def_file->exports + i; + fprintf (out, " "); + quoteput (e->name, out, 0); + if (e->internal_name && strcmp (e->internal_name, e->name)) + { + fprintf (out, " = "); + quoteput (e->internal_name, out, 0); + } + if (e->ordinal != -1) + fprintf (out, " @%d", e->ordinal); + if (e->flag_private) + fprintf (out, " PRIVATE"); + if (e->flag_constant) + fprintf (out, " CONSTANT"); + if (e->flag_noname) + fprintf (out, " NONAME"); + if (e->flag_data) + fprintf (out, " DATA"); + + fprintf (out, "\n"); } - if (e->ordinal != -1) - fprintf (out, " @%d", e->ordinal); - if (e->flag_private) - fprintf (out, " PRIVATE"); - if (e->flag_constant) - fprintf (out, " CONSTANT"); - if (e->flag_noname) - fprintf (out, " NONAME"); - if (e->flag_data) - fprintf (out, " DATA"); - - fprintf (out, "\n"); } - } - if (pe_def_file->num_imports > 0) - { - fprintf (out, "\nIMPORTS\n\n"); - for (i = 0; i < pe_def_file->num_imports; i++) + if (pe_def_file->num_imports > 0) { - def_file_import *im = pe_def_file->imports + i; - fprintf (out, " "); - if (im->internal_name - && (!im->name || strcmp (im->internal_name, im->name))) + fprintf (out, "\nIMPORTS\n\n"); + for (i = 0; i < pe_def_file->num_imports; i++) { - quoteput (im->internal_name, out, 0); - fprintf (out, " = "); + def_file_import *im = pe_def_file->imports + i; + fprintf (out, " "); + if (im->internal_name + && (!im->name || strcmp (im->internal_name, im->name))) + { + quoteput (im->internal_name, out, 0); + fprintf (out, " = "); + } + quoteput (im->module->name, out, 0); + fprintf (out, "."); + if (im->name) + quoteput (im->name, out, 0); + else + fprintf (out, "%d", im->ordinal); + fprintf (out, "\n"); } - quoteput (im->module, out, 0); - fprintf (out, "."); - if (im->name) - quoteput (im->name, out, 0); - else - fprintf (out, "%d", im->ordinal); - fprintf (out, "\n"); } } + else + fprintf (out, _("; no contents available\n")); if (fclose (out) == EOF) { @@ -874,6 +1083,754 @@ pe_dll_generate_def_file (pe_out_def_filename) } } +/************************************************************************ + + Generate the import library + + ************************************************************************/ + +static asymbol **symtab; +static int symptr; +static int tmp_seq; +static const char *dll_filename; +static char *dll_symname; + +#define UNDSEC (asection *) &bfd_und_section + +static asection * +quick_section(abfd, name, flags, align) + bfd *abfd; + const char *name; + int flags; + int align; +{ + asection *sec; + asymbol *sym; + + sec = bfd_make_section_old_way (abfd, name); + bfd_set_section_flags (abfd, sec, flags + | SEC_ALLOC + | SEC_LOAD + | SEC_KEEP + ); + bfd_set_section_alignment (abfd, sec, align); + /* remember to undo this before trying to link internally! */ + sec->output_section = sec; + + sym = bfd_make_empty_symbol (abfd); + symtab[symptr++] = sym; + sym->name = sec->name; + sym->section = sec; + sym->flags = BSF_LOCAL; + sym->value = 0; + + return sec; +} + +static void +quick_symbol (abfd, n1, n2, n3, sec, flags, addr) + bfd *abfd; + char *n1; + char *n2; + char *n3; + asection *sec; + int flags; + int addr; +{ + asymbol *sym; + char *name = (char *) xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1); + strcpy (name, n1); + strcat (name, n2); + strcat (name, n3); + sym = bfd_make_empty_symbol (abfd); + sym->name = name; + sym->section = sec; + sym->flags = flags; + sym->value = addr; + symtab[symptr++] = sym; +} + +static arelent *reltab = 0; +static int relcount = 0, relsize = 0; + +static void +quick_reloc (abfd, address, which_howto, symidx) + bfd *abfd; + int address; + int which_howto; + int symidx; +{ + if (relcount >= (relsize-1)) + { + relsize += 10; + if (reltab) + reltab = (arelent *) xrealloc (reltab, relsize * sizeof (arelent)); + else + reltab = (arelent *) xmalloc (relsize * sizeof (arelent)); + } + reltab[relcount].address = address; + reltab[relcount].addend = 0; + reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto); + reltab[relcount].sym_ptr_ptr = symtab + symidx; + relcount++; +} + +static void +save_relocs (asection *sec) +{ + int i; + sec->relocation = reltab; + sec->reloc_count = relcount; + sec->orelocation = (arelent **) xmalloc ((relcount+1) * sizeof (arelent *)); + for (i=0; iorelocation[i] = sec->relocation + i; + sec->orelocation[relcount] = 0; + sec->flags |= SEC_RELOC; + reltab = 0; + relcount = relsize = 0; +} + +/* + * .section .idata$2 + * .global __head_my_dll + * __head_my_dll: + * .rva hname + * .long 0 + * .long 0 + * .rva __my_dll_iname + * .rva fthunk + * + * .section .idata$5 + * .long 0 + * fthunk: + * + * .section .idata$4 + * .long 0 + * hname: + */ + +static bfd * +make_head (parent) + bfd *parent; +{ + asection *id2, *id5, *id4; + unsigned char *d2, *d5, *d4; + char *oname; + bfd *abfd; + + oname = (char *) xmalloc (20); + sprintf (oname, "d%06d.o", tmp_seq); + tmp_seq++; + + abfd = bfd_create (oname, parent); + bfd_find_target (pe_details->object_target, abfd); + bfd_make_writable (abfd); + + bfd_set_format (abfd, bfd_object); + bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0); + + symptr = 0; + symtab = (asymbol **) xmalloc (6 * sizeof (asymbol *)); + id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2); + id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2); + id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2); + quick_symbol (abfd, U("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0); + quick_symbol (abfd, U(""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0); + + /* OK, pay attention here. I got confused myself looking back at + it. We create a four-byte section to mark the beginning of the + list, and we include an offset of 4 in the section, so that the + pointer to the list points to the *end* of this section, which is + the start of the list of sections from other objects. */ + + bfd_set_section_size (abfd, id2, 20); + d2 = (unsigned char *) xmalloc (20); + id2->contents = d2; + memset (d2, 0, 20); + d2[0] = d2[16] = 4; /* reloc addend */ + quick_reloc (abfd, 0, BFD_RELOC_RVA, 2); + quick_reloc (abfd, 12, BFD_RELOC_RVA, 4); + quick_reloc (abfd, 16, BFD_RELOC_RVA, 1); + save_relocs (id2); + + bfd_set_section_size (abfd, id5, 4); + d5 = (unsigned char *) xmalloc (4); + id5->contents = d5; + memset (d5, 0, 4); + + bfd_set_section_size (abfd, id4, 4); + d4 = (unsigned char *) xmalloc (4); + id4->contents = d4; + memset (d4, 0, 4); + + bfd_set_symtab (abfd, symtab, symptr); + + bfd_set_section_contents (abfd, id2, d2, 0, 20); + bfd_set_section_contents (abfd, id5, d5, 0, 4); + bfd_set_section_contents (abfd, id4, d4, 0, 4); + + bfd_make_readable (abfd); + return abfd; +} + +/* + * .section .idata$4 + * .long 0 + * .section .idata$5 + * .long 0 + * .section idata$7 + * .global __my_dll_iname + *__my_dll_iname: + * .asciz "my.dll" + */ + +static bfd * +make_tail (parent) + bfd *parent; +{ + asection *id4, *id5, *id7; + unsigned char *d4, *d5, *d7; + int len; + char *oname; + bfd *abfd; + + oname = (char *) xmalloc (20); + sprintf (oname, "d%06d.o", tmp_seq); + tmp_seq++; + + abfd = bfd_create (oname, parent); + bfd_find_target (pe_details->object_target, abfd); + bfd_make_writable (abfd); + + bfd_set_format (abfd, bfd_object); + bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0); + + symptr = 0; + symtab = (asymbol **) xmalloc (5 * sizeof (asymbol *)); + id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2); + id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2); + id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2); + quick_symbol (abfd, U(""), dll_symname, "_iname", id7, BSF_GLOBAL, 0); + + bfd_set_section_size (abfd, id4, 4); + d4 = (unsigned char *) xmalloc (4); + id4->contents = d4; + memset (d4, 0, 4); + + bfd_set_section_size (abfd, id5, 4); + d5 = (unsigned char *) xmalloc (4); + id5->contents = d5; + memset (d5, 0, 4); + + len = strlen (dll_filename)+1; + if (len & 1) + len ++; + bfd_set_section_size (abfd, id7, len); + d7 = (unsigned char *) xmalloc (len); + id7->contents = d7; + strcpy (d7, dll_filename); + + bfd_set_symtab (abfd, symtab, symptr); + + bfd_set_section_contents (abfd, id4, d4, 0, 4); + bfd_set_section_contents (abfd, id5, d5, 0, 4); + bfd_set_section_contents (abfd, id7, d7, 0, len); + + bfd_make_readable (abfd); + return abfd; +} + +/* + * .text + * .global _function + * .global ___imp_function + * .global __imp__function + *_function: + * jmp *__imp__function: + * + * .section idata$7 + * .long __head_my_dll + * + * .section .idata$5 + *___imp_function: + *__imp__function: + *iat? + * .section .idata$4 + *iat? + * .section .idata$6 + *ID: + * .short + * .asciz "function" xlate? (add underscore, kill at) + */ + +static unsigned char jmp_ix86_bytes[] = { + 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 +}; + +/* + *_function: + * mov.l ip+8,r0 + * mov.l @r0,r0 + * jmp @r0 + * nop + * .dw __imp_function + */ + +static unsigned char jmp_sh_bytes[] = { + 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +/* + *_function: + * lui $t0, + * lw $t0, + * jr $t0 + * nop + */ + +static unsigned char jmp_mips_bytes[] = { + 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d, + 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 +}; + +static bfd * +make_one (exp, parent) + def_file_export *exp; + bfd *parent; +{ + asection *tx, *id7, *id5, *id4, *id6; + unsigned char *td, *d7, *d5, *d4, *d6 = NULL; + int len; + char *oname; + bfd *abfd; + unsigned char *jmp_bytes = NULL; + int jmp_byte_count = 0; + + switch (pe_details->pe_arch) + { + case PE_ARCH_i386: + jmp_bytes = jmp_ix86_bytes; + jmp_byte_count = sizeof (jmp_ix86_bytes); + break; + case PE_ARCH_sh: + jmp_bytes = jmp_sh_bytes; + jmp_byte_count = sizeof (jmp_sh_bytes); + break; + case PE_ARCH_mips: + jmp_bytes = jmp_mips_bytes; + jmp_byte_count = sizeof (jmp_mips_bytes); + break; + } + + oname = (char *) xmalloc (20); + sprintf (oname, "d%06d.o", tmp_seq); + tmp_seq++; + + abfd = bfd_create (oname, parent); + bfd_find_target (pe_details->object_target, abfd); + bfd_make_writable (abfd); + + bfd_set_format (abfd, bfd_object); + bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0); + + symptr = 0; + symtab = (asymbol **) xmalloc (10 * sizeof (asymbol *)); + tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2); + id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2); + id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2); + id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2); + id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2); + if (! exp->flag_data) + quick_symbol (abfd, U(""), exp->internal_name, "", tx, BSF_GLOBAL, 0); + quick_symbol (abfd, U("_head_"), dll_symname, "", UNDSEC, BSF_GLOBAL, 0); + quick_symbol (abfd, U("__imp_"), exp->internal_name, "", id5, BSF_GLOBAL, 0); + if (pe_dll_compat_implib) + quick_symbol (abfd, U("__imp_"), exp->internal_name, "", + id5, BSF_GLOBAL, 0); + + bfd_set_section_size (abfd, tx, jmp_byte_count); + td = (unsigned char *) xmalloc (jmp_byte_count); + tx->contents = td; + memcpy (td, jmp_bytes, jmp_byte_count); + switch (pe_details->pe_arch) + { + case PE_ARCH_i386: + quick_reloc (abfd, 2, BFD_RELOC_32, 2); + break; + case PE_ARCH_sh: + quick_reloc (abfd, 8, BFD_RELOC_32, 2); + break; + case PE_ARCH_mips: + quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2); + quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */ + quick_reloc (abfd, 4, BFD_RELOC_LO16, 2); + break; + } + save_relocs (tx); + + bfd_set_section_size (abfd, id7, 4); + d7 = (unsigned char *) xmalloc (4); + id7->contents = d7; + memset (d7, 0, 4); + quick_reloc (abfd, 0, BFD_RELOC_RVA, 6); + save_relocs (id7); + + bfd_set_section_size (abfd, id5, 4); + d5 = (unsigned char *) xmalloc (4); + id5->contents = d5; + memset (d5, 0, 4); + if (exp->flag_noname) + { + d5[0] = exp->ordinal; + d5[1] = exp->ordinal >> 8; + d5[3] = 0x80; + } + else + { + quick_reloc (abfd, 0, BFD_RELOC_RVA, 4); + save_relocs (id5); + } + + bfd_set_section_size (abfd, id4, 4); + d4 = (unsigned char *) xmalloc (4); + id4->contents = d4; + memset (d4, 0, 4); + if (exp->flag_noname) + { + d5[0] = exp->ordinal; + d5[1] = exp->ordinal >> 8; + d5[3] = 0x80; + } + else + { + quick_reloc (abfd, 0, BFD_RELOC_RVA, 4); + save_relocs (id4); + } + + if (exp->flag_noname) + { + len = 0; + bfd_set_section_size (abfd, id6, 0); + } + else + { + len = strlen (exp->name) + 3; + if (len & 1) + len++; + bfd_set_section_size (abfd, id6, len); + d6 = (unsigned char *) xmalloc (len); + id6->contents = d6; + memset (d6, 0, len); + d6[0] = exp->hint & 0xff; + d6[1] = exp->hint >> 8; + strcpy (d6+2, exp->name); + } + + bfd_set_symtab (abfd, symtab, symptr); + + bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count); + bfd_set_section_contents (abfd, id7, d7, 0, 4); + bfd_set_section_contents (abfd, id5, d5, 0, 4); + bfd_set_section_contents (abfd, id4, d4, 0, 4); + if (!exp->flag_noname) + bfd_set_section_contents (abfd, id6, d6, 0, len); + + bfd_make_readable (abfd); + return abfd; +} + +void +pe_dll_generate_implib (def, impfilename) + def_file *def; + const char *impfilename; +{ + int i; + bfd *ar_head; + bfd *ar_tail; + bfd *outarch; + bfd *head = 0; + + dll_filename = (def->name) ? def->name : dll_name; + dll_symname = xstrdup (dll_filename); + for (i=0; dll_symname[i]; i++) + if (!isalnum ((unsigned char) dll_symname[i])) + dll_symname[i] = '_'; + + unlink (impfilename); + + outarch = bfd_openw (impfilename, 0); + + if (!outarch) + { + /* xgettext:c-format */ + einfo (_("%XCan't open .lib file: %s\n"), impfilename); + return; + } + + /* xgettext:c-format */ + einfo (_("Creating library file: %s\n"), impfilename); + + bfd_set_format (outarch, bfd_archive); + outarch->has_armap = 1; + + /* Work out a reasonable size of things to put onto one line. */ + + ar_head = make_head (outarch); + + for (i = 0; inum_exports; i++) + { + /* The import library doesn't know about the internal name */ + char *internal = def->exports[i].internal_name; + bfd *n; + def->exports[i].internal_name = def->exports[i].name; + n = make_one (def->exports+i, outarch); + n->next = head; + head = n; + def->exports[i].internal_name = internal; + } + + ar_tail = make_tail (outarch); + + if (ar_head == NULL || ar_tail == NULL) + return; + + /* Now stick them all into the archive */ + + ar_head->next = head; + ar_tail->next = ar_head; + head = ar_tail; + + if (! bfd_set_archive_head (outarch, head)) + einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ())); + + if (! bfd_close (outarch)) + einfo ("%Xbfd_close %s: %s\n", impfilename, bfd_errmsg (bfd_get_error ())); + + while (head != NULL) + { + bfd *n = head->next; + bfd_close (head); + head = n; + } +} + +static void +add_bfd_to_link (abfd, name, link_info) + bfd *abfd; + char *name; + struct bfd_link_info *link_info; +{ + lang_input_statement_type *fake_file; + fake_file = lang_add_input_file (name, + lang_input_file_is_fake_enum, + NULL); + fake_file->the_bfd = abfd; + ldlang_add_file (fake_file); + if (!bfd_link_add_symbols (abfd, link_info)) + einfo ("%Xaddsym %s: %s\n", name, bfd_errmsg (bfd_get_error ())); +} + +void +pe_process_import_defs (output_bfd, link_info) + bfd *output_bfd; + struct bfd_link_info *link_info; +{ + def_file_module *module; + pe_dll_id_target(bfd_get_target (output_bfd)); + + if (!pe_def_file) + return; + + for (module = pe_def_file->modules; module; module = module->next) + { + int i, do_this_dll; + + dll_filename = module->name; + dll_symname = xstrdup (module->name); + for (i=0; dll_symname[i]; i++) + if (!isalnum (dll_symname[i])) + dll_symname[i] = '_'; + + do_this_dll = 0; + + for (i=0; inum_imports; i++) + if (pe_def_file->imports[i].module == module) + { + def_file_export exp; + struct bfd_link_hash_entry *blhe; + + /* see if we need this import */ + char *name = (char *) xmalloc (strlen (pe_def_file->imports[i].internal_name) + 2); + sprintf (name, "%s%s", U(""), pe_def_file->imports[i].internal_name); + blhe = bfd_link_hash_lookup (link_info->hash, name, + false, false, false); + free (name); + if (blhe && blhe->type == bfd_link_hash_undefined) + { + bfd *one; + /* we do */ + if (!do_this_dll) + { + bfd *ar_head = make_head (output_bfd); + add_bfd_to_link (ar_head, ar_head->filename, link_info); + do_this_dll = 1; + } + exp.internal_name = pe_def_file->imports[i].internal_name; + exp.name = pe_def_file->imports[i].name; + exp.ordinal = pe_def_file->imports[i].ordinal; + exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0; + exp.flag_private = 0; + exp.flag_constant = 0; + exp.flag_data = 0; + exp.flag_noname = exp.name ? 0 : 1; + one = make_one (&exp, output_bfd); + add_bfd_to_link (one, one->filename, link_info); + } + } + if (do_this_dll) + { + bfd *ar_tail = make_tail (output_bfd); + add_bfd_to_link (ar_tail, ar_tail->filename, link_info); + } + + free (dll_symname); + } +} + +/************************************************************************ + + We were handed a *.DLL file. Parse it and turn it into a set of + IMPORTS directives in the def file. Return true if the file was + handled, false if not. + + ************************************************************************/ + +static unsigned int +pe_get16 (abfd, where) + bfd *abfd; + int where; +{ + unsigned char b[2]; + bfd_seek (abfd, where, SEEK_SET); + bfd_read (b, 1, 2, abfd); + return b[0] + (b[1]<<8); +} + +static unsigned int +pe_get32 (abfd, where) + bfd *abfd; + int where; +{ + unsigned char b[4]; + bfd_seek (abfd, where, SEEK_SET); + bfd_read (b, 1, 4, abfd); + return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24); +} + +#if 0 /* This is not currently used. */ + +static unsigned int +pe_as16 (ptr) + void *ptr; +{ + unsigned char *b = ptr; + return b[0] + (b[1]<<8); +} + +#endif + +static unsigned int +pe_as32 (ptr) + void *ptr; +{ + unsigned char *b = ptr; + return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24); +} + +boolean +pe_implied_import_dll (filename) + const char *filename; +{ + bfd *dll; + unsigned long pe_header_offset, opthdr_ofs, num_entries, i; + unsigned long export_rva, export_size, nsections, secptr, expptr; + unsigned char *expdata, *erva; + unsigned long name_rvas, ordinals, nexp, ordbase; + const char *dll_name; + + /* No, I can't use bfd here. kernel32.dll puts its export table in + the middle of the .rdata section. */ + + dll = bfd_openr (filename, pe_details->target_name); + if (!dll) + { + einfo ("%Xopen %s: %s\n", filename, bfd_errmsg (bfd_get_error ())); + return false; + } + /* PEI dlls seem to be bfd_objects */ + if (!bfd_check_format (dll, bfd_object)) + { + einfo ("%X%s: this doesn't appear to be a DLL\n", filename); + return false; + } + + dll_name = filename; + for (i=0; filename[i]; i++) + if (filename[i] == '/' || filename[i] == '\\' || filename[i] == ':') + dll_name = filename + i + 1; + + pe_header_offset = pe_get32 (dll, 0x3c); + opthdr_ofs = pe_header_offset + 4 + 20; + num_entries = pe_get32 (dll, opthdr_ofs + 92); + if (num_entries < 1) /* no exports */ + return false; + export_rva = pe_get32 (dll, opthdr_ofs + 96); + export_size = pe_get32 (dll, opthdr_ofs + 100); + nsections = pe_get16 (dll, pe_header_offset + 4 + 2); + secptr = (pe_header_offset + 4 + 20 + + pe_get16 (dll, pe_header_offset + 4 + 16)); + expptr = 0; + for (i=0; i export_rva) + { + expptr = fptr + (export_rva - vaddr); + if (export_rva + export_size > vaddr + vsize) + export_size = vsize - (export_rva - vaddr); + break; + } + } + + expdata = (unsigned char *) xmalloc (export_size); + bfd_seek (dll, expptr, SEEK_SET); + bfd_read (expdata, 1, export_size, dll); + erva = expdata - export_rva; + + if (pe_def_file == 0) + pe_def_file = def_file_empty(); + + nexp = pe_as32 (expdata+24); + name_rvas = pe_as32 (expdata+32); + ordinals = pe_as32 (expdata+36); + ordbase = pe_as32 (expdata+16); + for (i=0; ipe_opthdr.ImageBase; generate_reloc (abfd, info); @@ -926,3 +1894,31 @@ pe_dll_fill_sections (abfd, info) edata_s->contents = edata_d; reloc_s->contents = reloc_d; } + +void +pe_exe_fill_sections (abfd, info) + bfd *abfd; + struct bfd_link_info *info; +{ + pe_dll_id_target (bfd_get_target (abfd)); + image_base = pe_data (abfd)->pe_opthdr.ImageBase; + + generate_reloc (abfd, info); + if (reloc_sz > 0) + { + bfd_set_section_size (filler_bfd, reloc_s, reloc_sz); + + /* Resize the sections. */ + lang_size_sections (stat_ptr->head, abs_output_section, + &stat_ptr->head, 0, (bfd_vma) 0, false); + + /* Redo special stuff. */ + ldemul_after_allocation (); + + /* Do the assignments again. */ + lang_do_assignments (stat_ptr->head, + abs_output_section, + (fill_type) 0, (bfd_vma) 0); + } + reloc_s->contents = reloc_d; +}