llvm.c.lto

Undocumented in source.

Members

Aliases

lto_bool_t
alias lto_bool_t = bool
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
lto_code_gen_t
alias lto_code_gen_t = LLVMOpaqueLTOCodeGenerator*
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
lto_module_t
alias lto_module_t = LLVMOpaqueLTOModule*
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
thinlto_code_gen_t
alias thinlto_code_gen_t = LLVMOpaqueThinLTOCodeGenerator*
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.

Enums

lto_codegen_diagnostic_severity_t
enum lto_codegen_diagnostic_severity_t

Diagnostic severity.

lto_codegen_model
enum lto_codegen_model

\since prior to LTO_API_VERSION=3

lto_debug_model
enum lto_debug_model

\since prior to LTO_API_VERSION=3

lto_symbol_attributes
enum lto_symbol_attributes

\since prior to LTO_API_VERSION=3

Functions

lto_api_version
int lto_api_version(void )

Returns the runtime API version.

lto_codegen_add_module
lto_bool_t lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod)

Add an object module to the set of modules for which code will be generated. Returns true on error (check lto_get_error_message() for details).

lto_codegen_add_must_preserve_symbol
void lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg, const(char)* symbol)

Adds to a list of all global symbols that must exist in the final generated code. If a function is not listed there, it might be inlined into every usage and optimized away.

lto_codegen_compile
const(void)* lto_codegen_compile(lto_code_gen_t cg, size_t* length)

Generates code for all added modules into one native object file. This calls lto_codegen_optimize then lto_codegen_compile_optimized.

lto_codegen_compile_optimized
const(void)* lto_codegen_compile_optimized(lto_code_gen_t cg, size_t* length)

Generates code for the optimized merged module into one native object file. It will not run any IR optimizations on the merged module.

lto_codegen_compile_to_file
lto_bool_t lto_codegen_compile_to_file(lto_code_gen_t cg, const(char)** name)

Generates code for all added modules into one native object file. This calls lto_codegen_optimize then lto_codegen_compile_optimized (instead of returning a generated mach-o/ELF buffer, it writes to a file).

lto_codegen_create
lto_code_gen_t lto_codegen_create()

Instantiates a code generator. Returns NULL on error (check lto_get_error_message() for details).

lto_codegen_create_in_local_context
lto_code_gen_t lto_codegen_create_in_local_context()

\brief Instantiate a code generator in its own context.

lto_codegen_debug_options
void lto_codegen_debug_options(lto_code_gen_t cg, const(char)* )

Sets options to help debug codegen bugs.

lto_codegen_dispose
void lto_codegen_dispose(lto_code_gen_t )

Frees all code generator and all memory it internally allocated. Upon return the lto_code_gen_t is no longer valid.

lto_codegen_optimize
lto_bool_t lto_codegen_optimize(lto_code_gen_t cg)

Runs optimization for the merged module. Returns true on error.

lto_codegen_set_assembler_args
void lto_codegen_set_assembler_args(lto_code_gen_t cg, const(char)** args, int nargs)

Sets extra arguments that libLTO should pass to the assembler.

lto_codegen_set_assembler_path
void lto_codegen_set_assembler_path(lto_code_gen_t cg, const(char)* path)

Sets the location of the assembler tool to run. If not set, libLTO will use gcc to invoke the assembler.

lto_codegen_set_cpu
void lto_codegen_set_cpu(lto_code_gen_t cg, const(char)* cpu)

Sets the cpu to generate code for.

lto_codegen_set_debug_model
lto_bool_t lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model )

Sets if debug info should be generated. Returns true on error (check lto_get_error_message() for details).

lto_codegen_set_diagnostic_handler
void lto_codegen_set_diagnostic_handler(lto_code_gen_t , lto_diagnostic_handler_t , void* )

Set a diagnostic handler and the related context (void *). This is more general than lto_get_error_message, as the diagnostic handler can be called at anytime within lto.

lto_codegen_set_module
void lto_codegen_set_module(lto_code_gen_t cg, lto_module_t mod)

Sets the object module for code generation. This will transfer the ownership of the module to the code generator.

lto_codegen_set_pic_model
lto_bool_t lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model )

Sets which PIC code model to generated. Returns true on error (check lto_get_error_message() for details).

lto_codegen_set_should_embed_uselists
void lto_codegen_set_should_embed_uselists(lto_code_gen_t cg, lto_bool_t ShouldEmbedUselists)

\brief Set whether to embed uselists in bitcode.

lto_codegen_set_should_internalize
void lto_codegen_set_should_internalize(lto_code_gen_t cg, lto_bool_t ShouldInternalize)

Sets if we should run internalize pass during optimization and code generation.

lto_codegen_write_merged_modules
lto_bool_t lto_codegen_write_merged_modules(lto_code_gen_t cg, const(char)* path)

