X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=binutils%2Fdlltool.c;h=c9a673840312738cfbb7f327ccb234de758a3d4f;hb=5df31fad477b5fcf31de404fa11b35a9b5768b59;hp=117943955c6561d0ac60076f7b6b94af1b31fca1;hpb=002898399e0ee6ad78cefa75c27b1dcae9308b2b;p=platform%2Fupstream%2Fbinutils.git diff --git a/binutils/dlltool.c b/binutils/dlltool.c index 1179439..c9a6738 100644 --- a/binutils/dlltool.c +++ b/binutils/dlltool.c @@ -1,5 +1,6 @@ -/* dlltool.c -- tool to generate stuff for PE style DLLs - Copyright (C) 1995 Free Software Foundation, Inc. +/* dlltool.c -- tool to generate stuff for PE style DLLs + Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 + Free Software Foundation, Inc. This file is part of GNU Binutils. @@ -15,67 +16,78 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ -/* - This program allows you to build the files necessary to create +/* This program allows you to build the files necessary to create DLLs to run on a system which understands PE format image files. (eg, Windows NT) + See "Peering Inside the PE: A Tour of the Win32 Portable Executable + File Format", MSJ 1994, Volume 9 for more information. + Also see "Microsoft Portable Executable and Common Object File Format, + Specification 4.1" for more information. + A DLL contains an export table which contains the information which the runtime loader needs to tie up references from a - referencing program. + referencing program. The export table is generated by this program by reading in a .DEF file or scanning the .a and .o files which will be in the - DLL. A .o file can contain information in special ".drective" sections - with export information. + DLL. A .o file can contain information in special ".drectve" sections + with export information. A DEF file contains any number of the following commands: - NAME [ , ] + NAME [ , ] The result is going to be .EXE - LIBRARY [ , ] + LIBRARY [ , ] The result is going to be .DLL - EXPORTS ( [ = ] [ @ ] [ NONAME ] [CONSTANT] ) * + EXPORTS ( ( ( [ = ] ) + | ( = . )) + [ @ ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) * Declares name1 as an exported symbol from the - DLL, with optional ordinal number + DLL, with optional ordinal number . + Or declares name1 as an alias (forward) of the function + in the DLL . - IMPORTS ( [ = ] . ) * - Ignored for compatibility + IMPORTS ( ( = . ) + | ( [ = ] . )) * + Declares that or the exported function whoes ordinal number + is is to be imported from the file . If + is specified then this is the name that the imported + function will be refereed to in the body of the DLL. DESCRIPTION Puts into output .exp file in the .rdata section [STACKSIZE|HEAPSIZE] [ , ] Generates --stack|--heap , - in the output .drective section. The linker will + in the output .drectve section. The linker will see this and act upon it. [CODE|DATA] + SECTIONS ( + )* = READ | WRITE | EXECUTE | SHARED Generates --attr in the output - .drective section. The linker will see this and act + .drectve section. The linker will see this and act upon it. - A -export: in a .drective section in an input .o or .a + A -export: in a .drectve section in an input .o or .a file to this program is equivalent to a EXPORTS in a .DEF file. The program generates output files with the prefix supplied - on the command line, or in the def file, or taken from the first + on the command line, or in the def file, or taken from the first supplied argument. - The output files are -exp.s and -lib.s - The .exp.s file contains the information necessary to export the routines in the DLL. The .lib.s file contains the information necessary to use the DLL's routines from a referencing program. @@ -84,222 +96,806 @@ Example: - file1.c: - asm (".section .drectve"); + file1.c: + asm (".section .drectve"); asm (".ascii \"-export:adef\""); - adef(char *s) + void adef (char * s) { - printf("hello from the dll %s\n",s); + printf ("hello from the dll %s\n", s); } - bdef(char *s) + void bdef (char * s) { - printf("hello from the dll and the other entry point %s\n",s); + printf ("hello from the dll and the other entry point %s\n", s); } - file2.c: + file2.c: asm (".section .drectve"); asm (".ascii \"-export:cdef\""); asm (".ascii \"-export:ddef\""); - cdef(char *s) + + void cdef (char * s) { - printf("hello from the dll %s\n",s); + printf ("hello from the dll %s\n", s); } - ddef(char *s) + void ddef (char * s) { - printf("hello from the dll and the other entry point %s\n",s); + printf ("hello from the dll and the other entry point %s\n", s); } - printf() + int printf (void) { - return 9; + return 9; } - main.c - - main() + themain.c: + int main (void) { - cdef(); + cdef (); + return 0; } - thedll.def + thedll.def LIBRARY thedll HEAPSIZE 0x40000, 0x2000 EXPORTS bdef @ 20 - cdef @ 30 NONAME + cdef @ 30 NONAME SECTIONS donkey READ WRITE aardvark EXECUTE + # Compile up the parts of the dll and the program - # compile up the parts of the dll - - gcc -c file1.c - gcc -c file2.c + gcc -c file1.c file2.c themain.c - # put them in a library (you don't have to, you - # could name all the .os on the dlltool line) + # Optional: put the dll objects into a library + # (you don't have to, you could name all the object + # files on the dlltool line) ar qcv thedll.in file1.o file2.o ranlib thedll.in - # run this tool over the library and the def file - ./dlltool -o thedll -d thedll.def thedll.in + # Run this tool over the DLL's .def file and generate an exports + # file (thedll.o) and an imports file (thedll.a). + # (You may have to use -S to tell dlltool where to find the assembler). + + dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a + + # Build the dll with the library and the export table + + ld -o thedll.dll thedll.o thedll.in + + # Link the executable with the import library + + gcc -o themain.exe themain.o thedll.a + + This example can be extended if relocations are needed in the DLL: + + # Compile up the parts of the dll and the program + + gcc -c file1.c file2.c themain.c + + # Run this tool over the DLL's .def file and generate an imports file. + + dlltool --def thedll.def --output-lib thedll.lib - # build the export table for the dll - as -o thedll.exp thedll-exp.s - # build the dll with the library with file1.o, file2.o and the export table - ld -o thedll.dll thedll.exp thedll.in + # Link the executable with the import library and generate a base file + # at the same time - # build the import table for the executable - as -o thedll.lib thedll-lib.s + gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base - # build the mainline - gcc -c themain.c + # Run this tool over the DLL's .def file and generate an exports file + # which includes the relocations from the base file. - # link the executable with the import library - ld -e main -Tthemain.ld -o themain.exe themain.o thedll.lib + dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp - */ + # Build the dll with file1.o, file2.o and the export table + + ld -o thedll.dll thedll.exp file1.o file2.o */ + +/* .idata section description + + The .idata section is the import table. It is a collection of several + subsections used to keep the pieces for each dll together: .idata$[234567]. + IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc. + + .idata$2 = Import Directory Table + = array of IMAGE_IMPORT_DESCRIPTOR's. + + DWORD Import Lookup Table; - pointer to .idata$4 + DWORD TimeDateStamp; - currently always 0 + DWORD ForwarderChain; - currently always 0 + DWORD Name; - pointer to dll's name + PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5 + + .idata$3 = null terminating entry for .idata$2. + + .idata$4 = Import Lookup Table + = array of array of pointers to hint name table. + There is one for each dll being imported from, and each dll's set is + terminated by a trailing NULL. + + .idata$5 = Import Address Table + = array of array of pointers to hint name table. + There is one for each dll being imported from, and each dll's set is + terminated by a trailing NULL. + Initially, this table is identical to the Import Lookup Table. However, + at load time, the loader overwrites the entries with the address of the + function. + + .idata$6 = Hint Name Table + = Array of { short, asciz } entries, one for each imported function. + The `short' is the function's ordinal number. + + .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc). */ + +/* AIX requires this to be the first thing in the file. */ +#ifndef __GNUC__ +# ifdef _AIX + #pragma alloca +#endif +#endif + +#define show_allnames 0 #define PAGE_SIZE 4096 #define PAGE_MASK (-PAGE_SIZE) -#include -#include -#include -#include "getopt.h" #include "bfd.h" -int yydebug; -char *def_file; -char *program_name; -char *strrchr (); -char *outfile_prefix; -char *xmalloc (); -char *strdup (); +#include "libiberty.h" +#include "bucomm.h" +#include "getopt.h" +#include "demangle.h" +#include "dyn-string.h" +#include "dlltool.h" +#include "safe-ctype.h" + +#include +#include + +#ifdef ANSI_PROTOTYPES +#include +#else +#include +#endif + +#ifdef DLLTOOL_ARM +#include "coff/arm.h" +#include "coff/internal.h" +#endif + +/* Forward references. */ +static char *look_for_prog (const char *, const char *, int); +static char *deduce_name (const char *); + +#ifdef DLLTOOL_MCORE_ELF +static void mcore_elf_cache_filename (char *); +static void mcore_elf_gen_out_file (void); +#endif + +#ifdef HAVE_SYS_WAIT_H +#include +#else /* ! HAVE_SYS_WAIT_H */ +#if ! defined (_WIN32) || defined (__CYGWIN32__) +#ifndef WIFEXITED +#define WIFEXITED(w) (((w) & 0377) == 0) +#endif +#ifndef WIFSIGNALED +#define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0) +#endif +#ifndef WTERMSIG +#define WTERMSIG(w) ((w) & 0177) +#endif +#ifndef WEXITSTATUS +#define WEXITSTATUS(w) (((w) >> 8) & 0377) +#endif +#else /* defined (_WIN32) && ! defined (__CYGWIN32__) */ +#ifndef WIFEXITED +#define WIFEXITED(w) (((w) & 0xff) == 0) +#endif +#ifndef WIFSIGNALED +#define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f) +#endif +#ifndef WTERMSIG +#define WTERMSIG(w) ((w) & 0x7f) +#endif +#ifndef WEXITSTATUS +#define WEXITSTATUS(w) (((w) & 0xff00) >> 8) +#endif +#endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */ +#endif /* ! HAVE_SYS_WAIT_H */ + +/* ifunc and ihead data structures: ttk@cygnus.com 1997 + + When IMPORT declarations are encountered in a .def file the + function import information is stored in a structure referenced by + the global variable IMPORT_LIST. The structure is a linked list + containing the names of the dll files each function is imported + from and a linked list of functions being imported from that dll + file. This roughly parallels the structure of the .idata section + in the PE object file. + + The contents of .def file are interpreted from within the + process_def_file function. Every time an IMPORT declaration is + encountered, it is broken up into its component parts and passed to + def_import. IMPORT_LIST is initialized to NULL in function main. */ + +typedef struct ifunct +{ + char * name; /* Name of function being imported. */ + int ord; /* Two-byte ordinal value associated with function. */ + struct ifunct *next; +} ifunctype; + +typedef struct iheadt +{ + char *dllname; /* Name of dll file imported from. */ + long nfuncs; /* Number of functions in list. */ + struct ifunct *funchead; /* First function in list. */ + struct ifunct *functail; /* Last function in list. */ + struct iheadt *next; /* Next dll file in list. */ +} iheadtype; + +/* Structure containing all import information as defined in .def file + (qv "ihead structure"). */ + +static iheadtype *import_list = NULL; + +static char *as_name = NULL; +static char * as_flags = ""; + +static char *tmp_prefix; + +static int no_idata4; +static int no_idata5; +static char *exp_name; +static char *imp_name; +static char *head_label; +static char *imp_name_lab; +static char *dll_name; + +static int add_indirect = 0; +static int add_underscore = 0; +static int dontdeltemps = 0; + +/* TRUE if we should export all symbols. Otherwise, we only export + symbols listed in .drectve sections or in the def file. */ +static bfd_boolean export_all_symbols; + +/* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when + exporting all symbols. */ +static bfd_boolean do_default_excludes = TRUE; + +/* Default symbols to exclude when exporting all the symbols. */ +static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr"; + +/* TRUE if we should add __imp_ to import libraries for backward + compatibility to old Cygwin releases. */ +static bfd_boolean create_compat_implib; + +static char *def_file; + +extern char * program_name; static int machine; -int suckunderscore; -int killat; +static int killat; +static int add_stdcall_alias; +static const char *ext_prefix_alias; static int verbose; -FILE *base_file; +static FILE *output_def; +static FILE *base_file; + #ifdef DLLTOOL_ARM -static char *mname = "arm"; +#ifdef DLLTOOL_ARM_EPOC +static const char *mname = "arm-epoc"; +#else +static const char *mname = "arm"; +#endif #endif #ifdef DLLTOOL_I386 -static char *mname = "i386"; +static const char *mname = "i386"; +#endif + +#ifdef DLLTOOL_PPC +static const char *mname = "ppc"; +#endif + +#ifdef DLLTOOL_SH +static const char *mname = "sh"; +#endif + +#ifdef DLLTOOL_MIPS +static const char *mname = "mips"; +#endif + +#ifdef DLLTOOL_MCORE +static const char * mname = "mcore-le"; +#endif + +#ifdef DLLTOOL_MCORE_ELF +static const char * mname = "mcore-elf"; +static char * mcore_elf_out_file = NULL; +static char * mcore_elf_linker = NULL; +static char * mcore_elf_linker_flags = NULL; + +#define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve") +#endif + +#ifndef DRECTVE_SECTION_NAME +#define DRECTVE_SECTION_NAME ".drectve" +#endif + +#define PATHMAX 250 /* What's the right name for this ? */ + +char *tmp_asm_buf; +char *tmp_head_s_buf; +char *tmp_head_o_buf; +char *tmp_tail_s_buf; +char *tmp_tail_o_buf; +char *tmp_stub_buf; + +#define TMP_ASM dlltmp (&tmp_asm_buf, "%sc.s") +#define TMP_HEAD_S dlltmp (&tmp_head_s_buf, "%sh.s") +#define TMP_HEAD_O dlltmp (&tmp_head_o_buf, "%sh.o") +#define TMP_TAIL_S dlltmp (&tmp_tail_s_buf, "%st.s") +#define TMP_TAIL_O dlltmp (&tmp_tail_o_buf, "%st.o") +#define TMP_STUB dlltmp (&tmp_stub_buf, "%ss") + +/* This bit of assembly does jmp * .... */ +static const unsigned char i386_jtab[] = +{ + 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 +}; + +static const unsigned char arm_jtab[] = +{ + 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */ + 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */ + 0, 0, 0, 0 +}; + +static const unsigned char arm_interwork_jtab[] = +{ + 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */ + 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */ + 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */ + 0, 0, 0, 0 +}; + +static const unsigned char thumb_jtab[] = +{ + 0x40, 0xb4, /* push {r6} */ + 0x02, 0x4e, /* ldr r6, [pc, #8] */ + 0x36, 0x68, /* ldr r6, [r6] */ + 0xb4, 0x46, /* mov ip, r6 */ + 0x40, 0xbc, /* pop {r6} */ + 0x60, 0x47, /* bx ip */ + 0, 0, 0, 0 +}; + +static const unsigned char mcore_be_jtab[] = +{ + 0x71, 0x02, /* lrw r1,2 */ + 0x81, 0x01, /* ld.w r1,(r1,0) */ + 0x00, 0xC1, /* jmp r1 */ + 0x12, 0x00, /* nop */ + 0x00, 0x00, 0x00, 0x00 /*
*/ +}; + +static const unsigned char mcore_le_jtab[] = +{ + 0x02, 0x71, /* lrw r1,2 */ + 0x01, 0x81, /* ld.w r1,(r1,0) */ + 0xC1, 0x00, /* jmp r1 */ + 0x00, 0x12, /* nop */ + 0x00, 0x00, 0x00, 0x00 /*
*/ +}; + +/* This is the glue sequence for PowerPC PE. There is a + tocrel16-tocdefn reloc against the first instruction. + We also need a IMGLUE reloc against the glue function + to restore the toc saved by the third instruction in + the glue. */ +static const unsigned char ppc_jtab[] = +{ + 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */ + /* Reloc TOCREL16 __imp_xxx */ + 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */ + 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */ + 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */ + 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */ + 0x20, 0x04, 0x80, 0x4E /* bctr */ +}; + +#ifdef DLLTOOL_PPC +/* The glue instruction, picks up the toc from the stw in + the above code: "lwz r2,4(r1)". */ +static bfd_vma ppc_glue_insn = 0x80410004; #endif -#define PATHMAX 250 /* What's the right name for this ? */ -char outfile[PATHMAX]; struct mac { - char *type; - char *how_byte; - char *how_short; - char *how_long; - char *how_asciz; - char *how_comment; - char *how_jump; - char *how_global; - char *how_space; - } -mtable[] -= + const char *type; + const char *how_byte; + const char *how_short; + const char *how_long; + const char *how_asciz; + const char *how_comment; + const char *how_jump; + const char *how_global; + const char *how_space; + const char *how_align_short; + const char *how_align_long; + const char *how_default_as_switches; + const char *how_bfd_target; + enum bfd_architecture how_bfd_arch; + const unsigned char *how_jtab; + int how_jtab_size; /* Size of the jtab entry. */ + int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */ + }; + +static const struct mac +mtable[] = { { - "arm", ".byte", ".short", ".long", ".asciz", "@", "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long", ".global", ".space" +#define MARM 0 + "arm", ".byte", ".short", ".long", ".asciz", "@", + "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long", + ".global", ".space", ".align\t2",".align\t4", "-mapcs-32", + "pe-arm-little", bfd_arch_arm, + arm_jtab, sizeof (arm_jtab), 8 + } + , + { +#define M386 1 + "i386", ".byte", ".short", ".long", ".asciz", "#", + "jmp *", ".global", ".space", ".align\t2",".align\t4", "", + "pe-i386",bfd_arch_i386, + i386_jtab, sizeof (i386_jtab), 2 + } + , + { +#define MPPC 2 + "ppc", ".byte", ".short", ".long", ".asciz", "#", + "jmp *", ".global", ".space", ".align\t2",".align\t4", "", + "pe-powerpcle",bfd_arch_powerpc, + ppc_jtab, sizeof (ppc_jtab), 0 + } + , + { +#define MTHUMB 3 + "thumb", ".byte", ".short", ".long", ".asciz", "@", + "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip", + ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork", + "pe-arm-little", bfd_arch_arm, + thumb_jtab, sizeof (thumb_jtab), 12 + } + , +#define MARM_INTERWORK 4 + { + "arm_interwork", ".byte", ".short", ".long", ".asciz", "@", + "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long", + ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork", + "pe-arm-little", bfd_arch_arm, + arm_interwork_jtab, sizeof (arm_interwork_jtab), 12 + } + , + { +#define MMCORE_BE 5 + "mcore-be", ".byte", ".short", ".long", ".asciz", "//", + "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long", + ".global", ".space", ".align\t2",".align\t4", "", + "pe-mcore-big", bfd_arch_mcore, + mcore_be_jtab, sizeof (mcore_be_jtab), 8 + } + , + { +#define MMCORE_LE 6 + "mcore-le", ".byte", ".short", ".long", ".asciz", "//", + "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long", + ".global", ".space", ".align\t2",".align\t4", "-EL", + "pe-mcore-little", bfd_arch_mcore, + mcore_le_jtab, sizeof (mcore_le_jtab), 8 + } + , + { +#define MMCORE_ELF 7 + "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//", + "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long", + ".global", ".space", ".align\t2",".align\t4", "", + "elf32-mcore-big", bfd_arch_mcore, + mcore_be_jtab, sizeof (mcore_be_jtab), 8 + } + , + { +#define MMCORE_ELF_LE 8 + "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//", + "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long", + ".global", ".space", ".align\t2",".align\t4", "-EL", + "elf32-mcore-little", bfd_arch_mcore, + mcore_le_jtab, sizeof (mcore_le_jtab), 8 } , { - "i386", ".byte", ".short", ".long", ".asciz", "#", "jmp *", ".global", ".space" +#define MARM_EPOC 9 + "arm-epoc", ".byte", ".short", ".long", ".asciz", "@", + "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long", + ".global", ".space", ".align\t2",".align\t4", "", + "epoc-pe-arm-little", bfd_arch_arm, + arm_jtab, sizeof (arm_jtab), 8 } , - 0 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }; -#define ASM_BYTE mtable[machine].how_byte -#define ASM_SHORT mtable[machine].how_short -#define ASM_LONG mtable[machine].how_long -#define ASM_TEXT mtable[machine].how_asciz -#define ASM_C mtable[machine].how_comment -#define ASM_JUMP mtable[machine].how_jump -#define ASM_GLOBAL mtable[machine].how_global -#define ASM_SPACE mtable[machine].how_space +typedef struct dlist +{ + char *text; + struct dlist *next; +} +dlist_type; + +typedef struct export + { + const char *name; + const char *internal_name; + int ordinal; + int constant; + int noname; /* Don't put name in image file. */ + int private; /* Don't put reference in import lib. */ + int data; + int hint; + int forward; /* Number of forward label, 0 means no forward. */ + struct export *next; + } +export_type; + +/* A list of symbols which we should not export. */ +struct string_list +{ + struct string_list *next; + char *string; +}; -static char **oav; +static struct string_list *excludes; + +static const char *rvaafter (int); +static const char *rvabefore (int); +static const char *asm_prefix (int, const char *); +static void process_def_file (const char *); +static void new_directive (char *); +static void append_import (const char *, const char *, int); +static void run (const char *, char *); +static void scan_drectve_symbols (bfd *); +static void scan_filtered_symbols (bfd *, void *, long, unsigned int); +static void add_excludes (const char *); +static bfd_boolean match_exclude (const char *); +static void set_default_excludes (void); +static long filter_symbols (bfd *, void *, long, unsigned int); +static void scan_all_symbols (bfd *); +static void scan_open_obj_file (bfd *); +static void scan_obj_file (const char *); +static void dump_def_info (FILE *); +static int sfunc (const void *, const void *); +static void flush_page (FILE *, long *, int, int); +static void gen_def_file (void); +static void generate_idata_ofile (FILE *); +static void assemble_file (const char *, const char *); +static void gen_exp_file (void); +static const char *xlate (const char *); +#if 0 +static void dump_iat (FILE *, export_type *); +#endif +static char *make_label (const char *, const char *); +static char *make_imp_label (const char *, const char *); +static bfd *make_one_lib_file (export_type *, int); +static bfd *make_head (void); +static bfd *make_tail (void); +static void gen_lib_file (void); +static int pfunc (const void *, const void *); +static int nfunc (const void *, const void *); +static void remove_null_names (export_type **); +static void dtab (export_type **); +static void process_duplicates (export_type **); +static void fill_ordinals (export_type **); +static int alphafunc (const void *, const void *); +static void mangle_defs (void); +static void usage (FILE *, int); +static void inform (const char *, ...); -int i; +static char * +prefix_encode (char *start, unsigned code) +{ + static char alpha[26] = "abcdefghijklmnopqrstuvwxyz"; + static char buf[32]; + char *p; + strcpy (buf, start); + p = strchr (buf, '\0'); + do + *p++ = alpha[code % sizeof (alpha)]; + while ((code /= sizeof (alpha)) != 0); + *p = '\0'; + return buf; +} -FILE *yyin; /* communications with flex */ -extern int linenumber; -void -process_def_file (name) - char *name; +static char * +dlltmp (char **buf, const char *fmt) { - FILE *f = fopen (name, "r"); - if (!f) + if (!*buf) { - fprintf (stderr, "%s: Can't open def file %s\n", program_name, name); - exit (1); + *buf = malloc (strlen (tmp_prefix) + 64); + sprintf (*buf, fmt, tmp_prefix); } + return *buf; +} - yyin = f; +static void +inform VPARAMS ((const char * message, ...)) +{ + VA_OPEN (args, message); + VA_FIXEDARG (args, const char *, message); - yyparse (); + if (!verbose) + return; + + report (message, args); + + VA_CLOSE (args); } -/**********************************************************************/ +static const char * +rvaafter (int machine) +{ + switch (machine) + { + case MARM: + case M386: + case MPPC: + case MTHUMB: + case MARM_INTERWORK: + case MMCORE_BE: + case MMCORE_LE: + case MMCORE_ELF: + case MMCORE_ELF_LE: + case MARM_EPOC: + break; + default: + /* xgettext:c-format */ + fatal (_("Internal error: Unknown machine type: %d"), machine); + break; + } + return ""; +} + +static const char * +rvabefore (int machine) +{ + switch (machine) + { + case MARM: + case M386: + case MPPC: + case MTHUMB: + case MARM_INTERWORK: + case MMCORE_BE: + case MMCORE_LE: + case MMCORE_ELF: + case MMCORE_ELF_LE: + case MARM_EPOC: + return ".rva\t"; + default: + /* xgettext:c-format */ + fatal (_("Internal error: Unknown machine type: %d"), machine); + break; + } + return ""; +} -/* Communications with the parser */ +static const char * +asm_prefix (int machine, const char *name) +{ + switch (machine) + { + case MARM: + case MPPC: + case MTHUMB: + case MARM_INTERWORK: + case MMCORE_BE: + case MMCORE_LE: + case MMCORE_ELF: + case MMCORE_ELF_LE: + case MARM_EPOC: + break; + case M386: + /* Symbol names starting with ? do not have a leading underscore. */ + if (name && *name == '?') + break; + else + return "_"; + default: + /* xgettext:c-format */ + fatal (_("Internal error: Unknown machine type: %d"), machine); + break; + } + return ""; +} +#define ASM_BYTE mtable[machine].how_byte +#define ASM_SHORT mtable[machine].how_short +#define ASM_LONG mtable[machine].how_long +#define ASM_TEXT mtable[machine].how_asciz +#define ASM_C mtable[machine].how_comment +#define ASM_JUMP mtable[machine].how_jump +#define ASM_GLOBAL mtable[machine].how_global +#define ASM_SPACE mtable[machine].how_space +#define ASM_ALIGN_SHORT mtable[machine].how_align_short +#define ASM_RVA_BEFORE rvabefore (machine) +#define ASM_RVA_AFTER rvaafter (machine) +#define ASM_PREFIX(NAME) asm_prefix (machine, (NAME)) +#define ASM_ALIGN_LONG mtable[machine].how_align_long +#define HOW_BFD_READ_TARGET 0 /* Always default. */ +#define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target +#define HOW_BFD_ARCH mtable[machine].how_bfd_arch +#define HOW_JTAB mtable[machine].how_jtab +#define HOW_JTAB_SIZE mtable[machine].how_jtab_size +#define HOW_JTAB_ROFF mtable[machine].how_jtab_roff +#define ASM_SWITCHES mtable[machine].how_default_as_switches -typedef struct dlist +static char **oav; + +static void +process_def_file (const char *name) { - char *text; - struct dlist *next; + FILE *f = fopen (name, FOPEN_RT); + + if (!f) + /* xgettext:c-format */ + fatal (_("Can't open def file: %s"), name); + + yyin = f; + + /* xgettext:c-format */ + inform (_("Processing def file: %s"), name); + + yyparse (); + + inform (_("Processed def file")); } -dlist_type; -typedef struct export - { - char *name; - char *internal_name; - int ordinal; - int constant; - int noname; - struct export *next; - } -export_type; +/**********************************************************************/ -static char *d_name; /* Arg to NAME or LIBRARY */ -static int d_nfuncs; /* Number of functions exported */ -static int d_ord; /* Base ordinal index */ -static export_type *d_exports; /*list of exported functions */ -static char *d_suffix = "dll"; -static dlist_type *d_list; /* Descriptions */ -static dlist_type *a_list; /* Stuff to go in directives */ +/* Communications with the parser. */ + +static const char *d_name; /* Arg to NAME or LIBRARY. */ +static int d_nfuncs; /* Number of functions exported. */ +static int d_named_nfuncs; /* Number of named functions exported. */ +static int d_low_ord; /* Lowest ordinal index. */ +static int d_high_ord; /* Highest ordinal index. */ +static export_type *d_exports; /* List of exported functions. */ +static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */ +static dlist_type *d_list; /* Descriptions. */ +static dlist_type *a_list; /* Stuff to go in directives. */ +static int d_nforwards = 0; /* Number of forwarded exports. */ static int d_is_dll; static int d_is_exe; -yyerror () +int +yyerror (const char * err ATTRIBUTE_UNUSED) { - fprintf (stderr, "%s: Syntax error in def file %s:%d\n", - program_name, def_file, linenumber); + /* xgettext:c-format */ + non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber); + + return 0; } void -def_exports (name, internal_name, ordinal, noname, constant) - char *name; - char *internal_name; - int ordinal; - int noname; - int constant; +def_exports (const char *name, const char *internal_name, int ordinal, + int noname, int constant, int data, int private) { struct export *p = (struct export *) xmalloc (sizeof (*p)); @@ -308,114 +904,194 @@ def_exports (name, internal_name, ordinal, noname, constant) p->ordinal = ordinal; p->constant = constant; p->noname = noname; + p->private = private; + p->data = data; p->next = d_exports; d_exports = p; d_nfuncs++; -} + if ((internal_name != NULL) + && (strchr (internal_name, '.') != NULL)) + p->forward = ++d_nforwards; + else + p->forward = 0; /* no forward */ +} void -def_name (name, base) - char *name; - int base; +def_name (const char *name, int base) { - if (verbose) - fprintf (stderr, "%s NAME %s base %x\n", program_name, name, base); + /* xgettext:c-format */ + inform (_("NAME: %s base: %x"), name, base); + if (d_is_dll) - { - fprintf (stderr, "Can't have LIBRARY and NAME\n"); - } + non_fatal (_("Can't have LIBRARY and NAME")); + d_name = name; - if (strchr (d_name, '.')) - d_suffix = strdup (strchr (d_name, '.') + 1); + /* If --dllname not provided, use the one in the DEF file. + FIXME: Is this appropriate for executables? */ + if (! dll_name) + dll_name = xstrdup (name); d_is_exe = 1; } void -def_library (name, base) - char *name; - int base; +def_library (const char *name, int base) { - if (verbose) - printf ("%s: LIBRARY %s base %x\n", program_name, name, base); + /* xgettext:c-format */ + inform (_("LIBRARY: %s base: %x"), name, base); + if (d_is_exe) - { - fprintf (stderr, "%s: Can't have LIBRARY and NAME\n", program_name); - } + non_fatal (_("Can't have LIBRARY and NAME")); + d_name = name; - if (strchr (d_name, '.')) - d_suffix = strdup (strchr (d_name, '.') + 1); + /* If --dllname not provided, use the one in the DEF file. */ + if (! dll_name) + dll_name = xstrdup (name); d_is_dll = 1; } void -def_description (desc) - char *desc; +def_description (const char *desc) { dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type)); - d->text = strdup (desc); + d->text = xstrdup (desc); d->next = d_list; d_list = d; } -void -new_directive (dir) - char *dir; +static void +new_directive (char *dir) { dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type)); - d->text = strdup (dir); + d->text = xstrdup (dir); d->next = a_list; a_list = d; } void -def_stacksize (reserve, commit) - int reserve; - int commit; +def_heapsize (int reserve, int commit) { char b[200]; if (commit > 0) - sprintf (b, "-stack 0x%x,0x%x ", reserve, commit); + sprintf (b, "-heap 0x%x,0x%x ", reserve, commit); else - sprintf (b, "-stack 0x%x ", reserve); - new_directive (strdup (b)); + sprintf (b, "-heap 0x%x ", reserve); + new_directive (xstrdup (b)); } void -def_heapsize (reserve, commit) - int reserve; - int commit; +def_stacksize (int reserve, int commit) { char b[200]; if (commit > 0) - sprintf (b, "-heap 0x%x,0x%x ", reserve, commit); + sprintf (b, "-stack 0x%x,0x%x ", reserve, commit); else - sprintf (b, "-heap 0x%x ", reserve); - new_directive (strdup (b)); + sprintf (b, "-stack 0x%x ", reserve); + new_directive (xstrdup (b)); +} + +/* append_import simply adds the given import definition to the global + import_list. It is used by def_import. */ + +static void +append_import (const char *symbol_name, const char *dll_name, int func_ordinal) +{ + iheadtype **pq; + iheadtype *q; + + for (pq = &import_list; *pq != NULL; pq = &(*pq)->next) + { + if (strcmp ((*pq)->dllname, dll_name) == 0) + { + q = *pq; + q->functail->next = xmalloc (sizeof (ifunctype)); + q->functail = q->functail->next; + q->functail->ord = func_ordinal; + q->functail->name = xstrdup (symbol_name); + q->functail->next = NULL; + q->nfuncs++; + return; + } + } + + q = xmalloc (sizeof (iheadtype)); + q->dllname = xstrdup (dll_name); + q->nfuncs = 1; + q->funchead = xmalloc (sizeof (ifunctype)); + q->functail = q->funchead; + q->next = NULL; + q->functail->name = xstrdup (symbol_name); + q->functail->ord = func_ordinal; + q->functail->next = NULL; + + *pq = q; } +/* def_import is called from within defparse.y when an IMPORT + declaration is encountered. Depending on the form of the + declaration, the module name may or may not need ".dll" to be + appended to it, the name of the function may be stored in internal + or entry, and there may or may not be an ordinal value associated + with it. */ + +/* A note regarding the parse modes: + In defparse.y we have to accept import declarations which follow + any one of the following forms: + = . + = . + . + . + Furthermore, the dll's name may or may not end with ".dll", which + complicates the parsing a little. Normally the dll's name is + passed to def_import() in the "module" parameter, but when it ends + with ".dll" it gets passed in "module" sans ".dll" and that needs + to be reappended. + + def_import gets five parameters: + APP_NAME - the name of the function in the application, if + present, or NULL if not present. + MODULE - the name of the dll, possibly sans extension (ie, '.dll'). + DLLEXT - the extension of the dll, if present, NULL if not present. + ENTRY - the name of the function in the dll, if present, or NULL. + ORD_VAL - the numerical tag of the function in the dll, if present, + or NULL. Exactly one of or must be + present (i.e., not NULL). */ void -def_import (internal, module, entry) - char *internal; - char *module; - char *entry; +def_import (const char *app_name, const char *module, const char *dllext, + const char *entry, int ord_val) { - if (verbose) - fprintf (stderr, "%s: IMPORTS are ignored", program_name); + const char *application_name; + char *buf; + + if (entry != NULL) + application_name = entry; + else + { + if (app_name != NULL) + application_name = app_name; + else + application_name = ""; + } + + if (dllext != NULL) + { + buf = (char *) alloca (strlen (module) + strlen (dllext) + 2); + sprintf (buf, "%s.%s", module, dllext); + module = buf; + } + + append_import (application_name, module, ord_val); } void -def_version (major, minor) +def_version (int major, int minor) { printf ("VERSION %d.%d\n", major, minor); } - void -def_section (name, attr) - char *name; - int attr; +def_section (const char *name, int attr) { char buf[200]; char atts[5]; @@ -431,102 +1107,382 @@ def_section (name, attr) *d++ = 'S'; *d++ = 0; sprintf (buf, "-attr %s %s", name, atts); - new_directive (strdup (buf)); + new_directive (xstrdup (buf)); } + void -def_code (attr) - int attr; +def_code (int attr) { def_section ("CODE", attr); } void -def_data (attr) - int attr; +def_data (int attr) { def_section ("DATA", attr); } - /**********************************************************************/ -/* read in and block out the base relocations */ -static void -basenames (abfd) - bfd *abfd; +static void +run (const char *what, char *args) { + char *s; + int pid, wait_status; + int i; + const char **argv; + char *errmsg_fmt, *errmsg_arg; + char *temp_base = choose_temp_base (); + inform ("run: %s %s", what, args); + /* Count the args */ + i = 0; + for (s = args; *s; s++) + if (*s == ' ') + i++; + i++; + argv = alloca (sizeof (char *) * (i + 3)); + i = 0; + argv[i++] = what; + s = args; + while (1) + { + while (*s == ' ') + ++s; + argv[i++] = s; + while (*s != ' ' && *s != 0) + s++; + if (*s == 0) + break; + *s++ = 0; + } + argv[i++] = NULL; + pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base, + &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH); + if (pid == -1) + { + inform (strerror (errno)); + + fatal (errmsg_fmt, errmsg_arg); + } + + pid = pwait (pid, & wait_status, 0); + + if (pid == -1) + { + /* xgettext:c-format */ + fatal (_("wait: %s"), strerror (errno)); + } + else if (WIFSIGNALED (wait_status)) + { + /* xgettext:c-format */ + fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status)); + } + else if (WIFEXITED (wait_status)) + { + if (WEXITSTATUS (wait_status) != 0) + /* xgettext:c-format */ + non_fatal (_("%s exited with status %d"), + what, WEXITSTATUS (wait_status)); + } + else + abort (); } -void -scan_open_obj_file (abfd) - bfd *abfd; +/* Look for a list of symbols to export in the .drectve section of + ABFD. Pass each one to def_exports. */ + +static void +scan_drectve_symbols (bfd *abfd) { - /* Look for .drectives */ - asection *s = bfd_get_section_by_name (abfd, ".drectve"); - if (s) + asection * s; + int size; + char * buf; + char * p; + char * e; + + /* Look for .drectve's */ + s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME); + + if (s == NULL) + return; + + size = bfd_get_section_size (s); + buf = xmalloc (size); + + bfd_get_section_contents (abfd, s, buf, 0, size); + + /* xgettext:c-format */ + inform (_("Sucking in info from %s section in %s"), + DRECTVE_SECTION_NAME, bfd_get_filename (abfd)); + + /* Search for -export: strings. The exported symbols can optionally + have type tags (eg., -export:foo,data), so handle those as well. + Currently only data tag is supported. */ + p = buf; + e = buf + size; + while (p < e) { - int size = bfd_get_section_size_before_reloc (s); - char *buf = xmalloc (size); - char *p; - char *e; - bfd_get_section_contents (abfd, s, buf, 0, size); - if (verbose) - fprintf (stderr, "%s: Sucking in info from %s\n", - program_name, - bfd_get_filename (abfd)); - - /* Search for -export: strings */ - p = buf; - e = buf + size; - while (p < e) + if (p[0] == '-' + && strncmp (p, "-export:", 8) == 0) { - if (p[0] == '-' - && strncmp (p, "-export:", 8) == 0) + char * name; + char * c; + flagword flags = BSF_FUNCTION; + + p += 8; + name = p; + while (p < e && *p != ',' && *p != ' ' && *p != '-') + p++; + c = xmalloc (p - name + 1); + memcpy (c, name, p - name); + c[p - name] = 0; + if (p < e && *p == ',') /* found type tag. */ { - char *name; - char *c; - p += 8; - name = p; - while (*p != ' ' && *p != '-' && p < e) + char *tag_start = ++p; + while (p < e && *p != ' ' && *p != '-') p++; - c = xmalloc (p - name + 1); - memcpy (c, name, p - name); - c[p - name] = 0; - def_exports (c, 0, -1, 0); + if (strncmp (tag_start, "data", 4) == 0) + flags &= ~BSF_FUNCTION; + } + + /* FIXME: The 5th arg is for the `constant' field. + What should it be? Not that it matters since it's not + currently useful. */ + def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0); + + if (add_stdcall_alias && strchr (c, '@')) + { + int lead_at = (*c == '@') ; + char *exported_name = xstrdup (c + lead_at); + char *atsym = strchr (exported_name, '@'); + *atsym = '\0'; + /* Note: stdcall alias symbols can never be data. */ + def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0); } - else - p++; } - free (buf); + else + p++; } + free (buf); +} - basenames (abfd); +/* Look through the symbols in MINISYMS, and add each one to list of + symbols to export. */ - if (verbose) - fprintf (stderr, "%s: Done readin\n", - program_name); +static void +scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount, + unsigned int size) +{ + asymbol *store; + bfd_byte *from, *fromend; + store = bfd_make_empty_symbol (abfd); + if (store == NULL) + bfd_fatal (bfd_get_filename (abfd)); + + from = (bfd_byte *) minisyms; + fromend = from + symcount * size; + for (; from < fromend; from += size) + { + asymbol *sym; + const char *symbol_name; + + sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store); + if (sym == NULL) + bfd_fatal (bfd_get_filename (abfd)); + + symbol_name = bfd_asymbol_name (sym); + if (bfd_get_symbol_leading_char (abfd) == symbol_name[0]) + ++symbol_name; + + def_exports (xstrdup (symbol_name) , 0, -1, 0, 0, + ! (sym->flags & BSF_FUNCTION), 0); + + if (add_stdcall_alias && strchr (symbol_name, '@')) + { + int lead_at = (*symbol_name == '@'); + char *exported_name = xstrdup (symbol_name + lead_at); + char *atsym = strchr (exported_name, '@'); + *atsym = '\0'; + /* Note: stdcall alias symbols can never be data. */ + def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0); + } + } } +/* Add a list of symbols to exclude. */ -void -scan_obj_file (filename) - char *filename; +static void +add_excludes (const char *new_excludes) { - bfd *f = bfd_openr (filename, 0); + char *local_copy; + char *exclude_string; - if (!f) + local_copy = xstrdup (new_excludes); + + exclude_string = strtok (local_copy, ",:"); + for (; exclude_string; exclude_string = strtok (NULL, ",:")) + { + struct string_list *new_exclude; + + new_exclude = ((struct string_list *) + xmalloc (sizeof (struct string_list))); + new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2); + /* Don't add a leading underscore for fastcall symbols. */ + if (*exclude_string == '@') + sprintf (new_exclude->string, "%s", exclude_string); + else + sprintf (new_exclude->string, "_%s", exclude_string); + new_exclude->next = excludes; + excludes = new_exclude; + + /* xgettext:c-format */ + inform (_("Excluding symbol: %s"), exclude_string); + } + + free (local_copy); +} + +/* See if STRING is on the list of symbols to exclude. */ + +static bfd_boolean +match_exclude (const char *string) +{ + struct string_list *excl_item; + + for (excl_item = excludes; excl_item; excl_item = excl_item->next) + if (strcmp (string, excl_item->string) == 0) + return TRUE; + return FALSE; +} + +/* Add the default list of symbols to exclude. */ + +static void +set_default_excludes (void) +{ + add_excludes (default_excludes); +} + +/* Choose which symbols to export. */ + +static long +filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size) +{ + bfd_byte *from, *fromend, *to; + asymbol *store; + + store = bfd_make_empty_symbol (abfd); + if (store == NULL) + bfd_fatal (bfd_get_filename (abfd)); + + from = (bfd_byte *) minisyms; + fromend = from + symcount * size; + to = (bfd_byte *) minisyms; + + for (; from < fromend; from += size) + { + int keep = 0; + asymbol *sym; + + sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store); + if (sym == NULL) + bfd_fatal (bfd_get_filename (abfd)); + + /* Check for external and defined only symbols. */ + keep = (((sym->flags & BSF_GLOBAL) != 0 + || (sym->flags & BSF_WEAK) != 0 + || bfd_is_com_section (sym->section)) + && ! bfd_is_und_section (sym->section)); + + keep = keep && ! match_exclude (sym->name); + + if (keep) + { + memcpy (to, from, size); + to += size; + } + } + + return (to - (bfd_byte *) minisyms) / size; +} + +/* Export all symbols in ABFD, except for ones we were told not to + export. */ + +static void +scan_all_symbols (bfd *abfd) +{ + long symcount; + void *minisyms; + unsigned int size; + + /* Ignore bfds with an import descriptor table. We assume that any + such BFD contains symbols which are exported from another DLL, + and we don't want to reexport them from here. */ + if (bfd_get_section_by_name (abfd, ".idata$4")) + return; + + if (! (bfd_get_file_flags (abfd) & HAS_SYMS)) { - fprintf (stderr, "%s: Unable to open object file %s\n", - program_name, - filename); - exit (1); + /* xgettext:c-format */ + non_fatal (_("%s: no symbols"), bfd_get_filename (abfd)); + return; } + + symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size); + if (symcount < 0) + bfd_fatal (bfd_get_filename (abfd)); + + if (symcount == 0) + { + /* xgettext:c-format */ + non_fatal (_("%s: no symbols"), bfd_get_filename (abfd)); + return; + } + + /* Discard the symbols we don't want to export. It's OK to do this + in place; we'll free the storage anyway. */ + + symcount = filter_symbols (abfd, minisyms, symcount, size); + scan_filtered_symbols (abfd, minisyms, symcount, size); + + free (minisyms); +} + +/* Look at the object file to decide which symbols to export. */ + +static void +scan_open_obj_file (bfd *abfd) +{ + if (export_all_symbols) + scan_all_symbols (abfd); + else + scan_drectve_symbols (abfd); + + /* FIXME: we ought to read in and block out the base relocations. */ + + /* xgettext:c-format */ + inform (_("Done reading %s"), bfd_get_filename (abfd)); +} + +static void +scan_obj_file (const char *filename) +{ + bfd * f = bfd_openr (filename, 0); + + if (!f) + /* xgettext:c-format */ + fatal (_("Unable to open object file: %s"), filename); + + /* xgettext:c-format */ + inform (_("Scanning object file %s"), filename); + if (bfd_check_format (f, bfd_archive)) { bfd *arfile = bfd_openr_next_archived_file (f, 0); @@ -537,11 +1493,20 @@ scan_obj_file (filename) bfd_close (arfile); arfile = bfd_openr_next_archived_file (f, arfile); } - } - if (bfd_check_format (f, bfd_object)) +#ifdef DLLTOOL_MCORE_ELF + if (mcore_elf_out_file) + inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename); +#endif + } + else if (bfd_check_format (f, bfd_object)) { scan_open_obj_file (f); + +#ifdef DLLTOOL_MCORE_ELF + if (mcore_elf_out_file) + mcore_elf_cache_filename ((char *) filename); +#endif } bfd_close (f); @@ -549,24 +1514,8 @@ scan_obj_file (filename) /**********************************************************************/ - -/* return the bit of the name before the last . */ - -static -char * -prefix (name) - char *name; -{ - char *res = strdup (name); - char *p = strrchr (res, '.'); - if (p) - *p = 0; - return res; -} - -void -dump_def_info (f) - FILE *f; +static void +dump_def_info (FILE *f) { int i; export_type *exp; @@ -576,36 +1525,34 @@ dump_def_info (f) fprintf (f, "\n"); for (i = 0, exp = d_exports; exp; i++, exp = exp->next) { - fprintf (f, "%s %d = %s %s @ %d %s%s\n", + fprintf (f, "%s %d = %s %s @ %d %s%s%s%s\n", ASM_C, i, exp->name, exp->internal_name, exp->ordinal, exp->noname ? "NONAME " : "", - exp->constant ? "CONSTANT" : ""); + exp->private ? "PRIVATE " : "", + exp->constant ? "CONSTANT" : "", + exp->data ? "DATA" : ""); } } -/* Generate the .exp file */ -int -sfunc (a, b) - long *a; - long *b; +/* Generate the .exp file. */ + +static int +sfunc (const void *a, const void *b) { - return *a - *b; + return *(const long *) a - *(const long *) b; } -static void -flush_page (f, need, page_addr, on_page) - FILE *f; - long *need; - long page_addr; - int on_page; +static void +flush_page (FILE *f, long *need, int page_addr, int on_page) { int i; - /* Flush this page */ - fprintf (f, "\t%s\t0x%x\t%s Starting RVA for chunk\n", + + /* Flush this page. */ + fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n", ASM_LONG, page_addr, ASM_C); @@ -613,151 +1560,370 @@ flush_page (f, need, page_addr, on_page) ASM_LONG, (on_page * 2) + (on_page & 1) * 2 + 8, ASM_C); + for (i = 0; i < on_page; i++) { - fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, need[i] - page_addr | 0x3000); + long needed = need[i]; + + if (needed) + needed = ((needed - page_addr) | 0x3000) & 0xffff; + + fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed); } + /* And padding */ if (on_page & 1) fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000); - } - -void -gen_exp_file () +static void +gen_def_file (void) { - FILE *f; int i; export_type *exp; - dlist_type *dl; - int had_noname = 0; - sprintf (outfile, "%s-exp.s", outfile_prefix); + inform (_("Adding exports to output file")); - if (verbose) - fprintf (stderr, "%s: Generate exp file %s\n", - program_name, outfile_prefix); + fprintf (output_def, ";"); + for (i = 0; oav[i]; i++) + fprintf (output_def, " %s", oav[i]); - f = fopen (outfile, "w"); - if (!f) - { - fprintf (stderr, "%s: Unable to open output file %s\n", program_name, outfile); - exit (1); - } - if (verbose) - { - fprintf (stderr, "%s: Opened file %s\n", - program_name, outfile); - } + fprintf (output_def, "\nEXPORTS\n"); - dump_def_info (f); - fprintf (f, "\t.section .edata\n\n"); - fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C); - fprintf (f, "\t%s %d %s Time and date\n", ASM_LONG, time (0), ASM_C); - fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C); - fprintf (f, "\t%s name %s Ptr to name of dll\n", ASM_LONG, ASM_C); - fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_ord, ASM_C); - fprintf (f, "\t%s The next field is documented as being the number of functions\n", ASM_C); - fprintf (f, "\t%s yet it doesn't look like that in real PE dlls\n", ASM_C); - fprintf (f, "\t%s But it shouldn't be a problem, causes there's\n", ASM_C); - fprintf (f, "\t%s always the number of names field\n", ASM_C); - fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_nfuncs, ASM_C); - fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG, d_nfuncs, ASM_C); - fprintf (f, "\t%s afuncs %s Address of functions\n", ASM_LONG, ASM_C); - fprintf (f, "\t%s anames %s Address of names\n", ASM_LONG, ASM_C); - fprintf (f, "\t%s anords %s Address of ordinals\n", ASM_LONG, ASM_C); - - fprintf (f, "name: %s \"%s.%s\"\n", ASM_TEXT, outfile_prefix, d_suffix); - - fprintf (f, "afuncs:\n"); - i = d_ord; - for (exp = d_exports; exp; exp = exp->next) + for (i = 0, exp = d_exports; exp; i++, exp = exp->next) { -#if 0 - /* This seems necessary in the doc, but in real - life it's not used.. */ - if (exp->ordinal != i) + char *quote = strchr (exp->name, '.') ? "\"" : ""; + char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS); + + if (res) { - fprintf (f, "%s\t%s\t%d\t@ %d..%d missing\n", ASM_C, ASM_SPACE, - (exp->ordinal - i) * 4, - i, exp->ordinal - 1); - i = exp->ordinal; + fprintf (output_def,";\t%s\n", res); + free (res); } -#endif - fprintf (f, "\t%s %s\t%s %d\n", ASM_LONG, exp->internal_name, ASM_C, exp->ordinal); - i++; - } - - fprintf (f, "anames:\n"); - for (i = 0, exp = d_exports; exp; i++, exp = exp->next) - { - if (exp->noname) + if (strcmp (exp->name, exp->internal_name) == 0) { - had_noname = 1; - fprintf (f, "\t%s nNoname\n", ASM_LONG, ASM_C); + fprintf (output_def, "\t%s%s%s @ %d%s%s%s\n", + quote, + exp->name, + quote, + exp->ordinal, + exp->noname ? " NONAME" : "", + exp->private ? "PRIVATE " : "", + exp->data ? " DATA" : ""); } else { - fprintf (f, "\t%s n%d\n", ASM_LONG, i); + char * quote1 = strchr (exp->internal_name, '.') ? "\"" : ""; + /* char *alias = */ + fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s\n", + quote, + exp->name, + quote, + quote1, + exp->internal_name, + quote1, + exp->ordinal, + exp->noname ? " NONAME" : "", + exp->private ? "PRIVATE " : "", + exp->data ? " DATA" : ""); } } - fprintf (f, "anords:\n"); - for (exp = d_exports; exp; exp = exp->next) - fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_ord); + inform (_("Added exports to output file")); +} - for (i = 0, exp = d_exports; exp; i++, exp = exp->next) - if (exp->noname) - fprintf (f, "@n%d: %s \"%s\"\n", i, ASM_TEXT, exp->name); - else - fprintf (f, "n%d: %s \"%s\"\n", i, ASM_TEXT, exp->name); +/* generate_idata_ofile generates the portable assembly source code + for the idata sections. It appends the source code to the end of + the file. */ - if (had_noname) - fprintf (f, "nNoname: %s \"__noname__\"\n", ASM_TEXT); +static void +generate_idata_ofile (FILE *filvar) +{ + iheadtype *headptr; + ifunctype *funcptr; + int headindex; + int funcindex; + int nheads; + + if (import_list == NULL) + return; + + fprintf (filvar, "%s Import data sections\n", ASM_C); + fprintf (filvar, "\n\t.section\t.idata$2\n"); + fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL); + fprintf (filvar, "doi_idata:\n"); + + nheads = 0; + for (headptr = import_list; headptr != NULL; headptr = headptr->next) + { + fprintf (filvar, "\t%slistone%d%s\t%s %s\n", + ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER, + ASM_C, headptr->dllname); + fprintf (filvar, "\t%s\t0\n", ASM_LONG); + fprintf (filvar, "\t%s\t0\n", ASM_LONG); + fprintf (filvar, "\t%sdllname%d%s\n", + ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER); + fprintf (filvar, "\t%slisttwo%d%s\n\n", + ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER); + nheads++; + } - if (a_list) + fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */ + fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */ + fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */ + fprintf (filvar, "\t%s\t0\n", ASM_LONG); + fprintf (filvar, "\t%s\t0\n", ASM_LONG); + + fprintf (filvar, "\n\t.section\t.idata$4\n"); + headindex = 0; + for (headptr = import_list; headptr != NULL; headptr = headptr->next) { - fprintf (f, "\t.section .drectve\n"); - for (dl = a_list; dl; dl = dl->next) + fprintf (filvar, "listone%d:\n", headindex); + for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ ) + fprintf (filvar, "\t%sfuncptr%d_%d%s\n", + ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER); + fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */ + headindex++; + } + + fprintf (filvar, "\n\t.section\t.idata$5\n"); + headindex = 0; + for (headptr = import_list; headptr != NULL; headptr = headptr->next) + { + fprintf (filvar, "listtwo%d:\n", headindex); + for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ ) + fprintf (filvar, "\t%sfuncptr%d_%d%s\n", + ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER); + fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */ + headindex++; + } + + fprintf (filvar, "\n\t.section\t.idata$6\n"); + headindex = 0; + for (headptr = import_list; headptr != NULL; headptr = headptr->next) + { + funcindex = 0; + for (funcptr = headptr->funchead; funcptr != NULL; + funcptr = funcptr->next) { - fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text); + fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex); + fprintf (filvar,"\t%s\t%d\n", ASM_SHORT, + ((funcptr->ord) & 0xFFFF)); + fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name); + fprintf (filvar,"\t%s\t0\n", ASM_BYTE); + funcindex++; } + headindex++; } - if (d_list) + + fprintf (filvar, "\n\t.section\t.idata$7\n"); + headindex = 0; + for (headptr = import_list; headptr != NULL; headptr = headptr->next) { - fprintf (f, "\t.section .rdata\n"); - for (dl = d_list; dl; dl = dl->next) - { - char *p; - int l; - /* We dont output as ascii 'cause there can - be quote characters in the string */ + fprintf (filvar,"dllname%d:\n", headindex); + fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname); + fprintf (filvar,"\t%s\t0\n", ASM_BYTE); + headindex++; + } +} - l = 0; - for (p = dl->text; *p; p++) +/* Assemble the specified file. */ +static void +assemble_file (const char * source, const char * dest) +{ + char * cmd; + + cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags) + + strlen (source) + strlen (dest) + 50); + + sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source); + + run (as_name, cmd); +} + +static void +gen_exp_file (void) +{ + FILE *f; + int i; + export_type *exp; + dlist_type *dl; + + /* xgettext:c-format */ + inform (_("Generating export file: %s"), exp_name); + + f = fopen (TMP_ASM, FOPEN_WT); + if (!f) + /* xgettext:c-format */ + fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM); + + /* xgettext:c-format */ + inform (_("Opened temporary file: %s"), TMP_ASM); + + dump_def_info (f); + + if (d_exports) + { + fprintf (f, "\t.section .edata\n\n"); + fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C); + fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, (long) time(0), + ASM_C); + fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C); + fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); + fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C); + + + fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C); + fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n", + ASM_C, + d_named_nfuncs, d_low_ord, d_high_ord); + fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG, + show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C); + fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); + + fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n", + ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); + + fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); + + fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name); + + + fprintf(f,"%s Export address Table\n", ASM_C); + fprintf(f,"\t%s\n", ASM_ALIGN_LONG); + fprintf (f, "afuncs:\n"); + i = d_low_ord; + + for (exp = d_exports; exp; exp = exp->next) + { + if (exp->ordinal != i) { - if (l == 0) - fprintf (f, "\t%s\t", ASM_BYTE); - else - fprintf (f, ","); - fprintf (f, "%d", *p); - if (p[1] == 0) +#if 0 + fprintf (f, "\t%s\t%d\t%s %d..%d missing\n", + ASM_SPACE, + (exp->ordinal - i) * 4, + ASM_C, + i, exp->ordinal - 1); + i = exp->ordinal; +#endif + while (i < exp->ordinal) { - fprintf (f, ",0\n"); - break; + fprintf(f,"\t%s\t0\n", ASM_LONG); + i++; } - if (++l == 10) + } + + if (exp->forward == 0) + { + if (exp->internal_name[0] == '@') + fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE, + exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal); + else + fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE, + ASM_PREFIX (exp->internal_name), + exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal); + } + else + fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE, + exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal); + i++; + } + + fprintf (f,"%s Export Name Pointer Table\n", ASM_C); + fprintf (f, "anames:\n"); + + for (i = 0; (exp = d_exports_lexically[i]); i++) + { + if (!exp->noname || show_allnames) + fprintf (f, "\t%sn%d%s\n", + ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER); + } + + fprintf (f,"%s Export Oridinal Table\n", ASM_C); + fprintf (f, "anords:\n"); + for (i = 0; (exp = d_exports_lexically[i]); i++) + { + if (!exp->noname || show_allnames) + fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord); + } + + fprintf(f,"%s Export Name Table\n", ASM_C); + for (i = 0; (exp = d_exports_lexically[i]); i++) + { + if (!exp->noname || show_allnames) + fprintf (f, "n%d: %s \"%s\"\n", + exp->ordinal, ASM_TEXT, xlate (exp->name)); + if (exp->forward != 0) + fprintf (f, "f%d: %s \"%s\"\n", + exp->forward, ASM_TEXT, exp->internal_name); + } + + if (a_list) + { + fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME); + for (dl = a_list; dl; dl = dl->next) + { + fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text); + } + } + + if (d_list) + { + fprintf (f, "\t.section .rdata\n"); + for (dl = d_list; dl; dl = dl->next) + { + char *p; + int l; + + /* We don't output as ascii because there can + be quote characters in the string. */ + l = 0; + for (p = dl->text; *p; p++) { - fprintf (f, "\n"); - l = 0; + if (l == 0) + fprintf (f, "\t%s\t", ASM_BYTE); + else + fprintf (f, ","); + fprintf (f, "%d", *p); + if (p[1] == 0) + { + fprintf (f, ",0\n"); + break; + } + if (++l == 10) + { + fprintf (f, "\n"); + l = 0; + } } } } } - /* Dump the reloc section if a base file is provided */ + + /* Add to the output file a way of getting to the exported names + without using the import library. */ + if (add_indirect) + { + fprintf (f, "\t.section\t.rdata\n"); + for (i = 0, exp = d_exports; exp; i++, exp = exp->next) + if (!exp->noname || show_allnames) + { + /* We use a single underscore for MS compatibility, and a + double underscore for backward compatibility with old + cygwin releases. */ + if (create_compat_implib) + fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name); + fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name); + if (create_compat_implib) + fprintf (f, "__imp_%s:\n", exp->name); + fprintf (f, "_imp__%s:\n", exp->name); + fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name); + } + } + + /* Dump the reloc section if a base file is provided. */ if (base_file) { int addr; @@ -768,153 +1934,982 @@ gen_exp_file () long *copy; int j; int on_page; - fprintf (f, "\t.section\t.reloc\n"); + fprintf (f, "\t.section\t.init\n"); + fprintf (f, "lab:\n"); + fseek (base_file, 0, SEEK_END); numbytes = ftell (base_file); fseek (base_file, 0, SEEK_SET); - copy = malloc (numbytes); + copy = xmalloc (numbytes); fread (copy, 1, numbytes, base_file); num_entries = numbytes / sizeof (long); - qsort (copy, num_entries, sizeof (long), sfunc); - addr = copy[0]; - page_addr = addr & PAGE_MASK; /* work out the page addr */ - on_page = 0; - for (j = 0; j < num_entries; j++) + fprintf (f, "\t.section\t.reloc\n"); + if (num_entries) { - addr = copy[j]; - if ((addr & PAGE_MASK) != page_addr) + int src; + int dst = 0; + int last = -1; + qsort (copy, num_entries, sizeof (long), sfunc); + /* Delete duplicates */ + for (src = 0; src < num_entries; src++) { - flush_page (f, need, page_addr, on_page); - on_page = 0; - page_addr = addr & PAGE_MASK; + if (last != copy[src]) + last = copy[dst++] = copy[src]; } - need[on_page++] = addr; + num_entries = dst; + addr = copy[0]; + page_addr = addr & PAGE_MASK; /* work out the page addr */ + on_page = 0; + for (j = 0; j < num_entries; j++) + { + addr = copy[j]; + if ((addr & PAGE_MASK) != page_addr) + { + flush_page (f, need, page_addr, on_page); + on_page = 0; + page_addr = addr & PAGE_MASK; + } + need[on_page++] = addr; + } + flush_page (f, need, page_addr, on_page); + +/* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/ } - flush_page (f, need, page_addr, on_page); } + generate_idata_ofile (f); + fclose (f); + + /* Assemble the file. */ + assemble_file (TMP_ASM, exp_name); + + if (dontdeltemps == 0) + unlink (TMP_ASM); + + inform (_("Generated exports file")); } -static char * -xlate (char *name) +static const char * +xlate (const char *name) { + int lead_at = (*name == '@'); + + if (add_underscore && !lead_at) + { + char *copy = xmalloc (strlen (name) + 2); - if (!suckunderscore) - return name; + copy[0] = '_'; + strcpy (copy + 1, name); + name = copy; + } - if (name[0] == '_') - name++; - if (killat) { - char *p; - p = strchr (name, '@'); - if (p) - *p = 0; - } + if (killat) + { + char *p; + + name += lead_at; + p = strchr (name, '@'); + if (p) + *p = 0; + } return name; } -/**********************************************************************/ -gen_lib_file () +/**********************************************************************/ + +#if 0 + +static void +dump_iat (FILE *f, export_type *exp) +{ + if (exp->noname && !show_allnames ) + { + fprintf (f, "\t%s\t0x%08x\n", + ASM_LONG, + exp->ordinal | 0x80000000); /* hint or orindal ?? */ + } + else + { + fprintf (f, "\t%sID%d%s\n", ASM_RVA_BEFORE, + exp->ordinal, + ASM_RVA_AFTER); + } +} + +#endif + +typedef struct +{ + int id; + const char *name; + int flags; + int align; + asection *sec; + asymbol *sym; + asymbol **sympp; + int size; + unsigned char *data; +} sinfo; + +#ifndef DLLTOOL_PPC + +#define TEXT 0 +#define DATA 1 +#define BSS 2 +#define IDATA7 3 +#define IDATA5 4 +#define IDATA4 5 +#define IDATA6 6 + +#define NSECS 7 + +#define TEXT_SEC_FLAGS \ + (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS) +#define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA) +#define BSS_SEC_FLAGS SEC_ALLOC + +#define INIT_SEC_DATA(id, name, flags, align) \ + { id, name, flags, align, NULL, NULL, NULL, 0, NULL } +static sinfo secdata[NSECS] = +{ + INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2), + INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2), + INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2), + INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2), + INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2), + INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2), + INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1) +}; + +#else + +/* Sections numbered to make the order the same as other PowerPC NT + compilers. This also keeps funny alignment thingies from happening. */ +#define TEXT 0 +#define PDATA 1 +#define RDATA 2 +#define IDATA5 3 +#define IDATA4 4 +#define IDATA6 5 +#define IDATA7 6 +#define DATA 7 +#define BSS 8 + +#define NSECS 9 + +static sinfo secdata[NSECS] = +{ + { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3}, + { PDATA, ".pdata", SEC_HAS_CONTENTS, 2}, + { RDATA, ".reldata", SEC_HAS_CONTENTS, 2}, + { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2}, + { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2}, + { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1}, + { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2}, + { DATA, ".data", SEC_DATA, 2}, + { BSS, ".bss", 0, 2} +}; + +#endif + +/* This is what we're trying to make. We generate the imp symbols with + both single and double underscores, for compatibility. + + .text + .global _GetFileVersionInfoSizeW@8 + .global __imp_GetFileVersionInfoSizeW@8 +_GetFileVersionInfoSizeW@8: + jmp * __imp_GetFileVersionInfoSizeW@8 + .section .idata$7 # To force loading of head + .long __version_a_head +# Import Address Table + .section .idata$5 +__imp_GetFileVersionInfoSizeW@8: + .rva ID2 + +# Import Lookup Table + .section .idata$4 + .rva ID2 +# Hint/Name table + .section .idata$6 +ID2: .short 2 + .asciz "GetFileVersionInfoSizeW" + + + For the PowerPC, here's the variation on the above scheme: + +# Rather than a simple "jmp *", the code to get to the dll function +# looks like: + .text + lwz r11,[tocv]__imp_function_name(r2) +# RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name + lwz r12,0(r11) + stw r2,4(r1) + mtctr r12 + lwz r2,4(r11) + bctr */ + +static char * +make_label (const char *prefix, const char *name) +{ + int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name); + char *copy = xmalloc (len + 1); + + strcpy (copy, ASM_PREFIX (name)); + strcat (copy, prefix); + strcat (copy, name); + return copy; +} + +static char * +make_imp_label (const char *prefix, const char *name) +{ + int len; + char *copy; + + if (name[0] == '@') + { + len = strlen (prefix) + strlen (name); + copy = xmalloc (len + 1); + strcpy (copy, prefix); + strcat (copy, name); + } + else + { + len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name); + copy = xmalloc (len + 1); + strcpy (copy, prefix); + strcat (copy, ASM_PREFIX (name)); + strcat (copy, name); + } + return copy; +} + +static bfd * +make_one_lib_file (export_type *exp, int i) +{ +#if 0 + { + char *name; + FILE *f; + const char *prefix = "d"; + char *dest; + + name = (char *) alloca (strlen (prefix) + 10); + sprintf (name, "%ss%05d.s", prefix, i); + f = fopen (name, FOPEN_WT); + fprintf (f, "\t.text\n"); + fprintf (f, "\t%s\t%s%s\n", ASM_GLOBAL, ASM_PREFIX (exp->name), exp->name); + if (create_compat_implib) + fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name); + fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name); + if (create_compat_implib) + fprintf (f, "%s%s:\n\t%s\t__imp_%s\n", ASM_PREFIX (exp->name), + exp->name, ASM_JUMP, exp->name); + + fprintf (f, "\t.section\t.idata$7\t%s To force loading of head\n", ASM_C); + fprintf (f, "\t%s\t%s\n", ASM_LONG, head_label); + + + fprintf (f,"%s Import Address Table\n", ASM_C); + + fprintf (f, "\t.section .idata$5\n"); + if (create_compat_implib) + fprintf (f, "__imp_%s:\n", exp->name); + fprintf (f, "_imp__%s:\n", exp->name); + + dump_iat (f, exp); + + fprintf (f, "\n%s Import Lookup Table\n", ASM_C); + fprintf (f, "\t.section .idata$4\n"); + + dump_iat (f, exp); + + if(!exp->noname || show_allnames) + { + fprintf (f, "%s Hint/Name table\n", ASM_C); + fprintf (f, "\t.section .idata$6\n"); + fprintf (f, "ID%d:\t%s\t%d\n", exp->ordinal, ASM_SHORT, exp->hint); + fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, xlate (exp->name)); + } + + fclose (f); + + dest = (char *) alloca (strlen (prefix) + 10); + sprintf (dest, "%ss%05d.o", prefix, i); + assemble_file (name, dest); + } +#else /* if 0 */ + { + bfd * abfd; + asymbol * exp_label; + asymbol * iname = 0; + asymbol * iname2; + asymbol * iname2_pre = 0; + asymbol * iname_lab; + asymbol ** iname_lab_pp; + asymbol ** iname_pp; +#ifdef DLLTOOL_PPC + asymbol ** fn_pp; + asymbol ** toc_pp; +#define EXTRA 2 +#endif +#ifndef EXTRA +#define EXTRA 0 +#endif + asymbol * ptrs[NSECS + 4 + EXTRA + 1]; + flagword applicable; + char * outname = xmalloc (strlen (TMP_STUB) + 10); + int oidx = 0; + + + sprintf (outname, "%s%05d.o", TMP_STUB, i); + + abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET); + + if (!abfd) + /* xgettext:c-format */ + fatal (_("bfd_open failed open stub file: %s"), outname); + + /* xgettext:c-format */ + inform (_("Creating stub file: %s"), outname); + + bfd_set_format (abfd, bfd_object); + bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0); + +#ifdef DLLTOOL_ARM + if (machine == MARM_INTERWORK || machine == MTHUMB) + bfd_set_private_flags (abfd, F_INTERWORK); +#endif + + applicable = bfd_applicable_section_flags (abfd); + + /* First make symbols for the sections. */ + for (i = 0; i < NSECS; i++) + { + sinfo *si = secdata + i; + + if (si->id != i) + abort(); + si->sec = bfd_make_section_old_way (abfd, si->name); + bfd_set_section_flags (abfd, + si->sec, + si->flags & applicable); + + bfd_set_section_alignment(abfd, si->sec, si->align); + si->sec->output_section = si->sec; + si->sym = bfd_make_empty_symbol(abfd); + si->sym->name = si->sec->name; + si->sym->section = si->sec; + si->sym->flags = BSF_LOCAL; + si->sym->value = 0; + ptrs[oidx] = si->sym; + si->sympp = ptrs + oidx; + si->size = 0; + si->data = NULL; + + oidx++; + } + + if (! exp->data) + { + exp_label = bfd_make_empty_symbol (abfd); + exp_label->name = make_imp_label ("", exp->name); + + /* On PowerPC, the function name points to a descriptor in + the rdata section, the first element of which is a + pointer to the code (..function_name), and the second + points to the .toc. */ +#ifdef DLLTOOL_PPC + if (machine == MPPC) + exp_label->section = secdata[RDATA].sec; + else +#endif + exp_label->section = secdata[TEXT].sec; + + exp_label->flags = BSF_GLOBAL; + exp_label->value = 0; + +#ifdef DLLTOOL_ARM + if (machine == MTHUMB) + bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC); +#endif + ptrs[oidx++] = exp_label; + + if (ext_prefix_alias) + { + asymbol * exp_label_pre; + + exp_label_pre = bfd_make_empty_symbol (abfd); + exp_label_pre->name + = make_imp_label (ext_prefix_alias, exp->name); + exp_label_pre->section = exp_label->section; + exp_label_pre->flags = exp_label->flags; + exp_label_pre->value = exp_label->value; +#ifdef DLLTOOL_ARM + if (machine == MTHUMB) + bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC); +#endif + ptrs[oidx++] = exp_label_pre; + } + } + + /* Generate imp symbols with one underscore for Microsoft + compatibility, and with two underscores for backward + compatibility with old versions of cygwin. */ + if (create_compat_implib) + { + iname = bfd_make_empty_symbol (abfd); + iname->name = make_imp_label ("___imp", exp->name); + iname->section = secdata[IDATA5].sec; + iname->flags = BSF_GLOBAL; + iname->value = 0; + } + + iname2 = bfd_make_empty_symbol (abfd); + iname2->name = make_imp_label ("__imp_", exp->name); + iname2->section = secdata[IDATA5].sec; + iname2->flags = BSF_GLOBAL; + iname2->value = 0; + + if (ext_prefix_alias) + { + char *pre_name; + + iname2_pre = bfd_make_empty_symbol (abfd); + pre_name = xmalloc (strlen (ext_prefix_alias) + 7); + sprintf(pre_name, "__imp_%s", ext_prefix_alias); + iname2_pre->name = make_imp_label (pre_name, exp->name); + iname2_pre->section = iname2->section; + iname2_pre->flags = iname2->flags; + iname2_pre->value = iname2->value; + } + + iname_lab = bfd_make_empty_symbol (abfd); + + iname_lab->name = head_label; + iname_lab->section = (asection *) &bfd_und_section; + iname_lab->flags = 0; + iname_lab->value = 0; + + iname_pp = ptrs + oidx; + if (create_compat_implib) + ptrs[oidx++] = iname; + ptrs[oidx++] = iname2; + if (ext_prefix_alias) + ptrs[oidx++] = iname2_pre; + + iname_lab_pp = ptrs + oidx; + ptrs[oidx++] = iname_lab; + +#ifdef DLLTOOL_PPC + /* The symbol referring to the code (.text). */ + { + asymbol *function_name; + + function_name = bfd_make_empty_symbol(abfd); + function_name->name = make_label ("..", exp->name); + function_name->section = secdata[TEXT].sec; + function_name->flags = BSF_GLOBAL; + function_name->value = 0; + + fn_pp = ptrs + oidx; + ptrs[oidx++] = function_name; + } + + /* The .toc symbol. */ + { + asymbol *toc_symbol; + + toc_symbol = bfd_make_empty_symbol (abfd); + toc_symbol->name = make_label (".", "toc"); + toc_symbol->section = (asection *)&bfd_und_section; + toc_symbol->flags = BSF_GLOBAL; + toc_symbol->value = 0; + + toc_pp = ptrs + oidx; + ptrs[oidx++] = toc_symbol; + } +#endif + + ptrs[oidx] = 0; + + for (i = 0; i < NSECS; i++) + { + sinfo *si = secdata + i; + asection *sec = si->sec; + arelent *rel; + arelent **rpp; + + switch (i) + { + case TEXT: + if (! exp->data) + { + si->size = HOW_JTAB_SIZE; + si->data = xmalloc (HOW_JTAB_SIZE); + memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE); + + /* add the reloc into idata$5 */ + rel = xmalloc (sizeof (arelent)); + + rpp = xmalloc (sizeof (arelent *) * 2); + rpp[0] = rel; + rpp[1] = 0; + + rel->address = HOW_JTAB_ROFF; + rel->addend = 0; + + if (machine == MPPC) + { + rel->howto = bfd_reloc_type_lookup (abfd, + BFD_RELOC_16_GOTOFF); + rel->sym_ptr_ptr = iname_pp; + } + else + { + rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); + rel->sym_ptr_ptr = secdata[IDATA5].sympp; + } + sec->orelocation = rpp; + sec->reloc_count = 1; + } + break; + case IDATA4: + case IDATA5: + /* An idata$4 or idata$5 is one word long, and has an + rva to idata$6. */ + + si->data = xmalloc (4); + si->size = 4; + + if (exp->noname) + { + si->data[0] = exp->ordinal ; + si->data[1] = exp->ordinal >> 8; + si->data[2] = exp->ordinal >> 16; + si->data[3] = 0x80; + } + else + { + sec->reloc_count = 1; + memset (si->data, 0, si->size); + rel = xmalloc (sizeof (arelent)); + rpp = xmalloc (sizeof (arelent *) * 2); + rpp[0] = rel; + rpp[1] = 0; + rel->address = 0; + rel->addend = 0; + rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA); + rel->sym_ptr_ptr = secdata[IDATA6].sympp; + sec->orelocation = rpp; + } + + break; + + case IDATA6: + if (!exp->noname) + { + /* This used to add 1 to exp->hint. I don't know + why it did that, and it does not match what I see + in programs compiled with the MS tools. */ + int idx = exp->hint; + /* If the user has specified an internal name, use it. + Ignore command line name translation options. */ + char const * internal_name + = exp->internal_name != exp->name + ? exp->internal_name : xlate (exp->name); + + si->size = strlen (internal_name) + 3; + si->data = xmalloc (si->size); + si->data[0] = idx & 0xff; + si->data[1] = idx >> 8; + strcpy (si->data + 2, internal_name); + } + break; + case IDATA7: + si->size = 4; + si->data = xmalloc (4); + memset (si->data, 0, si->size); + rel = xmalloc (sizeof (arelent)); + rpp = xmalloc (sizeof (arelent *) * 2); + rpp[0] = rel; + rel->address = 0; + rel->addend = 0; + rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA); + rel->sym_ptr_ptr = iname_lab_pp; + sec->orelocation = rpp; + sec->reloc_count = 1; + break; + +#ifdef DLLTOOL_PPC + case PDATA: + { + /* The .pdata section is 5 words long. + Think of it as: + struct + { + bfd_vma BeginAddress, [0x00] + EndAddress, [0x04] + ExceptionHandler, [0x08] + HandlerData, [0x0c] + PrologEndAddress; [0x10] + }; */ + + /* So this pdata section setups up this as a glue linkage to + a dll routine. There are a number of house keeping things + we need to do: + + 1. In the name of glue trickery, the ADDR32 relocs for 0, + 4, and 0x10 are set to point to the same place: + "..function_name". + 2. There is one more reloc needed in the pdata section. + The actual glue instruction to restore the toc on + return is saved as the offset in an IMGLUE reloc. + So we need a total of four relocs for this section. + + 3. Lastly, the HandlerData field is set to 0x03, to indicate + that this is a glue routine. */ + arelent *imglue, *ba_rel, *ea_rel, *pea_rel; + + /* Alignment must be set to 2**2 or you get extra stuff. */ + bfd_set_section_alignment(abfd, sec, 2); + + si->size = 4 * 5; + si->data = xmalloc (si->size); + memset (si->data, 0, si->size); + rpp = xmalloc (sizeof (arelent *) * 5); + rpp[0] = imglue = xmalloc (sizeof (arelent)); + rpp[1] = ba_rel = xmalloc (sizeof (arelent)); + rpp[2] = ea_rel = xmalloc (sizeof (arelent)); + rpp[3] = pea_rel = xmalloc (sizeof (arelent)); + rpp[4] = 0; + + /* Stick the toc reload instruction in the glue reloc. */ + bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address); + + imglue->addend = 0; + imglue->howto = bfd_reloc_type_lookup (abfd, + BFD_RELOC_32_GOTOFF); + imglue->sym_ptr_ptr = fn_pp; + + ba_rel->address = 0; + ba_rel->addend = 0; + ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); + ba_rel->sym_ptr_ptr = fn_pp; + + bfd_put_32 (abfd, 0x18, si->data + 0x04); + ea_rel->address = 4; + ea_rel->addend = 0; + ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); + ea_rel->sym_ptr_ptr = fn_pp; + + /* Mark it as glue. */ + bfd_put_32 (abfd, 0x03, si->data + 0x0c); + + /* Mark the prolog end address. */ + bfd_put_32 (abfd, 0x0D, si->data + 0x10); + pea_rel->address = 0x10; + pea_rel->addend = 0; + pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); + pea_rel->sym_ptr_ptr = fn_pp; + + sec->orelocation = rpp; + sec->reloc_count = 4; + break; + } + case RDATA: + /* Each external function in a PowerPC PE file has a two word + descriptor consisting of: + 1. The address of the code. + 2. The address of the appropriate .toc + We use relocs to build this. */ + si->size = 8; + si->data = xmalloc (8); + memset (si->data, 0, si->size); + + rpp = xmalloc (sizeof (arelent *) * 3); + rpp[0] = rel = xmalloc (sizeof (arelent)); + rpp[1] = xmalloc (sizeof (arelent)); + rpp[2] = 0; + + rel->address = 0; + rel->addend = 0; + rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); + rel->sym_ptr_ptr = fn_pp; + + rel = rpp[1]; + + rel->address = 4; + rel->addend = 0; + rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); + rel->sym_ptr_ptr = toc_pp; + + sec->orelocation = rpp; + sec->reloc_count = 2; + break; +#endif /* DLLTOOL_PPC */ + } + } + + { + bfd_vma vma = 0; + /* Size up all the sections. */ + for (i = 0; i < NSECS; i++) + { + sinfo *si = secdata + i; + + bfd_set_section_size (abfd, si->sec, si->size); + bfd_set_section_vma (abfd, si->sec, vma); + +/* vma += si->size;*/ + } + } + /* Write them out. */ + for (i = 0; i < NSECS; i++) + { + sinfo *si = secdata + i; + + if (i == IDATA5 && no_idata5) + continue; + + if (i == IDATA4 && no_idata4) + continue; + + bfd_set_section_contents (abfd, si->sec, + si->data, 0, + si->size); + } + + bfd_set_symtab (abfd, ptrs, oidx); + bfd_close (abfd); + abfd = bfd_openr (outname, HOW_BFD_READ_TARGET); + return abfd; + } +#endif +} + +static bfd * +make_head (void) +{ + FILE *f = fopen (TMP_HEAD_S, FOPEN_WT); + + if (f == NULL) + { + fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S); + return NULL; + } + + fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C); + fprintf (f, "\t.section .idata$2\n"); + + fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label); + + fprintf (f, "%s:\n", head_label); + + fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n", + ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); + + fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C); + fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C); + fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C); + fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C); + fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n", + ASM_RVA_BEFORE, + imp_name_lab, + ASM_RVA_AFTER, + ASM_C); + fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n", + ASM_RVA_BEFORE, + ASM_RVA_AFTER, ASM_C); + + fprintf (f, "%sStuff for compatibility\n", ASM_C); + + if (!no_idata5) + { + fprintf (f, "\t.section\t.idata$5\n"); + fprintf (f, "\t%s\t0\n", ASM_LONG); + fprintf (f, "fthunk:\n"); + } + + if (!no_idata4) + { + fprintf (f, "\t.section\t.idata$4\n"); + + fprintf (f, "\t%s\t0\n", ASM_LONG); + fprintf (f, "\t.section .idata$4\n"); + fprintf (f, "hname:\n"); + } + + fclose (f); + + assemble_file (TMP_HEAD_S, TMP_HEAD_O); + + return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET); +} + +static bfd * +make_tail (void) { - int i; - FILE *f; - export_type *exp; + FILE *f = fopen (TMP_TAIL_S, FOPEN_WT); - sprintf (outfile, "%s-lib.s", outfile_prefix); - - f = fopen (outfile, "w"); - if (!f) + if (f == NULL) { - fprintf (stderr, "Unable to open output file %s\n", outfile); - exit (1); + fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S); + return NULL; } - - dump_def_info (f); - fprintf (f, "\t.text\n"); - fprintf (f, "%s Thunk table\n", ASM_C); - for (i = 0, exp = d_exports; exp; i++, exp = exp->next) + if (!no_idata4) { - fprintf (f, "\t%s\t%s\n", ASM_GLOBAL, exp->name); - fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name); + fprintf (f, "\t.section .idata$4\n"); + fprintf (f, "\t%s\t0\n", ASM_LONG); } - for (i = 0, exp = d_exports; exp; i++, exp = exp->next) + if (!no_idata5) { - fprintf (f, "%s:\t%s\t__imp_%s\n", exp->name, ASM_JUMP, exp->name); + fprintf (f, "\t.section .idata$5\n"); + fprintf (f, "\t%s\t0\n", ASM_LONG); } +#ifdef DLLTOOL_PPC + /* Normally, we need to see a null descriptor built in idata$3 to + act as the terminator for the list. The ideal way, I suppose, + would be to mark this section as a comdat type 2 section, so + only one would appear in the final .exe (if our linker supported + comdat, that is) or cause it to be inserted by something else (say + crt0). */ - fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C); - fprintf (f, "\t.section .idata$2\n"); - fprintf (f, "\t%s\thname\t%s Ptr to image import by name list\n", ASM_LONG, ASM_C); - fprintf (f, "\t%s\t%d\t%s time\n", ASM_LONG, time (0), ASM_C); - fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C); - fprintf (f, "\t%s\tiname\t%s imported dll's name\n", ASM_LONG, ASM_C); - fprintf (f, "\t%s\tfthunk\t%s pointer to firstthunk\n", ASM_LONG, ASM_C); - - fprintf (f, "%sStuff for compatibility\n", ASM_C); - fprintf (f, "\t.section\t.idata$3\n"); - fprintf (f, "\t%s\t0\n", ASM_LONG); + fprintf (f, "\t.section .idata$3\n"); fprintf (f, "\t%s\t0\n", ASM_LONG); fprintf (f, "\t%s\t0\n", ASM_LONG); fprintf (f, "\t%s\t0\n", ASM_LONG); fprintf (f, "\t%s\t0\n", ASM_LONG); - fprintf (f, "\t.section\t.idata$5\n"); fprintf (f, "\t%s\t0\n", ASM_LONG); +#endif - fprintf (f, "\t.section\t.idata$4\n"); - fprintf (f, "\t%s\t0\n", ASM_LONG); +#ifdef DLLTOOL_PPC + /* Other PowerPC NT compilers use idata$6 for the dllname, so I + do too. Original, huh? */ + fprintf (f, "\t.section .idata$6\n"); +#else + fprintf (f, "\t.section .idata$7\n"); +#endif - fprintf (f, "\n%s Loader modifies this\n", ASM_C); - fprintf (f, "\t.section .idata$5\n"); - fprintf (f, "fthunk:\n"); - for (i = 0, exp = d_exports; exp; i++, exp = exp->next) + fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab); + fprintf (f, "__%s_iname:\t%s\t\"%s\"\n", + imp_name_lab, ASM_TEXT, dll_name); + + fclose (f); + + assemble_file (TMP_TAIL_S, TMP_TAIL_O); + + return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET); +} + +static void +gen_lib_file (void) +{ + int i; + export_type *exp; + bfd *ar_head; + bfd *ar_tail; + bfd *outarch; + bfd * head = 0; + + unlink (imp_name); + + outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET); + + if (!outarch) + /* xgettext:c-format */ + fatal (_("Can't open .lib file: %s"), imp_name); + + /* xgettext:c-format */ + inform (_("Creating library file: %s"), imp_name); + + 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 (); + ar_tail = make_tail(); + + if (ar_head == NULL || ar_tail == NULL) + return; + + for (i = 0; (exp = d_exports_lexically[i]); i++) { - fprintf (f, "__imp_%s:\n", exp->name); - fprintf (f, "\t%s\tID%d\n", ASM_LONG, i); + bfd *n; + /* Don't add PRIVATE entries to import lib. */ + if (exp->private) + continue; + n = make_one_lib_file (exp, i); + n->next = head; + head = n; } - fprintf (f, "\t%s\t0\n", ASM_LONG); - fprintf (f, "\n%s Hint name array\n", ASM_C); - fprintf (f, "\t.section .idata$4\n"); - fprintf (f, "hname:\n"); - for (i = 0, exp = d_exports; exp; i++, exp = exp->next) + /* 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)) + bfd_fatal ("bfd_set_archive_head"); + + if (! bfd_close (outarch)) + bfd_fatal (imp_name); + + while (head != NULL) { - fprintf (f, "\t%s\tID%d\n", ASM_LONG, i); + bfd *n = head->next; + bfd_close (head); + head = n; } - fprintf (f, "\t%s\t0\n", ASM_LONG); - fprintf (f, "%s Hint/name array storage and import dll name\n", ASM_C); - fprintf (f, "\t.section .idata$6\n"); + /* Delete all the temp files. */ + if (dontdeltemps == 0) + { + unlink (TMP_HEAD_O); + unlink (TMP_HEAD_S); + unlink (TMP_TAIL_O); + unlink (TMP_TAIL_S); + } - for (i = 0, exp = d_exports; exp; i++, exp = exp->next) + if (dontdeltemps < 2) { - fprintf (f, "ID%d:\t%s\t%d\n", i, ASM_SHORT, exp->ordinal); - fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, xlate (exp->name)); + char *name; + + name = (char *) alloca (strlen (TMP_STUB) + 10); + for (i = 0; (exp = d_exports_lexically[i]); i++) + { + /* Don't delete non-existent stubs for PRIVATE entries. */ + if (exp->private) + continue; + sprintf (name, "%s%05d.o", TMP_STUB, i); + if (unlink (name) < 0) + /* xgettext:c-format */ + non_fatal (_("cannot delete %s: %s"), name, strerror (errno)); + } } - fprintf (f, "\t%s\t0\n", ASM_LONG); - fprintf (f, "iname:\t%s\t\"%s.%s\"\n", ASM_TEXT, outfile_prefix, d_suffix); - fclose (f); + + inform (_("Created lib file")); } -/**********************************************************************/ /* Run through the information gathered from the .o files and the - .def file and work out the best stuff */ -int -pfunc (a, b) - void *a; - void *b; + .def file and work out the best stuff. */ + +static int +pfunc (const void *a, const void *b) { export_type *ap = *(export_type **) a; export_type *bp = *(export_type **) b; if (ap->ordinal == bp->ordinal) return 0; - /* unset ordinals go to the bottom */ + /* Unset ordinals go to the bottom. */ if (ap->ordinal == -1) return 1; if (bp->ordinal == -1) @@ -922,11 +2917,8 @@ pfunc (a, b) return (ap->ordinal - bp->ordinal); } - -int -nfunc (a, b) - void *a; - void *b; +static int +nfunc (const void *a, const void *b) { export_type *ap = *(export_type **) a; export_type *bp = *(export_type **) b; @@ -934,13 +2926,12 @@ nfunc (a, b) return (strcmp (ap->name, bp->name)); } -static -void -remove_null_names (ptr) - export_type **ptr; +static void +remove_null_names (export_type **ptr) { int src; int dst; + for (dst = src = 0; src < d_nfuncs; src++) { if (ptr[src]) @@ -953,8 +2944,7 @@ remove_null_names (ptr) } static void -dtab (ptr) - export_type **ptr; +dtab (export_type **ptr ATTRIBUTE_UNUSED) { #ifdef SACDEBUG int i; @@ -962,10 +2952,11 @@ dtab (ptr) { if (ptr[i]) { - printf ("%d %s @ %d %s%s\n", + printf ("%d %s @ %d %s%s%s\n", i, ptr[i]->name, ptr[i]->ordinal, ptr[i]->noname ? "NONAME " : "", - ptr[i]->constant ? "CONSTANT" : ""); + ptr[i]->constant ? "CONSTANT" : "", + ptr[i]->data ? "DATA" : ""); } else printf ("empty\n"); @@ -974,15 +2965,15 @@ dtab (ptr) } static void -process_duplicates (d_export_vec) - export_type **d_export_vec; +process_duplicates (export_type **d_export_vec) { int more = 1; + int i; while (more) { more = 0; - /* Remove duplicates */ + /* Remove duplicates. */ qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc); dtab (d_export_vec); @@ -991,28 +2982,26 @@ process_duplicates (d_export_vec) if (strcmp (d_export_vec[i]->name, d_export_vec[i + 1]->name) == 0) { - export_type *a = d_export_vec[i]; export_type *b = d_export_vec[i + 1]; more = 1; - if (verbose) - fprintf (stderr, "Warning, ignoring duplicate EXPORT %s %d,%d\n", - a->name, - a->ordinal, - b->ordinal); + + /* xgettext:c-format */ + inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"), + a->name, a->ordinal, b->ordinal); + if (a->ordinal != -1 && b->ordinal != -1) - { + /* xgettext:c-format */ + fatal (_("Error, duplicate EXPORT with oridinals: %s"), + a->name); - fprintf (stderr, "Error, duplicate EXPORT with oridinals %s\n", - a->name); - exit (1); - } - /* Merge attributes */ + /* Merge attributes. */ b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal; b->constant |= a->constant; b->noname |= a->noname; + b->data |= a->data; d_export_vec[i] = 0; } @@ -1021,40 +3010,53 @@ process_duplicates (d_export_vec) dtab (d_export_vec); } } + + /* Count the names. */ + for (i = 0; i < d_nfuncs; i++) + if (!d_export_vec[i]->noname) + d_named_nfuncs++; } static void -fill_ordinals (d_export_vec) - export_type **d_export_vec; +fill_ordinals (export_type **d_export_vec) { - int lowest = 0; - int unset = 0; + int lowest = -1; + int i; char *ptr; - qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc); + int size = 65536; - /* fill in the unset ordinals with ones from our range */ + qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc); - ptr = (char *) malloc (65536); + /* Fill in the unset ordinals with ones from our range. */ + ptr = (char *) xmalloc (size); - memset (ptr, 65536, 0); + memset (ptr, 0, size); - /* Mark in our large vector all the numbers that are taken */ + /* Mark in our large vector all the numbers that are taken. */ for (i = 0; i < d_nfuncs; i++) { if (d_export_vec[i]->ordinal != -1) { ptr[d_export_vec[i]->ordinal] = 1; - if (lowest == 0) + + if (lowest == -1 || d_export_vec[i]->ordinal < lowest) lowest = d_export_vec[i]->ordinal; } } + /* Start at 1 for compatibility with MS toolchain. */ + if (lowest == -1) + lowest = 1; + + /* Now fill in ordinals where the user wants us to choose. */ for (i = 0; i < d_nfuncs; i++) { if (d_export_vec[i]->ordinal == -1) { int j; - for (j = lowest; j < 65536; j++) + + /* First try within or after any user supplied range. */ + for (j = lowest; j < size; j++) if (ptr[j] == 0) { ptr[j] = 1; @@ -1062,7 +3064,8 @@ fill_ordinals (d_export_vec) goto done; } - for (j = 1; j < lowest; j++) + /* Then try before the range. */ + for (j = lowest; j >0; j--) if (ptr[j] == 0) { ptr[j] = 1; @@ -1070,154 +3073,329 @@ fill_ordinals (d_export_vec) goto done; } done:; - } } free (ptr); - /* And resort */ - + /* And resort. */ qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc); - /* Work out the lowest ordinal number */ - if (d_export_vec[0]) - d_ord = d_export_vec[0]->ordinal; + /* Work out the lowest and highest ordinal numbers. */ + if (d_nfuncs) + { + if (d_export_vec[0]) + d_low_ord = d_export_vec[0]->ordinal; + if (d_export_vec[d_nfuncs-1]) + d_high_ord = d_export_vec[d_nfuncs-1]->ordinal; + } } -void -mangle_defs () + +static int +alphafunc (const void *av, const void *bv) { - /* First work out the minimum ordinal chosen */ + const export_type **a = (const export_type **) av; + const export_type **b = (const export_type **) bv; + + return strcmp ((*a)->name, (*b)->name); +} +static void +mangle_defs (void) +{ + /* First work out the minimum ordinal chosen. */ export_type *exp; - int lowest = 0; + int i; - export_type **d_export_vec - = (export_type **) xmalloc (sizeof (export_type *) * d_nfuncs); + int hint = 0; + export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs); + + inform (_("Processing definitions")); for (i = 0, exp = d_exports; exp; i++, exp = exp->next) - { - d_export_vec[i] = exp; - } + d_export_vec[i] = exp; process_duplicates (d_export_vec); fill_ordinals (d_export_vec); - /* Put back the list in the new order */ + /* Put back the list in the new order. */ d_exports = 0; for (i = d_nfuncs - 1; i >= 0; i--) { d_export_vec[i]->next = d_exports; d_exports = d_export_vec[i]; } -} + /* Build list in alpha order. */ + d_exports_lexically = (export_type **) + xmalloc (sizeof (export_type *) * (d_nfuncs + 1)); -/**********************************************************************/ + for (i = 0, exp = d_exports; exp; i++, exp = exp->next) + d_exports_lexically[i] = exp; -void -usage (file, status) - FILE *file; - int status; -{ - fprintf (file, "Usage %s \n", program_name); - fprintf (file, "\t -m Generate code for \n"); - fprintf (file, "\t --machine \n"); - fprintf (file, "\t -o Set output prefix\n"); - fprintf (file, "\t -d Name input .def file\n"); - fprintf (file, "\t --def \n"); - fprintf (file, "\t --base-file Read linker generated base file\n"); - fprintf (file, "\t -b \n"); - fprintf (file, "\t -v Verbose\n"); - fprintf (file, "\t -u Remove leading underscore from .lib\n"); - fprintf (file, "\t -k Kill @ from exported names\n"); + d_exports_lexically[i] = 0; + + qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc); + + /* Fill exp entries with their hint values. */ + for (i = 0; i < d_nfuncs; i++) + if (!d_exports_lexically[i]->noname || show_allnames) + d_exports_lexically[i]->hint = hint++; + + inform (_("Processed definitions")); +} + +static void +usage (FILE *file, int status) +{ + /* xgetext:c-format */ + fprintf (file, _("Usage %s \n"), program_name); + /* xgetext:c-format */ + fprintf (file, _(" -m --machine Create as DLL for . [default: %s]\n"), mname); + fprintf (file, _(" possible : arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n")); + fprintf (file, _(" -e --output-exp Generate an export file.\n")); + fprintf (file, _(" -l --output-lib Generate an interface library.\n")); + fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n")); + fprintf (file, _(" -D --dllname Name of input dll to put into interface lib.\n")); + fprintf (file, _(" -d --input-def Name of .def file to be read in.\n")); + fprintf (file, _(" -z --output-def Name of .def file to be created.\n")); + fprintf (file, _(" --export-all-symbols Export all symbols to .def\n")); + fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n")); + fprintf (file, _(" --exclude-symbols Don't export \n")); + fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n")); + fprintf (file, _(" -b --base-file Read linker generated base file.\n")); + fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n")); + fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n")); + fprintf (file, _(" -U --add-underscore Add underscores to symbols in interface library.\n")); + fprintf (file, _(" -k --kill-at Kill @ from exported names.\n")); + fprintf (file, _(" -A --add-stdcall-alias Add aliases without @.\n")); + fprintf (file, _(" -p --ext-prefix-alias Add aliases with .\n")); + fprintf (file, _(" -S --as Use for assembler.\n")); + fprintf (file, _(" -f --as-flags Pass to the assembler.\n")); + fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n")); + fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n")); + fprintf (file, _(" -t --temp-prefix Use to construct temp file names.\n")); + fprintf (file, _(" -v --verbose Be verbose.\n")); + fprintf (file, _(" -V --version Display the program version.\n")); + fprintf (file, _(" -h --help Display this information.\n")); +#ifdef DLLTOOL_MCORE_ELF + fprintf (file, _(" -M --mcore-elf Process mcore-elf object files into .\n")); + fprintf (file, _(" -L --linker Use as the linker.\n")); + fprintf (file, _(" -F --linker-flags Pass to the linker.\n")); +#endif exit (status); } -static struct option long_options[] = +#define OPTION_EXPORT_ALL_SYMS 150 +#define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1) +#define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1) +#define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1) + +static const struct option long_options[] = { - {"def", required_argument, NULL, 'd'}, - {"underscore", no_argument, NULL, 'u'}, - {"killat", no_argument, NULL, 'k'}, + {"no-delete", no_argument, NULL, 'n'}, + {"dllname", required_argument, NULL, 'D'}, + {"no-idata4", no_argument, NULL, 'x'}, + {"no-idata5", no_argument, NULL, 'c'}, + {"output-exp", required_argument, NULL, 'e'}, + {"output-def", required_argument, NULL, 'z'}, + {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS}, + {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS}, + {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS}, + {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES}, + {"output-lib", required_argument, NULL, 'l'}, + {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */ + {"input-def", required_argument, NULL, 'd'}, + {"add-underscore", no_argument, NULL, 'U'}, + {"kill-at", no_argument, NULL, 'k'}, + {"add-stdcall-alias", no_argument, NULL, 'A'}, + {"ext-prefix-alias", required_argument, NULL, 'p'}, + {"verbose", no_argument, NULL, 'v'}, + {"version", no_argument, NULL, 'V'}, {"help", no_argument, NULL, 'h'}, {"machine", required_argument, NULL, 'm'}, + {"add-indirect", no_argument, NULL, 'a'}, {"base-file", required_argument, NULL, 'b'}, - 0 + {"as", required_argument, NULL, 'S'}, + {"as-flags", required_argument, NULL, 'f'}, + {"mcore-elf", required_argument, NULL, 'M'}, + {"compat-implib", no_argument, NULL, 'C'}, + {"temp-prefix", required_argument, NULL, 't'}, + {NULL,0,NULL,0} }; +int main (int, char **); + int -main (ac, av) - int ac; - char **av; +main (int ac, char **av) { int c; + int i; char *firstarg = 0; program_name = av[0]; oav = av; - while ((c = getopt_long (ac, av, "kvbuh?m:o:Dd:", long_options, 0)) != EOF) +#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) + setlocale (LC_MESSAGES, ""); +#endif +#if defined (HAVE_SETLOCALE) + setlocale (LC_CTYPE, ""); +#endif + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); + + while ((c = getopt_long (ac, av, +#ifdef DLLTOOL_MCORE_ELF + "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nvVHhM:L:F:", +#else + "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nvVHh", +#endif + long_options, 0)) + != EOF) { switch (c) { + case OPTION_EXPORT_ALL_SYMS: + export_all_symbols = TRUE; + break; + case OPTION_NO_EXPORT_ALL_SYMS: + export_all_symbols = FALSE; + break; + case OPTION_EXCLUDE_SYMS: + add_excludes (optarg); + break; + case OPTION_NO_DEFAULT_EXCLUDES: + do_default_excludes = FALSE; + break; + case 'x': + no_idata4 = 1; + break; + case 'c': + no_idata5 = 1; + break; + case 'S': + as_name = optarg; + break; + case 't': + tmp_prefix = optarg; + break; + case 'f': + as_flags = optarg; + break; + + /* Ignored for compatibility. */ + case 'u': + break; + case 'a': + add_indirect = 1; + break; + case 'z': + output_def = fopen (optarg, FOPEN_WT); + break; + case 'D': + dll_name = optarg; + break; + case 'l': + imp_name = optarg; + break; + case 'e': + exp_name = optarg; + break; + case 'H': case 'h': - case '?': - usage (stderr, 0); + usage (stdout, 0); break; case 'm': mname = optarg; break; - case 'o': - outfile_prefix = optarg; - break; case 'v': verbose = 1; break; - case 'D': - yydebug = 1; + case 'V': + print_version (program_name); break; - case 'u': - suckunderscore = 1; + case 'U': + add_underscore = 1; break; case 'k': killat = 1; break; + case 'A': + add_stdcall_alias = 1; + break; + case 'p': + ext_prefix_alias = optarg; + break; case 'd': def_file = optarg; break; + case 'n': + dontdeltemps++; + break; case 'b': - base_file = fopen (optarg, "r"); + base_file = fopen (optarg, FOPEN_RB); + if (!base_file) - { - fprintf (stderr, "%s: Unable to open base-file %s\n", - av[0], - optarg); - exit (1); - } + /* xgettext:c-format */ + fatal (_("Unable to open base-file: %s"), optarg); + + break; +#ifdef DLLTOOL_MCORE_ELF + case 'M': + mcore_elf_out_file = optarg; + break; + case 'L': + mcore_elf_linker = optarg; + break; + case 'F': + mcore_elf_linker_flags = optarg; + break; +#endif + case 'C': + create_compat_implib = 1; break; default: usage (stderr, 1); + break; } } + if (!tmp_prefix) + tmp_prefix = prefix_encode ("d", getpid ()); for (i = 0; mtable[i].type; i++) - { - if (strcmp (mtable[i].type, mname) == 0) - break; - } + if (strcmp (mtable[i].type, mname) == 0) + break; if (!mtable[i].type) + /* xgettext:c-format */ + fatal (_("Machine '%s' not supported"), mname); + + machine = i; + + if (!dll_name && exp_name) { - fprintf (stderr, "Machine not supported\n"); - exit (1); + int len = strlen (exp_name) + 5; + dll_name = xmalloc (len); + strcpy (dll_name, exp_name); + strcat (dll_name, ".dll"); } - machine = i; + if (as_name == NULL) + as_name = deduce_name ("as"); + + /* Don't use the default exclude list if we're reading only the + symbols in the .drectve section. The default excludes are meant + to avoid exporting DLL entry point and Cygwin32 impure_ptr. */ + if (! export_all_symbols) + do_default_excludes = FALSE; + + if (do_default_excludes) + set_default_excludes (); if (def_file) - { - process_def_file (def_file); - } + process_def_file (def_file); + while (optind < ac) { if (!firstarg) @@ -1226,31 +3404,273 @@ main (ac, av) optind++; } - if (!outfile_prefix) + mangle_defs (); + + if (exp_name) + gen_exp_file (); + + if (imp_name) { - if (d_name) - outfile_prefix = d_name; - else if (def_file) - outfile_prefix = def_file; - else if (firstarg) - outfile_prefix = firstarg; - else + /* Make imp_name safe for use as a label. */ + char *p; + + imp_name_lab = xstrdup (imp_name); + for (p = imp_name_lab; *p; p++) + { + if (!ISALNUM (*p)) + *p = '_'; + } + head_label = make_label("_head_", imp_name_lab); + gen_lib_file (); + } + + if (output_def) + gen_def_file (); + +#ifdef DLLTOOL_MCORE_ELF + if (mcore_elf_out_file) + mcore_elf_gen_out_file (); +#endif + + return 0; +} + +/* Look for the program formed by concatenating PROG_NAME and the + string running from PREFIX to END_PREFIX. If the concatenated + string contains a '/', try appending EXECUTABLE_SUFFIX if it is + appropriate. */ + +static char * +look_for_prog (const char *prog_name, const char *prefix, int end_prefix) +{ + struct stat s; + char *cmd; + + cmd = xmalloc (strlen (prefix) + + strlen (prog_name) +#ifdef HAVE_EXECUTABLE_SUFFIX + + strlen (EXECUTABLE_SUFFIX) +#endif + + 10); + strcpy (cmd, prefix); + + sprintf (cmd + end_prefix, "%s", prog_name); + + if (strchr (cmd, '/') != NULL) + { + int found; + + found = (stat (cmd, &s) == 0 +#ifdef HAVE_EXECUTABLE_SUFFIX + || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0 +#endif + ); + + if (! found) + { + /* xgettext:c-format */ + inform (_("Tried file: %s"), cmd); + free (cmd); + return NULL; + } + } + + /* xgettext:c-format */ + inform (_("Using file: %s"), cmd); + + return cmd; +} + +/* Deduce the name of the program we are want to invoke. + PROG_NAME is the basic name of the program we want to run, + eg "as" or "ld". The catch is that we might want actually + run "i386-pe-as" or "ppc-pe-ld". + + If argv[0] contains the full path, then try to find the program + in the same place, with and then without a target-like prefix. + + Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool, + deduce_name("as") uses the following search order: + + /usr/local/bin/i586-cygwin32-as + /usr/local/bin/as + as + + If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each + name, it'll try without and then with EXECUTABLE_SUFFIX. + + Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as" + as the fallback, but rather return i586-cygwin32-as. + + Oh, and given, argv[0] = dlltool, it'll return "as". + + Returns a dynamically allocated string. */ + +static char * +deduce_name (const char *prog_name) +{ + char *cmd; + char *dash, *slash, *cp; + + dash = NULL; + slash = NULL; + for (cp = program_name; *cp != '\0'; ++cp) + { + if (*cp == '-') + dash = cp; + if ( +#if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__) + *cp == ':' || *cp == '\\' || +#endif + *cp == '/') { - fprintf (stderr, "No way to create an output filename\n"); - exit (1); + slash = cp; + dash = NULL; } } - outfile_prefix = prefix (outfile_prefix); + + cmd = NULL; + + if (dash != NULL) + { + /* First, try looking for a prefixed PROG_NAME in the + PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */ + cmd = look_for_prog (prog_name, program_name, dash - program_name + 1); + } + + if (slash != NULL && cmd == NULL) + { + /* Next, try looking for a PROG_NAME in the same directory as + that of this program. */ + cmd = look_for_prog (prog_name, program_name, slash - program_name + 1); + } + + if (cmd == NULL) + { + /* Just return PROG_NAME as is. */ + cmd = xstrdup (prog_name); + } + + return cmd; +} + +#ifdef DLLTOOL_MCORE_ELF +typedef struct fname_cache +{ + char * filename; + struct fname_cache * next; +} +fname_cache; + +static fname_cache fnames; + +static void +mcore_elf_cache_filename (char * filename) +{ + fname_cache * ptr; + + ptr = & fnames; + + while (ptr->next != NULL) + ptr = ptr->next; + + ptr->filename = filename; + ptr->next = (fname_cache *) malloc (sizeof (fname_cache)); + if (ptr->next != NULL) + ptr->next->next = NULL; +} + +#define MCORE_ELF_TMP_OBJ "mcoreelf.o" +#define MCORE_ELF_TMP_EXP "mcoreelf.exp" +#define MCORE_ELF_TMP_LIB "mcoreelf.lib" + +static void +mcore_elf_gen_out_file (void) +{ + fname_cache * ptr; + dyn_string_t ds; + + /* Step one. Run 'ld -r' on the input object files in order to resolve + any internal references and to generate a single .exports section. */ + ptr = & fnames; + + ds = dyn_string_new (100); + dyn_string_append_cstr (ds, "-r "); + + if (mcore_elf_linker_flags != NULL) + dyn_string_append_cstr (ds, mcore_elf_linker_flags); + + while (ptr->next != NULL) + { + dyn_string_append_cstr (ds, ptr->filename); + dyn_string_append_cstr (ds, " "); + + ptr = ptr->next; + } + + dyn_string_append_cstr (ds, "-o "); + dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); + + if (mcore_elf_linker == NULL) + mcore_elf_linker = deduce_name ("ld"); + + run (mcore_elf_linker, ds->s); + + dyn_string_delete (ds); + + /* Step two. Create a .exp file and a .lib file from the temporary file. + Do this by recursively invoking dlltool... */ + ds = dyn_string_new (100); + + dyn_string_append_cstr (ds, "-S "); + dyn_string_append_cstr (ds, as_name); + + dyn_string_append_cstr (ds, " -e "); + dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP); + dyn_string_append_cstr (ds, " -l "); + dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB); + dyn_string_append_cstr (ds, " " ); + dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); if (verbose) - fprintf (stderr, "%s: Outfile prefix is %s\n", - program_name, outfile_prefix); - mangle_defs (); + dyn_string_append_cstr (ds, " -v"); - gen_exp_file (); + if (dontdeltemps) + { + dyn_string_append_cstr (ds, " -n"); + if (dontdeltemps > 1) + dyn_string_append_cstr (ds, " -n"); + } - gen_lib_file (); + /* XXX - FIME: ought to check/copy other command line options as well. */ + run (program_name, ds->s); - return 0; + dyn_string_delete (ds); + + /* Step four. Feed the .exp and object files to ld -shared to create the dll. */ + ds = dyn_string_new (100); + + dyn_string_append_cstr (ds, "-shared "); + + if (mcore_elf_linker_flags) + dyn_string_append_cstr (ds, mcore_elf_linker_flags); + + dyn_string_append_cstr (ds, " "); + dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP); + dyn_string_append_cstr (ds, " "); + dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); + dyn_string_append_cstr (ds, " -o "); + dyn_string_append_cstr (ds, mcore_elf_out_file); + + run (mcore_elf_linker, ds->s); + + dyn_string_delete (ds); + + if (dontdeltemps == 0) + unlink (MCORE_ELF_TMP_EXP); + + if (dontdeltemps < 2) + unlink (MCORE_ELF_TMP_OBJ); } +#endif /* DLLTOOL_MCORE_ELF */