lto.h

Go to the documentation of this file.

/*===-- llvm-c/lto.h - LTO Public C Interface ---------------------*- C -*-===*\
|*                                                                            *|
|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
|* Exceptions.                                                                *|
|* See https://llvm.org/LICENSE.txt for license information.                  *|
|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
|*                                                                            *|
|*===----------------------------------------------------------------------===*|
|*                                                                            *|
|* This header provides public interface to an abstract link time optimization*|
|* library.  LLVM provides an implementation of this interface for use with   *|
|* llvm bitcode files.                                                        *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
#ifndef LLVM_C_LTO_H
#define LLVM_C_LTO_H
 
#include "llvm-c/ExternC.h"
 
#ifdef __cplusplus
#include <cstddef>
#else
#include <stddef.h>
#endif
#include <sys/types.h>
 
#ifndef __cplusplus
#if !defined(_MSC_VER)
#include <stdbool.h>
typedef bool lto_bool_t;
#else
/* MSVC in particular does not have anything like _Bool or bool in C, but we can
   at least make sure the type is the same size.  The implementation side will
   use C++ bool. */
typedef unsigned char lto_bool_t;
#endif
#else
typedef bool lto_bool_t;
#endif
 
#define LTO_API_VERSION 29
 
typedef enum {
    LTO_SYMBOL_ALIGNMENT_MASK              = 0x0000001F, /* log2 of alignment */
    LTO_SYMBOL_PERMISSIONS_MASK            = 0x000000E0,
    LTO_SYMBOL_PERMISSIONS_CODE            = 0x000000A0,
    LTO_SYMBOL_PERMISSIONS_DATA            = 0x000000C0,
    LTO_SYMBOL_PERMISSIONS_RODATA          = 0x00000080,
    LTO_SYMBOL_DEFINITION_MASK             = 0x00000700,
    LTO_SYMBOL_DEFINITION_REGULAR          = 0x00000100,
    LTO_SYMBOL_DEFINITION_TENTATIVE        = 0x00000200,
    LTO_SYMBOL_DEFINITION_WEAK             = 0x00000300,
    LTO_SYMBOL_DEFINITION_UNDEFINED        = 0x00000400,
    LTO_SYMBOL_DEFINITION_WEAKUNDEF        = 0x00000500,
    LTO_SYMBOL_SCOPE_MASK                  = 0x00003800,
    LTO_SYMBOL_SCOPE_INTERNAL              = 0x00000800,
    LTO_SYMBOL_SCOPE_HIDDEN                = 0x00001000,
    LTO_SYMBOL_SCOPE_PROTECTED             = 0x00002000,
    LTO_SYMBOL_SCOPE_DEFAULT               = 0x00001800,
    LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN = 0x00002800,
    LTO_SYMBOL_COMDAT                      = 0x00004000,
    LTO_SYMBOL_ALIAS                       = 0x00008000
} lto_symbol_attributes;
 
typedef enum {
    LTO_DEBUG_MODEL_NONE         = 0,
    LTO_DEBUG_MODEL_DWARF        = 1
} lto_debug_model;
 
typedef enum {
    LTO_CODEGEN_PIC_MODEL_STATIC         = 0,
    LTO_CODEGEN_PIC_MODEL_DYNAMIC        = 1,
    LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2,
    LTO_CODEGEN_PIC_MODEL_DEFAULT        = 3
} lto_codegen_model;
 
typedef struct LLVMOpaqueLTOModule *lto_module_t;
 
typedef struct LLVMOpaqueLTOCodeGenerator *lto_code_gen_t;
 
typedef struct LLVMOpaqueThinLTOCodeGenerator *thinlto_code_gen_t;
 
LLVM_C_EXTERN_C_BEGIN
 
extern const char*
lto_get_version(void);
 
extern const char*
lto_get_error_message(void);
 
extern lto_bool_t
lto_module_is_object_file(const char* path);
 
extern lto_bool_t
lto_module_is_object_file_for_target(const char* path,
                                     const char* target_triple_prefix);
 