Writes a new object file at the specified path that contains the merged contents of all modules added so far. Returns true on error (check lto_get_error_message() for details).

lto_get_error_message
const(char)* lto_get_error_message()

Returns the last error string or NULL if last operation was successful.

lto_get_version
const(char)* lto_get_version()

Returns a printable string.

lto_initialize_disassembler
void lto_initialize_disassembler()

Initializes LLVM disassemblers. FIXME: This doesn't really belong here.

lto_module_create
lto_module_t lto_module_create(const(char)* path)

Loads an object file from disk. Returns NULL on error (check lto_get_error_message() for details).

lto_module_create_from_fd
lto_module_t lto_module_create_from_fd(int fd, const(char)* path, size_t file_size)

Loads an object file from disk. The seek point of fd is not preserved. Returns NULL on error (check lto_get_error_message() for details).

lto_module_create_from_fd_at_offset
lto_module_t lto_module_create_from_fd_at_offset(int fd, const(char)* path, size_t file_size, size_t map_size, off_t offset)

Loads an object file from disk. The seek point of fd is not preserved. Returns NULL on error (check lto_get_error_message() for details).

lto_module_create_from_memory
lto_module_t lto_module_create_from_memory(const(void)* mem, size_t length)

Loads an object file from memory. Returns NULL on error (check lto_get_error_message() for details).

lto_module_create_from_memory_with_path
lto_module_t lto_module_create_from_memory_with_path(const(void)* mem, size_t length, const(char)* path)

Loads an object file from memory with an extra path argument. Returns NULL on error (check lto_get_error_message() for details).

lto_module_create_in_codegen_context
lto_module_t lto_module_create_in_codegen_context(const(void)* mem, size_t length, const(char)* path, lto_code_gen_t cg)

\brief Loads an object file in the codegen context.

lto_module_create_in_local_context
lto_module_t lto_module_create_in_local_context(const(void)* mem, size_t length, const(char)* path)

\brief Loads an object file in its own context.

lto_module_dispose
void lto_module_dispose(lto_module_t mod)

Frees all memory internally allocated by the module. Upon return the lto_module_t is no longer valid.

lto_module_get_linkeropts
const(char)* lto_module_get_linkeropts(lto_module_t mod)

Returns the module's linker options.

lto_module_get_num_symbols
uint lto_module_get_num_symbols(lto_module_t mod)

Returns the number of symbols in the object module.

lto_module_get_symbol_attribute
lto_symbol_attributes lto_module_get_symbol_attribute(lto_module_t mod, uint index)

Returns the attributes of the ith symbol in the object module.

lto_module_get_symbol_name
const(char)* lto_module_get_symbol_name(lto_module_t mod, uint index)

Returns the name of the ith symbol in the object module.

lto_module_get_target_triple
const(char)* lto_module_get_target_triple(lto_module_t mod)

Returns triple string which the object module was compiled under.

lto_module_is_object_file
bool lto_module_is_object_file(const(char)* path)

Checks if a file is a loadable object file.

lto_module_is_object_file_for_target
bool lto_module_is_object_file_for_target(const(char)* path, const(char)* target_triple_prefix)

Checks if a file is a loadable object compiled for requested target.

lto_module_is_object_file_in_memory
lto_bool_t lto_module_is_object_file_in_memory(const(void)* mem, size_t length)

Checks if a buffer is a loadable object file.

lto_module_is_object_file_in_memory
lto_bool_t lto_module_is_object_file_in_memory(const(void)* mem, size_t length)

Checks if a buffer is a loadable object file.

lto_module_is_object_file_in_memory_for_target
lto_bool_t lto_module_is_object_file_in_memory_for_target(const(void)* mem, size_t length, const(char)* target_triple_prefix)

Checks if a buffer is a loadable object compiled for requested target.

lto_module_is_thinlto
lto_bool_t lto_module_is_thinlto(lto_module_t mod)

Test if a module has support for ThinLTO linking.

lto_module_set_target_triple
void lto_module_set_target_triple(lto_module_t mod, const(char)* triple)

Sets triple string with which the object will be codegened.

thinlto_codegen_add_cross_referenced_symbol
void thinlto_codegen_add_cross_referenced_symbol(thinlto_code_gen_t cg, const(char)* name, int length)

Adds a symbol to the list of global symbols that are cross-referenced between ThinLTO files. If the ThinLTO CodeGenerator can ensure that every references from a ThinLTO module to this symbol is optimized away, then the symbol can be discarded.

thinlto_codegen_add_module
void thinlto_codegen_add_module(thinlto_code_gen_t cg, const(char)* identifier, const(char)* data, int length)

