winedump
A Wine DLL tool
Synopsis
winedump
[-h | sym <sym> | spec
<dll> | dump <file> ]
[mode_options]
add an example, a script, a trick and tips
examples
no example yet ...
... Feel free to add your own example above to help other Linux-lovers !
description
winedump
is a Wine tool which aims to help:
A: Reimplementing a Win32 DLL for use within Wine, or
B: Compiling a Win32 application with Winelib that uses x86
DLLs
For both tasks
in order to be able to link to the Win functions some
glue code is needed. This ’glue’ comes in the
form of a .spec file.
The .spec file, along with some dummy code, is used
to create a
Wine .so corresponding to the Windows DLL. The
winebuild program
can then resolve calls made to DLL functions.
Creating a
.spec file is a labour intensive task during which it
is
easy to make a mistake. The idea of winedump is to
automate this task
and create the majority of the support code needed for your
DLL. In
addition you can have winedump create code to help
you re-implement a
DLL, by providing tracing of calls to the DLL, and (in some
cases)
automatically determining the parameters, calling
conventions, and
return values of the DLL’s functions.
Another use for
this tool is to display (dump) information about a 32bit
DLL or PE format image file. When used in this way
winedump functions
similarly to tools such as pedump provided by many Win32
compiler
vendors.
Finally
winedump can be also used to demangle C++
symbols.
options
Mode options
depend on the mode given as the first argument.
Help
mode:
No options are used.
The program prints the help info and than exits.
Dump
mode:
<file>
Dumps the content of the file
named <file>. Various file
formats are supported (PE, NE,
LE, Minidumps, .lnk).
-C
Turns on symbol demangling.
-f
Dumps file header information.
This option dumps only the
standard PE header structures,
along with the COFF sections available in the file.
-j dir_name
Dumps only the content of
directory dir_name, for files
which header points to directories.
For PE files, currently the import, export, debug, resource,
tls and clr directories are implemented.
For NE files, currently the export and resource directories
are
implemented.
This command prints all
available information (including all
available directories - see -j option) about the
file. You may
wish to pipe the output through more/less or into a file,
since
a lot of output will be produced.
-G
Dumps contents of debug section
if any (for now, only stabs
information is supported).
Spec
mode:
<dll>
Use dll for input file and
generate implementation code.
-I dir
Look for prototypes in ’dir’ (implies
-c). In the case of
Windows DLLs, this could be
either the standard include
directory from your compiler, or a SDK include directory.
If you have a text document with prototypes (such as
documentation) that can be used also, however you may need
to delete some non-code lines to ensure that prototypes are
parsed correctly.
The ’dir’ argument can also be a file
specification (e.g.
"include/*"). If it contains wildcards you must
quote it to
prevent the shell from expanding it.
If you have no prototypes, specify /dev/null for
’dir’.
Winedump may still be able to generate some working stub
code for you.
-c
Generate skeleton code (requires
-I).
This option tells winedump to
create function stubs for each
function in the DLL. As winedump reads each exported symbol
from the source DLL, it first tries to demangle the name. If
the name is a C++ symbol, the arguments, class and return
value are all encoded into the symbol name. Winedump
converts this information into a C function prototype. If
this fails, the file(s) specified in the -I argument
are
scanned for a function prototype. If one is found it is used
for the next step of the process, code generation.
-t
TRACE arguments (implies
-c).
This option produces the same
code as -c, except that
arguments are printed out when the function is called.
Structs that are passed by value are printed as
"struct",
and functions that take variable argument lists print
"...".
-f dll
Forward calls to
’dll’ (implies -t).
This is the most complicated
level of code generation. The
same code is generated as -t, however support is
added for
forwarding calls to another DLL. The DLL to forward to is
given as ’dll’.
-D
Generate documentation.
By default, winedump generates
a standard comment at the
header of each function it generates. Passing this option
makes winedump output a full header template for standard
Wine documentation, listing the parameters and return value
of the function.
-o name
Set the output dll name
(default: dll).
By default, if winedump is run on DLL ’foo’, it
creates
files ’foo.spec’, ’foo_main.c’ etc,
and prefixes any
functions generated with ’FOO_’. If ’-o
bar’ is given,
these will become ’bar.spec’,
’bar_main.c’ and ’BAR_’
respectively.
This option is mostly useful when generating a forwarding
DLL.
-C
Assume __cdecl calls (default: __stdcall).
If winebuild cannot determine
the calling convention,
__stdcall is used by default, unless this option has
been given.
Unless -q is given, a warning will be printed for
every
function that winedump determines the calling convention
for and which does not match the assumed calling
convention.
-s num
Start prototype search after
symbol ’num’.
-e num
End prototype search after symbol
’num’.
By passing the -s or
-e options you can have winedump try to
generate code for only some functions in your DLL. This may
be used to generate a single function, for example, if you
wanted to add functionality to an existing DLL.
-S symfile
Search only prototype names
found in ’symfile’.
If you want to only generate code for a subset of exported
functions from your source DLL, you can use this option to
provide a text file containing the names of the symbols to
extract, one per line. Only the symbols present in this file
will be used in your output DLL.
-q
Don’t show progress (quiet).
No output is printed unless a
fatal error is encountered.
-v
Show lots of detail while
working (verbose).
There are 3 levels of output
while winedump is running. The
default level, when neither -q or -v are given, prints the
number of exported functions found in the dll, followed by
the name of each function as it is processed, and a status
indication of whether it was processed OK. With -v given, a
lot of information is dumped while winedump works: this is
intended to help debug any problems.
Sym
mode:
<sym>
Demangles C++ symbol
’<sym>’ and then exits.
files
function_grep.pl
Perl script used to retrieve a function prototype.
Files output in spec mode for foo.dll:
foo.spec
This is the .spec file.
foo_dll.h
foo_main.c
These are the source code files containing the minimum set
of code to build a stub DLL. The C file contains one
function, FOO_Init, which does nothing (but must be
present).
Makefile.in
This is a template for ’configure’ to produce a makefile. It
is designed for a DLL that will be inserted into the Wine
source tree.
modes
winedump can be used in several different modes. The first
argument to the program determines the mode winedump will run in.
-h
Help mode. Basic usage help is printed.
dump
To dump the contents of a file.
spec
For generating .spec files and stub DLLs.
sym
Symbol mode. Used to demangle C++ symbols.
bugs
C++ name
demangling is not fully in sync with the implementation in
msvcrt. It might be useful to submit your C++ name to the
testsuite for msvcrt.
see also
winedump’s
README file
The Winelib User Guide
The Wine Developers Guide
authors
Jon P.
Griffiths <jon_p_griffiths at yahoo dot com>
Michael Stefaniuc <mstefani at redhat dot com>