extern lto_bool_t
lto_module_has_objc_category(const void *mem, size_t length);
 
extern lto_bool_t lto_module_is_object_file_in_memory(const void *mem,
                                                      size_t length);
 
extern lto_bool_t
lto_module_is_object_file_in_memory_for_target(const void* mem, size_t length,
                                              const char* target_triple_prefix);
 
extern lto_module_t
lto_module_create(const char* path);
 
extern lto_module_t
lto_module_create_from_memory(const void* mem, size_t length);
 
extern lto_module_t
lto_module_create_from_memory_with_path(const void* mem, size_t length,
                                        const char *path);
 
extern lto_module_t
lto_module_create_in_local_context(const void *mem, size_t length,
                                   const char *path);
 
extern lto_module_t
lto_module_create_in_codegen_context(const void *mem, size_t length,
                                     const char *path, lto_code_gen_t cg);
 
extern lto_module_t
lto_module_create_from_fd(int fd, const char *path, size_t file_size);
 
extern 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);
 
extern void
lto_module_dispose(lto_module_t mod);
 
extern const char*
lto_module_get_target_triple(lto_module_t mod);
 
extern void
lto_module_set_target_triple(lto_module_t mod, const char *triple);
 
extern unsigned int
lto_module_get_num_symbols(lto_module_t mod);
 
extern const char*
lto_module_get_symbol_name(lto_module_t mod, unsigned int index);
 
extern lto_symbol_attributes
lto_module_get_symbol_attribute(lto_module_t mod, unsigned int index);
 
extern const char*
lto_module_get_linkeropts(lto_module_t mod);
 
extern lto_bool_t lto_module_get_macho_cputype(lto_module_t mod,
                                               unsigned int *out_cputype,
                                               unsigned int *out_cpusubtype);
 
extern lto_bool_t lto_module_has_ctor_dtor(lto_module_t mod);
typedef enum {
  LTO_DS_ERROR = 0,
  LTO_DS_WARNING = 1,
  LTO_DS_REMARK = 3, // Added in LTO_API_VERSION=10.
  LTO_DS_NOTE = 2
} lto_codegen_diagnostic_severity_t;
 
typedef void (*lto_diagnostic_handler_t)(
    lto_codegen_diagnostic_severity_t severity, const char *diag, void *ctxt);
 
extern void lto_codegen_set_diagnostic_handler(lto_code_gen_t,
                                               lto_diagnostic_handler_t,
                                               void *);
 
extern lto_code_gen_t
lto_codegen_create(void);
 
extern lto_code_gen_t
lto_codegen_create_in_local_context(void);
 
extern void
lto_codegen_dispose(lto_code_gen_t);
 
extern lto_bool_t
lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod);
 
extern void
lto_codegen_set_module(lto_code_gen_t cg, lto_module_t mod);
 
extern lto_bool_t
lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model);
 
extern lto_bool_t
lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model);
 
extern void
lto_codegen_set_cpu(lto_code_gen_t cg, const char *cpu);
 
extern void
lto_codegen_set_assembler_path(lto_code_gen_t cg, const char* path);
 
extern void
lto_codegen_set_assembler_args(lto_code_gen_t cg, const char **args,
                               int nargs);
 
extern void
lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg, const char* symbol);
 
extern lto_bool_t
lto_codegen_write_merged_modules(lto_code_gen_t cg, const char* path);
 
extern const void*
lto_codegen_compile(lto_code_gen_t cg, size_t* length);
 
extern lto_bool_t
lto_codegen_compile_to_file(lto_code_gen_t cg, const char** name);
 
extern lto_bool_t
lto_codegen_optimize(lto_code_gen_t cg);
 
extern const void*
lto_codegen_compile_optimized(lto_code_gen_t cg, size_t* length);
 
extern unsigned int
lto_api_version(void);
 
extern void lto_set_debug_options(const char *const *options, int number);
 
extern void
lto_codegen_debug_options(lto_code_gen_t cg, const char *);
 
extern void lto_codegen_debug_options_array(lto_code_gen_t cg,
                                            const char *const *, int number);
 
