3576 lines
92 KiB
C
3576 lines
92 KiB
C
/* dlltool.c -- tool to generate stuff for PE style DLLs
|
|
Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
|
|
2005, 2006 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Binutils.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
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., 51 Franklin Street - Fifth Floor, Boston, MA
|
|
02110-1301, USA. */
|
|
|
|
|
|
/* 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.
|
|
|
|
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 ".drectve" sections
|
|
with export information.
|
|
|
|
A DEF file contains any number of the following commands:
|
|
|
|
|
|
NAME <name> [ , <base> ]
|
|
The result is going to be <name>.EXE
|
|
|
|
LIBRARY <name> [ , <base> ]
|
|
The result is going to be <name>.DLL
|
|
|
|
EXPORTS ( ( ( <name1> [ = <name2> ] )
|
|
| ( <name1> = <module-name> . <external-name>))
|
|
[ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) *
|
|
Declares name1 as an exported symbol from the
|
|
DLL, with optional ordinal number <integer>.
|
|
Or declares name1 as an alias (forward) of the function <external-name>
|
|
in the DLL <module-name>.
|
|
|
|
IMPORTS ( ( <internal-name> = <module-name> . <integer> )
|
|
| ( [ <internal-name> = ] <module-name> . <external-name> )) *
|
|
Declares that <external-name> or the exported function whose ordinal number
|
|
is <integer> is to be imported from the file <module-name>. If
|
|
<internal-name> is specified then this is the name that the imported
|
|
function will be refereed to in the body of the DLL.
|
|
|
|
DESCRIPTION <string>
|
|
Puts <string> into output .exp file in the .rdata section
|
|
|
|
[STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
|
|
Generates --stack|--heap <number-reserve>,<number-commit>
|
|
in the output .drectve section. The linker will
|
|
see this and act upon it.
|
|
|
|
[CODE|DATA] <attr>+
|
|
SECTIONS ( <sectionname> <attr>+ )*
|
|
<attr> = READ | WRITE | EXECUTE | SHARED
|
|
Generates --attr <sectionname> <attr> in the output
|
|
.drectve section. The linker will see this and act
|
|
upon it.
|
|
|
|
|
|
A -export:<name> in a .drectve section in an input .o or .a
|
|
file to this program is equivalent to a EXPORTS <name>
|
|
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
|
|
supplied argument.
|
|
|
|
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.
|
|
|
|
|
|
|
|
Example:
|
|
|
|
file1.c:
|
|
asm (".section .drectve");
|
|
asm (".ascii \"-export:adef\"");
|
|
|
|
void adef (char * s)
|
|
{
|
|
printf ("hello from the dll %s\n", s);
|
|
}
|
|
|
|
void bdef (char * s)
|
|
{
|
|
printf ("hello from the dll and the other entry point %s\n", s);
|
|
}
|
|
|
|
file2.c:
|
|
asm (".section .drectve");
|
|
asm (".ascii \"-export:cdef\"");
|
|
asm (".ascii \"-export:ddef\"");
|
|
|
|
void cdef (char * s)
|
|
{
|
|
printf ("hello from the dll %s\n", s);
|
|
}
|
|
|
|
void ddef (char * s)
|
|
{
|
|
printf ("hello from the dll and the other entry point %s\n", s);
|
|
}
|
|
|
|
int printf (void)
|
|
{
|
|
return 9;
|
|
}
|
|
|
|
themain.c:
|
|
int main (void)
|
|
{
|
|
cdef ();
|
|
return 0;
|
|
}
|
|
|
|
thedll.def
|
|
|
|
LIBRARY thedll
|
|
HEAPSIZE 0x40000, 0x2000
|
|
EXPORTS bdef @ 20
|
|
cdef @ 30 NONAME
|
|
|
|
SECTIONS donkey READ WRITE
|
|
aardvark EXECUTE
|
|
|
|
# Compile up the parts of the dll and the program
|
|
|
|
gcc -c file1.c file2.c themain.c
|
|
|
|
# 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 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
|
|
|
|
# Link the executable with the import library and generate a base file
|
|
# at the same time
|
|
|
|
gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
|
|
|
|
# Run this tool over the DLL's .def file and generate an exports file
|
|
# which includes the relocations from the base file.
|
|
|
|
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 "bfd.h"
|
|
#include "libiberty.h"
|
|
#include "bucomm.h"
|
|
#include "getopt.h"
|
|
#include "demangle.h"
|
|
#include "dyn-string.h"
|
|
#include "dlltool.h"
|
|
#include "safe-ctype.h"
|
|
|
|
#include <time.h>
|
|
#include <sys/stat.h>
|
|
#include <stdarg.h>
|
|
#include <assert.h>
|
|
|
|
#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 <sys/wait.h>
|
|
#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 add_stdcall_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_<SYMBOL> 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;
|
|
static int killat;
|
|
static int add_stdcall_alias;
|
|
static const char *ext_prefix_alias;
|
|
static int verbose;
|
|
static FILE *output_def;
|
|
static FILE *base_file;
|
|
|
|
#ifdef DLLTOOL_ARM
|
|
#ifdef DLLTOOL_ARM_EPOC
|
|
static const char *mname = "arm-epoc";
|
|
#else
|
|
static const char *mname = "arm";
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef DLLTOOL_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
|
|
|
|
/* What's the right name for this ? */
|
|
#define PATHMAX 250
|
|
|
|
/* External name alias numbering starts here. */
|
|
#define PREFIX_ALIAS_BASE 20000
|
|
|
|
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 /* <address> */
|
|
};
|
|
|
|
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 /* <address> */
|
|
};
|
|
|
|
/* 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
|
|
|
|
struct mac
|
|
{
|
|
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[] =
|
|
{
|
|
{
|
|
#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
|
|
}
|
|
,
|
|
{
|
|
#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 }
|
|
};
|
|
|
|
typedef struct dlist
|
|
{
|
|
char *text;
|
|
struct dlist *next;
|
|
}
|
|
dlist_type;
|
|
|
|
typedef struct export
|
|
{
|
|
const char *name;
|
|
const char *internal_name;
|
|
const char *import_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 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 *);
|
|
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 process_duplicates (export_type **);
|
|
static void fill_ordinals (export_type **);
|
|
static void mangle_defs (void);
|
|
static void usage (FILE *, int);
|
|
static void inform (const char *, ...) ATTRIBUTE_PRINTF_1;
|
|
static void set_dll_name_from_def (const char *);
|
|
|
|
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;
|
|
}
|
|
|
|
static char *
|
|
dlltmp (char **buf, const char *fmt)
|
|
{
|
|
if (!*buf)
|
|
{
|
|
*buf = malloc (strlen (tmp_prefix) + 64);
|
|
sprintf (*buf, fmt, tmp_prefix);
|
|
}
|
|
return *buf;
|
|
}
|
|
|
|
static void
|
|
inform VPARAMS ((const char * message, ...))
|
|
{
|
|
VA_OPEN (args, message);
|
|
VA_FIXEDARG (args, const char *, message);
|
|
|
|
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 "";
|
|
}
|
|
|
|
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
|
|
|
|
static char **oav;
|
|
|
|
static void
|
|
process_def_file (const char *name)
|
|
{
|
|
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"));
|
|
}
|
|
|
|
/**********************************************************************/
|
|
|
|
/* Communications with the parser. */
|
|
|
|
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;
|
|
|
|
int
|
|
yyerror (const char * err ATTRIBUTE_UNUSED)
|
|
{
|
|
/* xgettext:c-format */
|
|
non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
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));
|
|
|
|
p->name = name;
|
|
p->internal_name = internal_name ? internal_name : name;
|
|
p->import_name = name;
|
|
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 */
|
|
}
|
|
|
|
static void
|
|
set_dll_name_from_def (const char * name)
|
|
{
|
|
const char* image_basename = lbasename (name);
|
|
if (image_basename != name)
|
|
non_fatal (_("%s: Path components stripped from image name, '%s'."),
|
|
def_file, name);
|
|
dll_name = xstrdup (image_basename);
|
|
}
|
|
|
|
void
|
|
def_name (const char *name, int base)
|
|
{
|
|
/* xgettext:c-format */
|
|
inform (_("NAME: %s base: %x"), name, base);
|
|
|
|
if (d_is_dll)
|
|
non_fatal (_("Can't have LIBRARY and NAME"));
|
|
|
|
/* If --dllname not provided, use the one in the DEF file.
|
|
FIXME: Is this appropriate for executables? */
|
|
if (! dll_name)
|
|
set_dll_name_from_def (name);
|
|
d_is_exe = 1;
|
|
}
|
|
|
|
void
|
|
def_library (const char *name, int base)
|
|
{
|
|
/* xgettext:c-format */
|
|
inform (_("LIBRARY: %s base: %x"), name, base);
|
|
|
|
if (d_is_exe)
|
|
non_fatal (_("Can't have LIBRARY and NAME"));
|
|
|
|
/* If --dllname not provided, use the one in the DEF file. */
|
|
if (! dll_name)
|
|
set_dll_name_from_def (name);
|
|
d_is_dll = 1;
|
|
}
|
|
|
|
void
|
|
def_description (const char *desc)
|
|
{
|
|
dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
|
|
d->text = xstrdup (desc);
|
|
d->next = d_list;
|
|
d_list = d;
|
|
}
|
|
|
|
static void
|
|
new_directive (char *dir)
|
|
{
|
|
dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
|
|
d->text = xstrdup (dir);
|
|
d->next = a_list;
|
|
a_list = d;
|
|
}
|
|
|
|
void
|
|
def_heapsize (int reserve, int commit)
|
|
{
|
|
char b[200];
|
|
if (commit > 0)
|
|
sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
|
|
else
|
|
sprintf (b, "-heap 0x%x ", reserve);
|
|
new_directive (xstrdup (b));
|
|
}
|
|
|
|
void
|
|
def_stacksize (int reserve, int commit)
|
|
{
|
|
char b[200];
|
|
if (commit > 0)
|
|
sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
|
|
else
|
|
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:
|
|
<func_name_in_app> = <dll_name>.<func_name_in_dll>
|
|
<func_name_in_app> = <dll_name>.<number>
|
|
<dll_name>.<func_name_in_dll>
|
|
<dll_name>.<number>
|
|
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 <entry> or <ord_val> must be
|
|
present (i.e., not NULL). */
|
|
|
|
void
|
|
def_import (const char *app_name, const char *module, const char *dllext,
|
|
const char *entry, int ord_val)
|
|
{
|
|
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 (int major, int minor)
|
|
{
|
|
printf ("VERSION %d.%d\n", major, minor);
|
|
}
|
|
|
|
void
|
|
def_section (const char *name, int attr)
|
|
{
|
|
char buf[200];
|
|
char atts[5];
|
|
char *d = atts;
|
|
if (attr & 1)
|
|
*d++ = 'R';
|
|
|
|
if (attr & 2)
|
|
*d++ = 'W';
|
|
if (attr & 4)
|
|
*d++ = 'X';
|
|
if (attr & 8)
|
|
*d++ = 'S';
|
|
*d++ = 0;
|
|
sprintf (buf, "-attr %s %s", name, atts);
|
|
new_directive (xstrdup (buf));
|
|
}
|
|
|
|
void
|
|
def_code (int attr)
|
|
{
|
|
|
|
def_section ("CODE", attr);
|
|
}
|
|
|
|
void
|
|
def_data (int attr)
|
|
{
|
|
def_section ("DATA", attr);
|
|
}
|
|
|
|
/**********************************************************************/
|
|
|
|
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 ();
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
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)
|
|
{
|
|
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 *tag_start = ++p;
|
|
while (p < e && *p != ' ' && *p != '-')
|
|
p++;
|
|
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);
|
|
}
|
|
|
|
/* Look through the symbols in MINISYMS, and add each one to list of
|
|
symbols to export. */
|
|
|
|
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. */
|
|
|
|
static void
|
|
add_excludes (const char *new_excludes)
|
|
{
|
|
char *local_copy;
|
|
char *exclude_string;
|
|
|
|
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))
|
|
{
|
|
/* 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);
|
|
while (arfile)
|
|
{
|
|
if (bfd_check_format (arfile, bfd_object))
|
|
scan_open_obj_file (arfile);
|
|
bfd_close (arfile);
|
|
arfile = bfd_openr_next_archived_file (f, arfile);
|
|
}
|
|
|
|
#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);
|
|
}
|
|
|
|
/**********************************************************************/
|
|
|
|
static void
|
|
dump_def_info (FILE *f)
|
|
{
|
|
int i;
|
|
export_type *exp;
|
|
fprintf (f, "%s ", ASM_C);
|
|
for (i = 0; oav[i]; i++)
|
|
fprintf (f, "%s ", oav[i]);
|
|
fprintf (f, "\n");
|
|
for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
|
|
{
|
|
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->private ? "PRIVATE " : "",
|
|
exp->constant ? "CONSTANT" : "",
|
|
exp->data ? "DATA" : "");
|
|
}
|
|
}
|
|
|
|
/* Generate the .exp file. */
|
|
|
|
static int
|
|
sfunc (const void *a, const void *b)
|
|
{
|
|
return *(const long *) a - *(const long *) b;
|
|
}
|
|
|
|
static void
|
|
flush_page (FILE *f, long *need, int page_addr, int on_page)
|
|
{
|
|
int i;
|
|
|
|
/* Flush this page. */
|
|
fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
|
|
ASM_LONG,
|
|
page_addr,
|
|
ASM_C);
|
|
fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
|
|
ASM_LONG,
|
|
(on_page * 2) + (on_page & 1) * 2 + 8,
|
|
ASM_C);
|
|
|
|
for (i = 0; i < on_page; i++)
|
|
{
|
|
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);
|
|
}
|
|
|
|
static void
|
|
gen_def_file (void)
|
|
{
|
|
int i;
|
|
export_type *exp;
|
|
|
|
inform (_("Adding exports to output file"));
|
|
|
|
fprintf (output_def, ";");
|
|
for (i = 0; oav[i]; i++)
|
|
fprintf (output_def, " %s", oav[i]);
|
|
|
|
fprintf (output_def, "\nEXPORTS\n");
|
|
|
|
for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
|
|
{
|
|
char *quote = strchr (exp->name, '.') ? "\"" : "";
|
|
char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
|
|
|
|
if (res)
|
|
{
|
|
fprintf (output_def,";\t%s\n", res);
|
|
free (res);
|
|
}
|
|
|
|
if (strcmp (exp->name, exp->internal_name) == 0)
|
|
{
|
|
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
|
|
{
|
|
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" : "");
|
|
}
|
|
}
|
|
|
|
inform (_("Added exports to output file"));
|
|
}
|
|
|
|
/* generate_idata_ofile generates the portable assembly source code
|
|
for the idata sections. It appends the source code to the end of
|
|
the file. */
|
|
|
|
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++;
|
|
}
|
|
|
|
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 (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 (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++;
|
|
}
|
|
|
|
fprintf (filvar, "\n\t.section\t.idata$7\n");
|
|
headindex = 0;
|
|
for (headptr = import_list; headptr != NULL; headptr = headptr->next)
|
|
{
|
|
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++;
|
|
}
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
while (i < exp->ordinal)
|
|
{
|
|
fprintf(f,"\t%s\t0\n", ASM_LONG);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
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++)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* 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;
|
|
long need[PAGE_SIZE];
|
|
long page_addr;
|
|
int numbytes;
|
|
int num_entries;
|
|
long *copy;
|
|
int j;
|
|
int on_page;
|
|
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 = xmalloc (numbytes);
|
|
fread (copy, 1, numbytes, base_file);
|
|
num_entries = numbytes / sizeof (long);
|
|
|
|
|
|
fprintf (f, "\t.section\t.reloc\n");
|
|
if (num_entries)
|
|
{
|
|
int src;
|
|
int dst = 0;
|
|
int last = -1;
|
|
qsort (copy, num_entries, sizeof (long), sfunc);
|
|
/* Delete duplicates */
|
|
for (src = 0; src < num_entries; src++)
|
|
{
|
|
if (last != copy[src])
|
|
last = copy[dst++] = copy[src];
|
|
}
|
|
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);*/
|
|
}
|
|
}
|
|
|
|
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 const char *
|
|
xlate (const char *name)
|
|
{
|
|
int lead_at = (*name == '@');
|
|
|
|
if (!lead_at && (add_underscore
|
|
|| (add_stdcall_underscore
|
|
&& strchr (name, '@'))))
|
|
{
|
|
char *copy = xmalloc (strlen (name) + 2);
|
|
|
|
copy[0] = '_';
|
|
strcpy (copy + 1, name);
|
|
name = copy;
|
|
}
|
|
|
|
if (killat)
|
|
{
|
|
char *p;
|
|
|
|
name += lead_at;
|
|
p = strchr (name, '@');
|
|
if (p)
|
|
*p = 0;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
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)
|
|
{
|
|
bfd * abfd;
|
|
asymbol * exp_label;
|
|
asymbol * iname = 0;
|
|
asymbol * iname2;
|
|
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;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
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;
|
|
|
|
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;
|
|
si->size = strlen (xlate (exp->import_name)) + 3;
|
|
si->data = xmalloc (si->size);
|
|
si->data[0] = idx & 0xff;
|
|
si->data[1] = idx >> 8;
|
|
strcpy ((char *) si->data + 2, xlate (exp->import_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);
|
|
}
|
|
}
|
|
/* 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;
|
|
}
|
|
|
|
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)
|
|
{
|
|
FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
|
|
|
|
if (f == NULL)
|
|
{
|
|
fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
|
|
return NULL;
|
|
}
|
|
|
|
if (!no_idata4)
|
|
{
|
|
fprintf (f, "\t.section .idata$4\n");
|
|
fprintf (f, "\t%s\t0\n", ASM_LONG);
|
|
}
|
|
|
|
if (!no_idata5)
|
|
{
|
|
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, "\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%s\t0\n", ASM_LONG);
|
|
#endif
|
|
|
|
#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, "\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++)
|
|
{
|
|
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;
|
|
if (ext_prefix_alias)
|
|
{
|
|
export_type alias_exp;
|
|
|
|
assert (i < PREFIX_ALIAS_BASE);
|
|
alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
|
|
alias_exp.internal_name = exp->internal_name;
|
|
alias_exp.import_name = exp->name;
|
|
alias_exp.ordinal = exp->ordinal;
|
|
alias_exp.constant = exp->constant;
|
|
alias_exp.noname = exp->noname;
|
|
alias_exp.private = exp->private;
|
|
alias_exp.data = exp->data;
|
|
alias_exp.hint = exp->hint;
|
|
alias_exp.forward = exp->forward;
|
|
alias_exp.next = exp->next;
|
|
n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE);
|
|
n->next = head;
|
|
head = n;
|
|
}
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
bfd *n = head->next;
|
|
bfd_close (head);
|
|
head = 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);
|
|
}
|
|
|
|
if (dontdeltemps < 2)
|
|
{
|
|
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));
|
|
if (ext_prefix_alias)
|
|
{
|
|
sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
|
|
if (unlink (name) < 0)
|
|
/* xgettext:c-format */
|
|
non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
|
|
}
|
|
}
|
|
}
|
|
|
|
inform (_("Created lib file"));
|
|
}
|
|
|
|
/* Run through the information gathered from the .o files and the
|
|
.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. */
|
|
if (ap->ordinal == -1)
|
|
return 1;
|
|
if (bp->ordinal == -1)
|
|
return -1;
|
|
return (ap->ordinal - bp->ordinal);
|
|
}
|
|
|
|
static int
|
|
nfunc (const void *a, const void *b)
|
|
{
|
|
export_type *ap = *(export_type **) a;
|
|
export_type *bp = *(export_type **) b;
|
|
const char *an = ap->name;
|
|
const char *bn = bp->name;
|
|
|
|
if (killat)
|
|
{
|
|
an = (an[0] == '@') ? an + 1 : an;
|
|
bn = (bn[0] == '@') ? bn + 1 : bn;
|
|
}
|
|
|
|
return (strcmp (an, bn));
|
|
}
|
|
|
|
static void
|
|
remove_null_names (export_type **ptr)
|
|
{
|
|
int src;
|
|
int dst;
|
|
|
|
for (dst = src = 0; src < d_nfuncs; src++)
|
|
{
|
|
if (ptr[src])
|
|
{
|
|
ptr[dst] = ptr[src];
|
|
dst++;
|
|
}
|
|
}
|
|
d_nfuncs = dst;
|
|
}
|
|
|
|
static void
|
|
process_duplicates (export_type **d_export_vec)
|
|
{
|
|
int more = 1;
|
|
int i;
|
|
|
|
while (more)
|
|
{
|
|
more = 0;
|
|
/* Remove duplicates. */
|
|
qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
|
|
|
|
for (i = 0; i < d_nfuncs - 1; i++)
|
|
{
|
|
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;
|
|
|
|
/* 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);
|
|
|
|
/* 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;
|
|
}
|
|
|
|
remove_null_names (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 (export_type **d_export_vec)
|
|
{
|
|
int lowest = -1;
|
|
int i;
|
|
char *ptr;
|
|
int size = 65536;
|
|
|
|
qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
|
|
|
|
/* Fill in the unset ordinals with ones from our range. */
|
|
ptr = (char *) xmalloc (size);
|
|
|
|
memset (ptr, 0, size);
|
|
|
|
/* 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 == -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;
|
|
|
|
/* First try within or after any user supplied range. */
|
|
for (j = lowest; j < size; j++)
|
|
if (ptr[j] == 0)
|
|
{
|
|
ptr[j] = 1;
|
|
d_export_vec[i]->ordinal = j;
|
|
goto done;
|
|
}
|
|
|
|
/* Then try before the range. */
|
|
for (j = lowest; j >0; j--)
|
|
if (ptr[j] == 0)
|
|
{
|
|
ptr[j] = 1;
|
|
d_export_vec[i]->ordinal = j;
|
|
goto done;
|
|
}
|
|
done:;
|
|
}
|
|
}
|
|
|
|
free (ptr);
|
|
|
|
/* And resort. */
|
|
qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
|
|
|
|
/* 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;
|
|
}
|
|
}
|
|
|
|
static void
|
|
mangle_defs (void)
|
|
{
|
|
/* First work out the minimum ordinal chosen. */
|
|
export_type *exp;
|
|
|
|
int i;
|
|
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;
|
|
|
|
process_duplicates (d_export_vec);
|
|
fill_ordinals (d_export_vec);
|
|
|
|
/* 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;
|
|
|
|
d_exports_lexically[i] = 0;
|
|
|
|
qsort (d_exports_lexically, i, sizeof (export_type *), nfunc);
|
|
|
|
/* 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 <option(s)> <object-file(s)>\n"), program_name);
|
|
/* xgetext:c-format */
|
|
fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
|
|
fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
|
|
fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
|
|
fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
|
|
fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
|
|
fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
|
|
fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
|
|
fprintf (file, _(" -z --output-def <deffile> 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 <list> Don't export <list>\n"));
|
|
fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
|
|
fprintf (file, _(" -b --base-file <basefile> 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 all symbols in interface library.\n"));
|
|
fprintf (file, _(" --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n"));
|
|
fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
|
|
fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
|
|
fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
|
|
fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
|
|
fprintf (file, _(" -f --as-flags <flags> Pass <flags> 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 <prefix> Use <prefix> 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"));
|
|
fprintf (file, _(" @<file> Read options from <file>.\n"));
|
|
#ifdef DLLTOOL_MCORE_ELF
|
|
fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
|
|
fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
|
|
fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
|
|
#endif
|
|
exit (status);
|
|
}
|
|
|
|
#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)
|
|
#define OPTION_ADD_STDCALL_UNDERSCORE (OPTION_NO_DEFAULT_EXCLUDES + 1)
|
|
|
|
static const struct option long_options[] =
|
|
{
|
|
{"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'},
|
|
{"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE},
|
|
{"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'},
|
|
{"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 (int ac, char **av)
|
|
{
|
|
int c;
|
|
int i;
|
|
char *firstarg = 0;
|
|
program_name = av[0];
|
|
oav = av;
|
|
|
|
#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);
|
|
|
|
expandargv (&ac, &av);
|
|
|
|
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 OPTION_ADD_STDCALL_UNDERSCORE:
|
|
add_stdcall_underscore = 1;
|
|
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 = (char*) lbasename (optarg);
|
|
if (dll_name != optarg)
|
|
non_fatal (_("Path components stripped from dllname, '%s'."),
|
|
optarg);
|
|
break;
|
|
case 'l':
|
|
imp_name = optarg;
|
|
break;
|
|
case 'e':
|
|
exp_name = optarg;
|
|
break;
|
|
case 'H':
|
|
case 'h':
|
|
usage (stdout, 0);
|
|
break;
|
|
case 'm':
|
|
mname = optarg;
|
|
break;
|
|
case 'v':
|
|
verbose = 1;
|
|
break;
|
|
case 'V':
|
|
print_version (program_name);
|
|
break;
|
|
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, FOPEN_RB);
|
|
|
|
if (!base_file)
|
|
/* 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 (!mtable[i].type)
|
|
/* xgettext:c-format */
|
|
fatal (_("Machine '%s' not supported"), mname);
|
|
|
|
machine = i;
|
|
|
|
if (!dll_name && exp_name)
|
|
{
|
|
/* If we are inferring dll_name from exp_name,
|
|
strip off any path components, without emitting
|
|
a warning. */
|
|
const char* exp_basename = lbasename (exp_name);
|
|
const int len = strlen (exp_basename) + 5;
|
|
dll_name = xmalloc (len);
|
|
strcpy (dll_name, exp_basename);
|
|
strcat (dll_name, ".dll");
|
|
}
|
|
|
|
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);
|
|
|
|
while (optind < ac)
|
|
{
|
|
if (!firstarg)
|
|
firstarg = av[optind];
|
|
scan_obj_file (av[optind]);
|
|
optind++;
|
|
}
|
|
|
|
mangle_defs ();
|
|
|
|
if (exp_name)
|
|
gen_exp_file ();
|
|
|
|
if (imp_name)
|
|
{
|
|
/* 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 == '/')
|
|
{
|
|
slash = cp;
|
|
dash = NULL;
|
|
}
|
|
}
|
|
|
|
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)
|
|
dyn_string_append_cstr (ds, " -v");
|
|
|
|
if (dontdeltemps)
|
|
{
|
|
dyn_string_append_cstr (ds, " -n");
|
|
|
|
if (dontdeltemps > 1)
|
|
dyn_string_append_cstr (ds, " -n");
|
|
}
|
|
|
|
/* XXX - FIME: ought to check/copy other command line options as well. */
|
|
run (program_name, ds->s);
|
|
|
|
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 */
|