llvm2cpp(1)

NAME

llvm2xpp - LLVM bitcode to LLVM C++ IR translator

SYNOPSIS

llvm2cpp [options] [filename]

DESCRIPTION

llvm2cpp translates from LLVM bitcode (.bc files) to a corresponding C++ source file that will make calls against the LLVM C++ API to build the same module as the input. By default, the C++ output is a complete program that builds the module, verifies it and then emits the module
as LLVM assembly. This technique assists with testing because the input to llvm2cpp and the output of the generated C++ program should be identical.

If filename is omitted or is "-", then llvm2cpp reads its input from standard input.

If an output file is not specified with the -o option, then llvm2cpp sends its output to a file or standard output by following these rules:

� If the input is standard input, then the output is standard output.

� If the input is a file that ends with ".bc", then the output file: is of the same name, except that the suffix is changed to ".cpp".
� If the input is a file that does not end with the ".bc" suffix,: then the output file has the same name as the input file, except
that the ".cpp" suffix is appended.

OPTIONS

-f Force overwrite. Normally, llvm2cpp will refuse to overwrite an: output file that already exists. With this option, llvm2cpp will overwrite the output file and replace it with new C++ source code.
--help: Print a summary of command line options.
-f Normally, llvm2cpp will not overwrite an existing output file. With: this option, that default behavior is changed and the program will overwrite existing output files.
-o filename: Specify the output file name. If filename is "-", then llvm2cpp sends its output to standard output.
-funcname functionName: Specify the name of the function to be generated. The generated
code contains a single function that produces the input module. By default its name is makeLLVMModule. The -funcname option overrides this default and allows you to control the name of the generated
function. This is handy in conjunction with the -fragment option when you only want llvm2cpp to generate a single function that produces the module. With both options, such generated code could
be #included into another program.
-for: Specify the name of the thing for which C++ code should be
generated. By default the entire input module is re-generated.
However, use of the various -gen-* options can restrict what is produced. This option indicates what that restriction is.
-gen-program: Specify that the output should be a complete program. Such program will recreate llvm2cpp's input as an LLVM module, verify that module, and then write out the module in LLVM assembly format. This is useful for doing identity tests where the output of the
generated program is identical to the input to llvm2cpp. The LLVM DejaGnu test suite can make use of this fact. This is the default
form of generated output.; If the -for option is given with this option, it specifies the module identifier to use for the module created.
-gen-module: Specify that the output should be a function that regenerates the
module. It is assumed that this output will be #included into
another program that has already arranged for the correct header
files to be #included. The function generated takes no arguments
and returns a Module*.; If the -for option is given with this option, it specifies the module identifier to use in creating the module returned by the
generated function.
-gen-contents: Specify that the output should be a function that adds the contents of the input module to another module. It is assumed that the
output will be #included into another program that has already
arranged for the correct header files to be #included. The function generated takes a single argument of type Module* and returns that argument. Note that Module level attributes such as endianess,
pointer size, target triple and inline asm are not passed on from
the input module to the destination module. Only the sub-elements
of the module (types, constants, functions, global variables) will be added to the input module.; If the -for option is given with this option, it specifies the module identifier to set in the input module by the generated
function.
-gen-function: Specify that the output should be a function that produces the
definitions necessary for a specific function to be added to a
module. It is assumed that the output will be #included into
another program that has already arranged for the correct header
files to be #included. The function generated takes a single
argument of type Module* and returns the Function* that it added to the module. Note that only those things (types, constants, etc.)
directly needed in the definition of the function will be placed in the generated function.; The -for option must be given with this option or an error will be produced. The value of the option must be the name of a function
in the input module for which code should be generated. If the
named function does not exist an error will be produced.
-gen-inline: This option is very analagous to -gen-function except that the generated function will not re-produce the target function's
definition. Instead, the body of the target function is inserted
into some other function passed as an argument to the generated
function. Similarly any arguments to the function must be passed to the generated function. The result of the generated function is the first basic block of the target function.; The -for option works the same way as it does for -gen-function.
-gen-variable: Specify that the output should be a function that produces the
definitions necessary for a specific global variable to be added to a module. It is assumed that the output will be #included into
another program that has already arranged for the correct header
files to be #included. The function generated takes a single
argument of type Module* and returns the GlobalVariable* that it added to the module. Note that only those things (types, constants, etc.) directly needed in the definition of the global variable
will be placed in the generated function.; The -for option must be given with this option or an error will be produced. THe value of the option must be the name of a global
variable in the input module for which code should be generated. If the named global variable does not exist an error will be produced.
-gen-type: Specify that the output should be a function that produces the
definitions necessary for specific type to be added to a module. It is assumed that the otuput will be #included into another program
that has already arranged for the correct header files to be
#included. The function generated take a single argument of type
Module* and returns the Type* that it added to the module. Note that the generated function will only add the necessary type
definitions to (possibly recursively) define the requested type.; The -for option must be given with this option or an error will be produced. The value of the option must be the name of a global
type in the input module for which code should be generated. If the named type does not exist an error will be produced.
-stats: Show pass statistics (not interesting in this program).
-time-passes: Show pass timing statistics (not interesting in this program).
-version: Show the version number of this program.

EXIT STATUS

If llvm2cpp succeeds, it will exit with 0. Otherwise, if an error occurs, it will exit with a non-zero value.

NOTES

This tool may be removed from a future version of LLVM. Instead, its
functionality may be incorporated into the llc tool. It would then act similarly to other targets except its output would be C++ source that
could be compiled to construct the input program.

AUTHORS

Written by Reid Spencer (<http://hlvm.org>).

docs.sk

komplexný repozitár dokumentácie

Najnavštevovanejšie