extern void
lto_initialize_disassembler(void);
 
extern void
lto_codegen_set_should_internalize(lto_code_gen_t cg,
                                   lto_bool_t ShouldInternalize);
 
extern void
lto_codegen_set_should_embed_uselists(lto_code_gen_t cg,
                                      lto_bool_t ShouldEmbedUselists);
 
typedef struct LLVMOpaqueLTOInput *lto_input_t;
 
extern lto_input_t lto_input_create(const void *buffer,
                                    size_t buffer_size,
                                    const char *path);
 
extern void lto_input_dispose(lto_input_t input);
 
extern unsigned lto_input_get_num_dependent_libraries(lto_input_t input);
 
extern const char * lto_input_get_dependent_library(lto_input_t input,
                                                    size_t index,
                                                    size_t *size);
 
extern const char *const *lto_runtime_lib_symbols_list(size_t *size);
 
typedef struct {
  const char *Buffer;
  size_t Size;
} LTOObjectBuffer;
 
extern thinlto_code_gen_t thinlto_create_codegen(void);
 
extern void thinlto_codegen_dispose(thinlto_code_gen_t cg);
 
extern void thinlto_codegen_add_module(thinlto_code_gen_t cg,
                                       const char *identifier, const char *data,
                                       int length);
 
extern void thinlto_codegen_process(thinlto_code_gen_t cg);
 
extern unsigned int thinlto_module_get_num_objects(thinlto_code_gen_t cg);
 
extern LTOObjectBuffer thinlto_module_get_object(thinlto_code_gen_t cg,
                                                 unsigned int index);
 
unsigned int thinlto_module_get_num_object_files(thinlto_code_gen_t cg);
 
const char *thinlto_module_get_object_file(thinlto_code_gen_t cg,
                                           unsigned int index);
 
extern lto_bool_t thinlto_codegen_set_pic_model(thinlto_code_gen_t cg,
                                                lto_codegen_model);
 
extern void thinlto_codegen_set_savetemps_dir(thinlto_code_gen_t cg,
                                              const char *save_temps_dir);
 
void thinlto_set_generated_objects_dir(thinlto_code_gen_t cg,
                                       const char *save_temps_dir);
 
extern void thinlto_codegen_set_cpu(thinlto_code_gen_t cg, const char *cpu);
 
extern void thinlto_codegen_disable_codegen(thinlto_code_gen_t cg,
                                            lto_bool_t disable);
 
extern void thinlto_codegen_set_codegen_only(thinlto_code_gen_t cg,
                                             lto_bool_t codegen_only);
 
extern void thinlto_debug_options(const char *const *options, int number);
 
extern lto_bool_t lto_module_is_thinlto(lto_module_t mod);
 
extern void thinlto_codegen_add_must_preserve_symbol(thinlto_code_gen_t cg,
                                                     const char *name,
                                                     int length);
 
extern void thinlto_codegen_add_cross_referenced_symbol(thinlto_code_gen_t cg,
                                                        const char *name,
                                                        int length);
 
extern void thinlto_codegen_set_cache_dir(thinlto_code_gen_t cg,
                                          const char *cache_dir);
 
extern void thinlto_codegen_set_cache_pruning_interval(thinlto_code_gen_t cg,
                                                       int interval);
 
extern void thinlto_codegen_set_final_cache_size_relative_to_available_space(
    thinlto_code_gen_t cg, unsigned percentage);
 
extern void thinlto_codegen_set_cache_entry_expiration(thinlto_code_gen_t cg,
                                                       unsigned expiration);
 
extern void thinlto_codegen_set_cache_size_bytes(thinlto_code_gen_t cg,
                                                 unsigned max_size_bytes);
 
extern void
thinlto_codegen_set_cache_size_megabytes(thinlto_code_gen_t cg,
                                         unsigned max_size_megabytes);
 
extern void thinlto_codegen_set_cache_size_files(thinlto_code_gen_t cg,
                                                 unsigned max_size_files);
 
LLVM_C_EXTERN_C_END
 
#endif /* LLVM_C_LTO_H */