635 lines
17 KiB
C
635 lines
17 KiB
C
#pragma once
|
|
|
|
#include <lib.h>
|
|
#include <llvm-c/Core.h>
|
|
#include <llvm-c/DebugInfo.h>
|
|
#include <llvm-c/Analysis.h>
|
|
#include <llvm-c/Target.h>
|
|
#include <llvm-c/Analysis.h>
|
|
#include <llvm-c/TargetMachine.h>
|
|
|
|
enum class BBLLVMCodeGenerationPipelineResult : u8
|
|
{
|
|
success = 0,
|
|
failed_to_create_file = 1,
|
|
failed_to_add_emit_passes = 2,
|
|
};
|
|
|
|
enum class BBLLVMCodeGenerationFileType : u8
|
|
{
|
|
assembly_file = 0,
|
|
object_file = 1,
|
|
null = 2,
|
|
};
|
|
|
|
#define BB_LLVM_CODE_GENERATION_PIPELINE_OPTIONS_PADDING_BIT_COUNT (60)
|
|
|
|
struct BBLLVMCodeGenerationPipelineOptions
|
|
{
|
|
String output_dwarf_file_path;
|
|
String output_file_path;
|
|
u64 code_generation_file_type:2;
|
|
u64 optimize_when_possible:1;
|
|
u64 verify_module:1;
|
|
u64 reserved: BB_LLVM_CODE_GENERATION_PIPELINE_OPTIONS_PADDING_BIT_COUNT;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMCodeGenerationPipelineOptions) == 5 * sizeof(u64));
|
|
static_assert(BB_LLVM_CODE_GENERATION_PIPELINE_OPTIONS_PADDING_BIT_COUNT == 60);
|
|
|
|
enum class BBLLVMOptimizationLevel : u8
|
|
{
|
|
O0 = 0,
|
|
O1 = 1,
|
|
O2 = 2,
|
|
O3 = 3,
|
|
Os = 4,
|
|
Oz = 5,
|
|
};
|
|
|
|
#define BB_LLVM_OPTIMIZATION_PIPELINE_OPTIONS_PADDING_BIT_COUNT (51)
|
|
struct BBLLVMOptimizationPipelineOptions
|
|
{
|
|
u64 optimization_level:3;
|
|
u64 debug_info:1;
|
|
u64 loop_unrolling:1;
|
|
u64 loop_interleaving:1;
|
|
u64 loop_vectorization:1;
|
|
u64 slp_vectorization:1;
|
|
u64 merge_functions:1;
|
|
u64 call_graph_profile:1;
|
|
u64 unified_lto:1;
|
|
u64 assignment_tracking:1;
|
|
u64 verify_module:1;
|
|
u64 reserved:BB_LLVM_OPTIMIZATION_PIPELINE_OPTIONS_PADDING_BIT_COUNT;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMOptimizationPipelineOptions) == sizeof(u64));
|
|
static_assert(BB_LLVM_OPTIMIZATION_PIPELINE_OPTIONS_PADDING_BIT_COUNT == 51);
|
|
|
|
enum class BBLLVMUWTableKind : u64
|
|
{
|
|
None = 0, ///< No unwind table requested
|
|
Sync = 1, ///< "Synchronous" unwind tables
|
|
Async = 2, ///< "Asynchronous" unwind tables (instr precise)
|
|
Default = 2,
|
|
};
|
|
|
|
enum class BBLLVMFramePointerKind : u64
|
|
{
|
|
none = 0,
|
|
reserved = 1,
|
|
non_leaf = 2,
|
|
all = 3,
|
|
};
|
|
|
|
enum class ZeroCallUsedRegsKind : u64
|
|
{
|
|
all = 0,
|
|
skip = 1 << 0,
|
|
only_used = 1 << 1,
|
|
only_gpr = 1 << 2,
|
|
only_arg = 1 << 3,
|
|
used_gpr_arg = only_used | only_gpr | only_arg,
|
|
used_gpr = only_used | only_gpr,
|
|
used_arg = only_used | only_arg,
|
|
used = only_used,
|
|
all_gpr_arg = only_gpr | only_arg,
|
|
all_gpr = only_gpr,
|
|
all_arg = only_arg,
|
|
};
|
|
|
|
struct BBLLVMFunctionAttributesFlags0
|
|
{
|
|
u64 noreturn:1;
|
|
u64 cmse_ns_call:1;
|
|
u64 nounwind:1;
|
|
u64 returns_twice:1;
|
|
u64 cold:1;
|
|
u64 hot:1;
|
|
u64 no_duplicate:1;
|
|
u64 convergent:1;
|
|
u64 no_merge:1;
|
|
u64 will_return:1;
|
|
u64 no_caller_saved_registers:1;
|
|
u64 no_cf_check:1;
|
|
u64 no_callback:1;
|
|
u64 alloc_size:1;
|
|
u64 uniform_work_group_size:1;
|
|
u64 aarch64_pstate_sm_body:1;
|
|
u64 aarch64_pstate_sm_enabled:1;
|
|
u64 aarch64_pstate_sm_compatible:1;
|
|
u64 aarch64_preserves_za:1;
|
|
u64 aarch64_in_za:1;
|
|
u64 aarch64_out_za:1;
|
|
u64 aarch64_inout_za:1;
|
|
u64 aarch64_preserves_zt0:1;
|
|
u64 aarch64_in_zt0:1;
|
|
u64 aarch64_out_zt0:1;
|
|
u64 aarch64_inout_zt0:1;
|
|
u64 optimize_for_size:1;
|
|
u64 min_size:1;
|
|
u64 no_red_zone:1;
|
|
u64 indirect_tls_seg_refs:1;
|
|
u64 no_implicit_floats:1;
|
|
u64 sample_profile_suffix_elision_policy:1;
|
|
u64 memory_none:1;
|
|
u64 memory_readonly:1;
|
|
u64 memory_inaccessible_or_arg_memory_only:1;
|
|
u64 memory_arg_memory_only:1;
|
|
u64 strict_fp:1;
|
|
u64 no_inline:1;
|
|
u64 always_inline:1;
|
|
u64 guard_no_cf:1;
|
|
|
|
// TODO: branch protection function attributes
|
|
// TODO: cpu features
|
|
|
|
// Call-site begin
|
|
u64 call_no_builtins:1;
|
|
|
|
BBLLVMFramePointerKind definition_frame_pointer_kind:2;
|
|
u64 definition_less_precise_fpmad:1;
|
|
u64 definition_null_pointer_is_valid:1;
|
|
u64 definition_no_trapping_fp_math:1;
|
|
u64 definition_no_infs_fp_math:1;
|
|
u64 definition_no_nans_fp_math:1;
|
|
u64 definition_approx_func_fp_math:1;
|
|
u64 definition_unsafe_fp_math:1;
|
|
u64 definition_use_soft_float:1;
|
|
u64 definition_no_signed_zeroes_fp_math:1;
|
|
u64 definition_stack_realignment:1;
|
|
u64 definition_backchain:1;
|
|
u64 definition_split_stack:1;
|
|
u64 definition_speculative_load_hardening:1;
|
|
ZeroCallUsedRegsKind definition_zero_call_used_registers:4;
|
|
// TODO: denormal builtins
|
|
u64 definition_non_lazy_bind:1;
|
|
u64 definition_cmse_nonsecure_entry:1;
|
|
BBLLVMUWTableKind definition_unwind_table_kind:2;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMFunctionAttributesFlags0) == sizeof(u64));
|
|
|
|
struct BBLLVMFunctionAttributesFlags1
|
|
{
|
|
u64 definition_disable_tail_calls:1;
|
|
u64 definition_stack_protect_strong:1;
|
|
u64 definition_stack_protect:1;
|
|
u64 definition_stack_protect_req:1;
|
|
u64 definition_aarch64_new_za:1;
|
|
u64 definition_aarch64_new_zt0:1;
|
|
u64 definition_optimize_none:1;
|
|
u64 definition_naked:1;
|
|
u64 definition_inline_hint:1;
|
|
u64 _:55;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMFunctionAttributesFlags1) == sizeof(u64));
|
|
|
|
struct BBLLVMFunctionAttributes
|
|
{
|
|
String prefer_vector_width;
|
|
String stack_protector_buffer_size;
|
|
String definition_probe_stack;
|
|
String definition_stack_probe_size;
|
|
|
|
BBLLVMFunctionAttributesFlags0 flags0;
|
|
BBLLVMFunctionAttributesFlags1 flags1;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMFunctionAttributes) == 10 * sizeof(u64));
|
|
|
|
struct BBLLVMArgumentAttributes
|
|
{
|
|
LLVMTypeRef semantic_type;
|
|
LLVMTypeRef abi_type;
|
|
u64 dereferenceable_bytes;
|
|
u32 alignment;
|
|
u32 no_alias:1;
|
|
u32 non_null:1;
|
|
u32 no_undef:1;
|
|
u32 sign_extend:1;
|
|
u32 zero_extend:1;
|
|
u32 in_reg:1;
|
|
u32 no_fp_class:10;
|
|
u32 struct_return:1;
|
|
u32 writable:1;
|
|
u32 dead_on_unwind:1;
|
|
u32 in_alloca:1;
|
|
u32 dereferenceable:1;
|
|
u32 dereferenceable_or_null:1;
|
|
u32 nest:1;
|
|
u32 by_value:1;
|
|
u32 by_reference:1;
|
|
u32 no_capture:1;
|
|
u32 _:6;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMArgumentAttributes) == 2 * sizeof(LLVMTypeRef) + 2 * sizeof(u64));
|
|
|
|
struct BBLLVMAttributeListOptions
|
|
{
|
|
BBLLVMFunctionAttributes function;
|
|
BBLLVMArgumentAttributes return_;
|
|
BBLLVMArgumentAttributes* argument_pointer;
|
|
u64 argument_count;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMAttributeListOptions) == sizeof(BBLLVMFunctionAttributes) + sizeof(BBLLVMArgumentAttributes) + sizeof(void*) + sizeof(u64));
|
|
|
|
typedef void* BBLLVMAttributeList;
|
|
|
|
enum class DwarfEmissionKind
|
|
{
|
|
none,
|
|
full,
|
|
line_tables_only,
|
|
};
|
|
|
|
enum class DwarfType
|
|
{
|
|
void_type = 0x0,
|
|
address = 0x1,
|
|
boolean = 0x2,
|
|
complex_float = 0x3,
|
|
float_type = 0x4,
|
|
signed_type = 0x5,
|
|
signed_char = 0x6,
|
|
unsigned_type = 0x7,
|
|
unsigned_char = 0x8,
|
|
|
|
// DWARF 3.
|
|
imaginary_float = 0x9,
|
|
packed_decimal = 0xa,
|
|
numeric_string = 0xb,
|
|
edited = 0xc,
|
|
signed_fixed = 0xd,
|
|
unsigned_fixed = 0xe,
|
|
decimal_float = 0xf,
|
|
|
|
// DWARF 4.
|
|
UTF = 0x10,
|
|
|
|
// DWARF 5.
|
|
UCS = 0x11,
|
|
ASCII = 0x12,
|
|
|
|
// HP extensions.
|
|
HP_float80 = 0x80, // Floating-point (80 bit).
|
|
HP_complex_float80 = 0x81, // Complex floating-point (80 bit).
|
|
HP_float128 = 0x82, // Floating-point (128 bit).
|
|
HP_complex_float128 = 0x83, // Complex fp (128 bit).
|
|
HP_floathpintel = 0x84, // Floating-point (82 bit IA64).
|
|
HP_imaginary_float80 = 0x85,
|
|
HP_imaginary_float128 = 0x86,
|
|
HP_VAX_float = 0x88, // F or G floating.
|
|
HP_VAX_float_d = 0x89, // D floating.
|
|
HP_packed_decimal = 0x8a, // Cobol.
|
|
HP_zoned_decimal = 0x8b, // Cobol.
|
|
HP_edited = 0x8c, // Cobol.
|
|
HP_signed_fixed = 0x8d, // Cobol.
|
|
HP_unsigned_fixed = 0x8e, // Cobol.
|
|
HP_VAX_complex_float = 0x8f, // F or G floating complex.
|
|
HP_VAX_complex_float_d = 0x90, // D floating complex.
|
|
};
|
|
|
|
enum class DIFlagsVisibility : u32
|
|
{
|
|
none = 0,
|
|
private_ = 1,
|
|
protected_ = 2,
|
|
public_ = 3,
|
|
};
|
|
|
|
enum class DIFlagsInheritance : u32
|
|
{
|
|
none = 0,
|
|
single_ = 1,
|
|
multiple_ = 2,
|
|
virtual_ = 3,
|
|
};
|
|
|
|
struct DIFlags
|
|
{
|
|
DIFlagsVisibility visibility:2;
|
|
u32 forward_declaration:1;
|
|
u32 apple_block:1;
|
|
u32 block_by_ref_struct:1;
|
|
u32 virtual_:1;
|
|
u32 artificial:1;
|
|
u32 explicit_:1;
|
|
u32 prototyped:1;
|
|
u32 objective_c_class_complete:1;
|
|
u32 object_pointer:1;
|
|
u32 vector:1;
|
|
u32 static_member:1;
|
|
u32 lvalue_reference:1;
|
|
u32 rvalue_reference:1;
|
|
u32 reserved:1;
|
|
DIFlagsInheritance inheritance:2;
|
|
u32 introduced_virtual:1;
|
|
u32 bit_field:1;
|
|
u32 no_return:1;
|
|
u32 type_pass_by_value:1;
|
|
u32 type_pass_by_reference:1;
|
|
u32 enum_class:1;
|
|
u32 thunk:1;
|
|
u32 non_trivial:1;
|
|
u32 big_endian:1;
|
|
u32 little_endian:1;
|
|
u32 all_calls_described:1;
|
|
u32 _:3;
|
|
};
|
|
|
|
static_assert(sizeof(DIFlags) == sizeof(u32));
|
|
|
|
enum class BBLLVMEmitDwarfUnwindType : u8
|
|
{
|
|
always = 0,
|
|
no_compact_unwind = 1,
|
|
normal = 2,
|
|
};
|
|
|
|
enum class BBLLVMDwarfDirectory : u8
|
|
{
|
|
disable = 0,
|
|
enable = 1,
|
|
normal = 2,
|
|
};
|
|
|
|
enum class BBLLVMDebugCompressionType : u8
|
|
{
|
|
none = 0,
|
|
zlib = 1,
|
|
zstd = 2,
|
|
};
|
|
|
|
#define BB_LLVM_MC_TARGET_OPTIONS_PADDING_BIT_COUNT (7)
|
|
|
|
struct BBLLVMMCTargetOptions
|
|
{
|
|
String abi_name;
|
|
String assembly_language;
|
|
String split_dwarf_file;
|
|
String as_secure_log_file;
|
|
const char* argv0;
|
|
String* argv_pointer;
|
|
u64 argv_count;
|
|
String* integrated_assembler_search_path_pointer;
|
|
u64 integrated_assembler_search_path_count;
|
|
u32 relax_all:1;
|
|
u32 no_exec_stack:1;
|
|
u32 fatal_warnings:1;
|
|
u32 no_warn:1;
|
|
u32 no_deprecated_warn:1;
|
|
u32 no_type_check:1;
|
|
u32 save_temp_labels:1;
|
|
u32 incremental_linker_compatible:1;
|
|
u32 fdpic:1;
|
|
u32 show_mc_encoding:1;
|
|
u32 show_mc_inst:1;
|
|
u32 asm_verbose:1;
|
|
u32 preserve_asm_comments:1 = true;
|
|
u32 dwarf64:1;
|
|
u32 crel:1;
|
|
u32 x86_relax_relocations:1;
|
|
u32 x86_sse2_avx:1;
|
|
u32 emit_dwarf_unwind:2 = 2;
|
|
u32 use_dwarf_directory:2 = 2;
|
|
u32 debug_compression_type:2 = 0;
|
|
u32 emit_compact_unwind_non_canonical:1;
|
|
u32 ppc_use_full_register_names:1;
|
|
u32 reserved:BB_LLVM_MC_TARGET_OPTIONS_PADDING_BIT_COUNT;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMMCTargetOptions) == 112);
|
|
static_assert(BB_LLVM_MC_TARGET_OPTIONS_PADDING_BIT_COUNT == 7);
|
|
|
|
enum class BBLLVMCodeModel : u8
|
|
{
|
|
none = 0,
|
|
tiny = 1,
|
|
small = 2,
|
|
kernel = 3,
|
|
medium = 4,
|
|
large = 5,
|
|
};
|
|
|
|
enum class BBLLVMRelocationModel : u8
|
|
{
|
|
default_relocation = 0,
|
|
static_relocation = 1,
|
|
pic = 2,
|
|
dynamic_no_pic = 3,
|
|
ropi = 4,
|
|
rwpi = 5,
|
|
ropi_rwpi = 6,
|
|
};
|
|
|
|
enum class BBLLVMCodeGenerationOptimizationLevel : u8
|
|
{
|
|
none = 0, // -O0
|
|
less = 1, // -O1
|
|
normal = 2, // -O2, -Os
|
|
aggressive = 3 // -O3
|
|
};
|
|
|
|
enum class BBLLVMGlobalISelAbortMode : u8
|
|
{
|
|
disable = 0,
|
|
enable = 1,
|
|
disable_with_diag = 2,
|
|
};
|
|
|
|
enum class BBLLVMSwiftAsyncFramePointerMode : u8
|
|
{
|
|
deployment_based = 0,
|
|
always = 1,
|
|
never = 2,
|
|
};
|
|
|
|
enum class BBLLVMBasicBlockSection : u8
|
|
{
|
|
all = 0,
|
|
list = 1,
|
|
preset = 2,
|
|
none = 3,
|
|
};
|
|
|
|
enum class BBLLVMFloatAbi : u8
|
|
{
|
|
normal = 0,
|
|
soft = 1,
|
|
hard = 2,
|
|
};
|
|
|
|
enum class BBLLVMFPOpFusion : u8
|
|
{
|
|
fast = 0,
|
|
standard = 1,
|
|
strict = 2,
|
|
};
|
|
|
|
enum class BBLLVMThreadModel : u8
|
|
{
|
|
posix = 0,
|
|
single = 1,
|
|
};
|
|
|
|
enum class BBLLVMEAbi : u8
|
|
{
|
|
unknown = 0,
|
|
normal = 1,
|
|
eabi4 = 2,
|
|
eabi5 = 3,
|
|
gnu = 4,
|
|
};
|
|
|
|
enum class BBLLVMDebuggerKind : u8
|
|
{
|
|
normal = 0,
|
|
gdb = 1,
|
|
lldb = 2,
|
|
sce = 3,
|
|
dbx = 4,
|
|
};
|
|
|
|
enum class BBLLVMExceptionHandling : u8
|
|
{
|
|
none = 0,
|
|
dwarf_cfi = 1,
|
|
setjmp_longjmp = 2,
|
|
arm = 3,
|
|
win_eh = 4,
|
|
wasm = 5,
|
|
aix = 6,
|
|
zos = 7,
|
|
};
|
|
|
|
#define BB_LLVM_TARGET_OPTIONS_PADDING_BIT_COUNT (21)
|
|
|
|
struct BBLLVMTargetOptions
|
|
{
|
|
u64 unsafe_fp_math:1;
|
|
u64 no_infs_fp_math:1;
|
|
u64 no_nans_fp_math:1;
|
|
u64 no_trapping_fp_math:1 = true;
|
|
u64 no_signed_zeroes_fp_math:1;
|
|
u64 approx_func_fp_math:1;
|
|
u64 enable_aix_extended_altivec_abi:1;
|
|
u64 honor_sign_dependent_rounding_fp_math:1;
|
|
u64 no_zeroes_in_bss:1;
|
|
u64 guaranteed_tail_call_optimization:1;
|
|
u64 stack_symbol_ordering:1 = true;
|
|
u64 enable_fast_isel:1;
|
|
u64 enable_global_isel:1 = 1;
|
|
u64 global_isel_abort_mode:2;
|
|
u64 swift_async_frame_pointer:2 = 1;
|
|
u64 use_init_array:1;
|
|
u64 disable_integrated_assembler:1;
|
|
u64 function_sections:1;
|
|
u64 data_sections:1;
|
|
u64 ignore_xcoff_visibility:1;
|
|
u64 xcoff_traceback_table:1 = true;
|
|
u64 unique_section_names:1 = true;
|
|
u64 unique_basic_block_section_names:1;
|
|
u64 separate_named_sections:1;
|
|
u64 trap_unreachable:1;
|
|
u64 no_trap_after_noreturn:1;
|
|
u64 tls_size:8;
|
|
u64 emulated_tls:1;
|
|
u64 enable_tls_descriptors:1;
|
|
u64 enable_ipra:1;
|
|
u64 emit_stack_size_section:1;
|
|
u64 enable_machine_outliner:1;
|
|
u64 enable_machine_function_splitter:1;
|
|
u64 supports_default_outlining:1;
|
|
u64 emit_address_significance_table:1;
|
|
u64 bb_address_map:1;
|
|
u64 bb_sections:3 = 3;
|
|
u64 emit_call_site_information:1;
|
|
u64 supports_debug_entry_values:1;
|
|
u64 enable_debug_entry_values:1;
|
|
u64 value_tracking_variable_locations:1;
|
|
u64 force_dwarf_frame_section:1;
|
|
u64 xray_function_index:1 = true;
|
|
u64 debug_strict_dwarf:1;
|
|
u64 hotpatch:1;
|
|
u64 ppc_gen_scalar_mass_entries:1;
|
|
u64 jmc_instrument:1;
|
|
u64 enable_cfi_fixup:1;
|
|
u64 mis_expect:1;
|
|
u64 xcoff_read_only_pointers:1;
|
|
u64 float_abi:2 = 0;
|
|
u64 thread_model:1 = 0;
|
|
u32 fp_op_fusion_mode:2 = 1;
|
|
u32 eabi_version:3 = 1;
|
|
u32 debugger_kind:3 = 0;
|
|
u32 exception_handling:3 = 0;
|
|
u32 reserved:BB_LLVM_TARGET_OPTIONS_PADDING_BIT_COUNT;
|
|
unsigned loop_alignment = 0;
|
|
int binutils_version[2];
|
|
|
|
BBLLVMMCTargetOptions mc;
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMTargetOptions) == 136);
|
|
static_assert(BB_LLVM_TARGET_OPTIONS_PADDING_BIT_COUNT == 21);
|
|
|
|
#define BB_LLVM_TARGET_MACHINE_CREATE_PADDING_BYTE_COUNT (4)
|
|
|
|
struct BBLLVMTargetMachineCreate
|
|
{
|
|
BBLLVMTargetOptions target_options;
|
|
String target_triple;
|
|
String cpu_model;
|
|
String cpu_features;
|
|
BBLLVMRelocationModel relocation_model;
|
|
BBLLVMCodeModel code_model;
|
|
BBLLVMCodeGenerationOptimizationLevel optimization_level;
|
|
bool jit;
|
|
u8 reserved[BB_LLVM_TARGET_MACHINE_CREATE_PADDING_BYTE_COUNT];
|
|
};
|
|
|
|
static_assert(sizeof(BBLLVMTargetMachineCreate) == 192);
|
|
static_assert(BB_LLVM_TARGET_MACHINE_CREATE_PADDING_BYTE_COUNT == 4);
|
|
|
|
fn bool llvm_initialized = false;
|
|
|
|
extern "C" String llvm_default_target_triple();
|
|
extern "C" String llvm_host_cpu_name();
|
|
extern "C" String llvm_host_cpu_features();
|
|
|
|
extern "C" LLVMModuleRef llvm_context_create_module(LLVMContextRef context, String name);
|
|
|
|
extern "C" LLVMValueRef llvm_module_create_function(LLVMModuleRef module, LLVMTypeRef function_type, LLVMLinkage linkage_type, unsigned address_space, String name);
|
|
extern "C" void llvm_function_set_attributes(LLVMValueRef function, BBLLVMAttributeList attribute_list);
|
|
|
|
extern "C" LLVMBasicBlockRef llvm_context_create_basic_block(LLVMContextRef context, String name, LLVMValueRef parent_function);
|
|
|
|
extern "C" LLVMValueRef llvm_module_create_global_variable(LLVMModuleRef module, LLVMTypeRef type, bool is_constant, LLVMLinkage linkage_type, LLVMValueRef initial_value, String name, LLVMValueRef before, LLVMThreadLocalMode thread_local_mode, unsigned address_space, bool externally_initialized);
|
|
|
|
extern "C" LLVMValueRef llvm_builder_create_alloca(LLVMBuilderRef builder, LLVMTypeRef type, unsigned address_space, u32 alignment, String name);
|
|
extern "C" bool llvm_value_has_one_use(LLVMValueRef value);
|
|
extern "C" LLVMValueRef llvm_basic_block_user_begin(LLVMBasicBlockRef basic_block);
|
|
extern "C" void llvm_basic_block_delete(LLVMBasicBlockRef basic_block);
|
|
extern "C" bool llvm_basic_block_is_empty(LLVMBasicBlockRef basic_block);
|
|
extern "C" void llvm_function_set_attributes(LLVMValueRef f, BBLLVMAttributeList attribute_list_handle);
|
|
extern "C" void llvm_call_base_set_attributes(LLVMValueRef call_value, BBLLVMAttributeList attribute_list_handle);
|
|
|
|
extern "C" BBLLVMAttributeList llvm_attribute_list_build(LLVMContextRef context, BBLLVMAttributeListOptions* attributes, bool call_site);
|
|
extern "C" LLVMValueRef llvm_find_return_value_dominating_store(LLVMBuilderRef b, LLVMValueRef ra, LLVMTypeRef et);
|
|
extern "C" bool llvm_value_use_empty(LLVMValueRef value);
|
|
extern "C" bool llvm_function_verify(LLVMValueRef function_value, String* error_message);
|
|
extern "C" bool llvm_module_verify(LLVMModuleRef m, String* error_message);
|
|
|
|
extern "C" void llvm_subprogram_replace_type(LLVMMetadataRef subprogram, LLVMMetadataRef subroutine_type);
|
|
|
|
extern "C" String llvm_module_to_string(LLVMModuleRef module);
|
|
|
|
extern "C" LLVMTargetMachineRef llvm_create_target_machine(const BBLLVMTargetMachineCreate* create, String* error_message);
|
|
extern "C" void llvm_module_set_target(LLVMModuleRef m, LLVMTargetMachineRef tm);
|
|
extern "C" void llvm_module_run_optimization_pipeline(LLVMModuleRef module, LLVMTargetMachineRef target_machine, BBLLVMOptimizationPipelineOptions options);
|
|
extern "C" BBLLVMCodeGenerationPipelineResult llvm_module_run_code_generation_pipeline(LLVMModuleRef m, LLVMTargetMachineRef tm, const BBLLVMCodeGenerationPipelineOptions* options);
|