Add a module to a ThinLTO code generator. Identifier has to be unique among all the modules in a code generator. The data buffer stays owned by the client, and is expected to be available for the entire lifetime of the thinlto_code_gen_t it is added to.

thinlto_codegen_add_must_preserve_symbol
void thinlto_codegen_add_must_preserve_symbol(thinlto_code_gen_t cg, const(char)* name, int length)

Adds a symbol to the list of global symbols that must exist in the final generated code. If a function is not listed there, it might be inlined into every usage and optimized away. For every single module, the functions referenced from code outside of the ThinLTO modules need to be added here.

thinlto_codegen_disable_codegen
void thinlto_codegen_disable_codegen(thinlto_code_gen_t cg, lto_bool_t disable)

Disable CodeGen, only run the stages till codegen and stop. The output will be bitcode.

thinlto_codegen_dispose
void thinlto_codegen_dispose(thinlto_code_gen_t cg)

Frees the generator and all memory it internally allocated. Upon return the thinlto_code_gen_t is no longer valid.

thinlto_codegen_process
void thinlto_codegen_process(thinlto_code_gen_t cg)

Optimize and codegen all the modules added to the codegenerator using ThinLTO. Resulting objects are accessible using thinlto_module_get_object().

thinlto_codegen_set_cache_dir
void thinlto_codegen_set_cache_dir(thinlto_code_gen_t cg, const(char)* cache_dir)

Sets the path to a directory to use as a cache storage for incremental build. Setting this activates caching.

thinlto_codegen_set_cache_entry_expiration
void thinlto_codegen_set_cache_entry_expiration(thinlto_code_gen_t cg, uint expiration)

Sets the expiration (in seconds) for an entry in the cache. An unspecified default value will be applied. A value of 0 will be ignored.

thinlto_codegen_set_cache_pruning_interval
void thinlto_codegen_set_cache_pruning_interval(thinlto_code_gen_t cg, int interval)

Sets the cache pruning interval (in seconds). A negative value disable the pruning. An unspecified default value will be applied, and a value of 0 will be ignored.

thinlto_codegen_set_codegen_only
void thinlto_codegen_set_codegen_only(thinlto_code_gen_t cg, lto_bool_t codegen_only)

Perform CodeGen only: disable all other stages.

thinlto_codegen_set_cpu
void thinlto_codegen_set_cpu(thinlto_code_gen_t cg, const(char)* cpu)

Sets the cpu to generate code for.

thinlto_codegen_set_final_cache_size_relative_to_available_space
void thinlto_codegen_set_final_cache_size_relative_to_available_space(thinlto_code_gen_t cg, uint percentage)

Sets the maximum cache size that can be persistent across build, in terms of percentage of the available space on the the disk. Set to 100 to indicate no limit, 50 to indicate that the cache size will not be left over half the available space. A value over 100 will be reduced to 100, a value of 0 will be ignored. An unspecified default value will be applied.

thinlto_codegen_set_pic_model
lto_bool_t thinlto_codegen_set_pic_model(thinlto_code_gen_t cg, lto_codegen_model )

Sets which PIC code model to generate. Returns true on error (check lto_get_error_message() for details).

thinlto_codegen_set_savetemps_dir
void thinlto_codegen_set_savetemps_dir(thinlto_code_gen_t cg, const(char)* save_temps_dir)

Sets the path to a directory to use as a storage for temporary bitcode files. The intention is to make the bitcode files available for debugging at various stage of the pipeline.

thinlto_create_codegen
thinlto_code_gen_t thinlto_create_codegen()

Instantiates a ThinLTO code generator. Returns NULL on error (check lto_get_error_message() for details).

thinlto_debug_options
void thinlto_debug_options(const(char)** options, int number)

Parse -mllvm style debug options.

thinlto_module_get_num_objects
uint thinlto_module_get_num_objects(thinlto_code_gen_t cg)

Returns the number of object files produced by the ThinLTO CodeGenerator.

thinlto_module_get_object
LTOObjectBuffer thinlto_module_get_object(thinlto_code_gen_t cg, uint index)

Returns a reference to the ith object file produced by the ThinLTO CodeGenerator.

Manifest constants

LTO_API_VERSION
enum LTO_API_VERSION;

@defgroup LLVMCLTO LTO @ingroup LLVMC

Structs

LLVMOpaqueLTOCodeGenerator
struct LLVMOpaqueLTOCodeGenerator

opaque reference to a code generator

LLVMOpaqueLTOModule
struct LLVMOpaqueLTOModule

opaque reference to a loaded object module

LLVMOpaqueThinLTOCodeGenerator
struct LLVMOpaqueThinLTOCodeGenerator

opaque reference to a thin code generator

LTOObjectBuffer
struct LTOObjectBuffer

Type to wrap a single object returned by ThinLTO.

Meta