Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
WINEDUMP(1)		    Wine Developers Manual		   WINEDUMP(1)

NAME
       winedump	- A Wine DLL tool

SYNOPSIS
       winedump	[-h | sym sym |	spec dll | dump	file ] [mode_options]

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	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.

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.

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 then exits.

       Dump mode:

       file   Dumps the	contents of 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.

       -x     Dumps everything.
	      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 as 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.

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.

       Bugs can	be reported on the Wine	bug tracker <https://bugs.winehq.org>.

AUTHORS
       Jon P. Griffiths	<jon_p_griffiths at yahoo dot com>
       Michael Stefaniuc <mstefani at redhat dot com>

AVAILABILITY
       winedump	is part	of the Wine distribution, which	is  available  through
       WineHQ, the Wine	development headquarters <https://www.winehq.org/>.

SEE ALSO
       wine(1)
       Wine documentation and support <https://www.winehq.org/help>.

Wine 5.15			 October 2005			   WINEDUMP(1)

NAME | SYNOPSIS | DESCRIPTION | MODES | OPTIONS | FILES | BUGS | AUTHORS | AVAILABILITY | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=winedump&sektion=1&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help