Commit 1fa4d2a5af
Changed files (7)
src/all_types.hpp
@@ -1015,7 +1015,7 @@ struct TypeTableEntry {
Buf name;
LLVMTypeRef type_ref;
- LLVMZigDIType *di_type;
+ ZigLLVMDIType *di_type;
bool zero_bits;
bool deep_const;
@@ -1055,7 +1055,7 @@ struct ImportTableEntry {
AstNode *root;
Buf *path; // relative to root_package->root_src_dir
PackageTableEntry *package;
- LLVMZigDIFile *di_file;
+ ZigLLVMDIFile *di_file;
Buf *source_code;
ZigList<int> *line_offsets;
BlockContext *block_context;
@@ -1190,8 +1190,8 @@ struct CodeGen {
LLVMModuleRef module;
ZigList<ErrorMsg*> errors;
LLVMBuilderRef builder;
- LLVMZigDIBuilder *dbuilder;
- LLVMZigDICompileUnit *compile_unit;
+ ZigLLVMDIBuilder *dbuilder;
+ ZigLLVMDICompileUnit *compile_unit;
ZigList<Buf *> link_libs; // non-libc link libs
@@ -1271,7 +1271,7 @@ struct CodeGen {
uint32_t target_environ_index;
uint32_t target_oformat_index;
LLVMTargetMachineRef target_machine;
- LLVMZigDIFile *dummy_di_file;
+ ZigLLVMDIFile *dummy_di_file;
bool is_native_target;
PackageTableEntry *root_package;
PackageTableEntry *std_package;
@@ -1341,7 +1341,7 @@ struct VariableTableEntry {
AstNode *decl_node;
// which node contains the ConstExprValue for this variable's value
AstNode *val_node;
- LLVMZigDILocalVariable *di_loc_var;
+ ZigLLVMDILocalVariable *di_loc_var;
int src_arg_index;
int gen_arg_index;
BlockContext *block_context;
@@ -1383,7 +1383,7 @@ struct BlockContext {
// it would pertain to
AstNode *parent_loop_node;
- LLVMZigDIScope *di_scope;
+ ZigLLVMDIScope *di_scope;
Buf *c_import_buf;
// if this is true, then this code will not be generated
src/analyze.cpp
@@ -312,7 +312,7 @@ TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
assert(child_type->di_type);
- entry->di_type = LLVMZigCreateDebugPointerType(g->dbuilder, child_type->di_type,
+ entry->di_type = ZigLLVMCreateDebugPointerType(g->dbuilder, child_type->di_type,
debug_size_in_bits, debug_align_in_bits, buf_ptr(&entry->name));
}
@@ -355,11 +355,11 @@ TypeTableEntry *get_maybe_type(CodeGen *g, TypeTableEntry *child_type) {
entry->type_ref = LLVMStructType(elem_types, 2, false);
- LLVMZigDIScope *compile_unit_scope = LLVMZigCompileUnitToScope(g->compile_unit);
- LLVMZigDIFile *di_file = nullptr;
+ ZigLLVMDIScope *compile_unit_scope = ZigLLVMCompileUnitToScope(g->compile_unit);
+ ZigLLVMDIFile *di_file = nullptr;
unsigned line = 0;
- entry->di_type = LLVMZigCreateReplaceableCompositeType(g->dbuilder,
- LLVMZigTag_DW_structure_type(), buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateReplaceableCompositeType(g->dbuilder,
+ ZigLLVMTag_DW_structure_type(), buf_ptr(&entry->name),
compile_unit_scope, di_file, line);
uint64_t val_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, child_type->type_ref);
@@ -374,27 +374,27 @@ TypeTableEntry *get_maybe_type(CodeGen *g, TypeTableEntry *child_type) {
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- LLVMZigDIType *di_element_types[] = {
- LLVMZigCreateDebugMemberType(g->dbuilder, LLVMZigTypeToScope(entry->di_type),
+ ZigLLVMDIType *di_element_types[] = {
+ ZigLLVMCreateDebugMemberType(g->dbuilder, ZigLLVMTypeToScope(entry->di_type),
"val", di_file, line,
val_debug_size_in_bits,
val_debug_align_in_bits,
val_offset_in_bits,
0, child_type->di_type),
- LLVMZigCreateDebugMemberType(g->dbuilder, LLVMZigTypeToScope(entry->di_type),
+ ZigLLVMCreateDebugMemberType(g->dbuilder, ZigLLVMTypeToScope(entry->di_type),
"maybe", di_file, line,
maybe_debug_size_in_bits,
maybe_debug_align_in_bits,
maybe_offset_in_bits,
0, child_type->di_type),
};
- LLVMZigDIType *replacement_di_type = LLVMZigCreateDebugStructType(g->dbuilder,
+ ZigLLVMDIType *replacement_di_type = ZigLLVMCreateDebugStructType(g->dbuilder,
compile_unit_scope,
buf_ptr(&entry->name),
di_file, line, debug_size_in_bits, debug_align_in_bits, 0,
nullptr, di_element_types, 2, 0, nullptr, "");
- LLVMZigReplaceTemporary(g->dbuilder, entry->di_type, replacement_di_type);
+ ZigLLVMReplaceTemporary(g->dbuilder, entry->di_type, replacement_di_type);
entry->di_type = replacement_di_type;
}
@@ -431,11 +431,11 @@ static TypeTableEntry *get_error_type(CodeGen *g, TypeTableEntry *child_type) {
};
entry->type_ref = LLVMStructType(elem_types, 2, false);
- LLVMZigDIScope *compile_unit_scope = LLVMZigCompileUnitToScope(g->compile_unit);
- LLVMZigDIFile *di_file = nullptr;
+ ZigLLVMDIScope *compile_unit_scope = ZigLLVMCompileUnitToScope(g->compile_unit);
+ ZigLLVMDIFile *di_file = nullptr;
unsigned line = 0;
- entry->di_type = LLVMZigCreateReplaceableCompositeType(g->dbuilder,
- LLVMZigTag_DW_structure_type(), buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateReplaceableCompositeType(g->dbuilder,
+ ZigLLVMTag_DW_structure_type(), buf_ptr(&entry->name),
compile_unit_scope, di_file, line);
uint64_t tag_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, g->err_tag_type->type_ref);
@@ -449,14 +449,14 @@ static TypeTableEntry *get_error_type(CodeGen *g, TypeTableEntry *child_type) {
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- LLVMZigDIType *di_element_types[] = {
- LLVMZigCreateDebugMemberType(g->dbuilder, LLVMZigTypeToScope(entry->di_type),
+ ZigLLVMDIType *di_element_types[] = {
+ ZigLLVMCreateDebugMemberType(g->dbuilder, ZigLLVMTypeToScope(entry->di_type),
"tag", di_file, line,
tag_debug_size_in_bits,
tag_debug_align_in_bits,
tag_offset_in_bits,
0, child_type->di_type),
- LLVMZigCreateDebugMemberType(g->dbuilder, LLVMZigTypeToScope(entry->di_type),
+ ZigLLVMCreateDebugMemberType(g->dbuilder, ZigLLVMTypeToScope(entry->di_type),
"value", di_file, line,
value_debug_size_in_bits,
value_debug_align_in_bits,
@@ -464,7 +464,7 @@ static TypeTableEntry *get_error_type(CodeGen *g, TypeTableEntry *child_type) {
0, child_type->di_type),
};
- LLVMZigDIType *replacement_di_type = LLVMZigCreateDebugStructType(g->dbuilder,
+ ZigLLVMDIType *replacement_di_type = ZigLLVMCreateDebugStructType(g->dbuilder,
compile_unit_scope,
buf_ptr(&entry->name),
di_file, line,
@@ -473,7 +473,7 @@ static TypeTableEntry *get_error_type(CodeGen *g, TypeTableEntry *child_type) {
0,
nullptr, di_element_types, 2, 0, nullptr, "");
- LLVMZigReplaceTemporary(g->dbuilder, entry->di_type, replacement_di_type);
+ ZigLLVMReplaceTemporary(g->dbuilder, entry->di_type, replacement_di_type);
entry->di_type = replacement_di_type;
}
@@ -500,7 +500,7 @@ TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, uint64_t
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- entry->di_type = LLVMZigCreateDebugArrayType(g->dbuilder, debug_size_in_bits,
+ entry->di_type = ZigLLVMCreateDebugArrayType(g->dbuilder, debug_size_in_bits,
debug_align_in_bits, child_type->di_type, array_size);
}
entry->data.array.child_type = child_type;
@@ -562,11 +562,11 @@ TypeTableEntry *get_slice_type(CodeGen *g, TypeTableEntry *child_type, bool is_c
buf_appendf(&entry->name, "[]%s", buf_ptr(&child_type->name));
entry->type_ref = LLVMStructCreateNamed(LLVMGetGlobalContext(), buf_ptr(&entry->name));
- LLVMZigDIScope *compile_unit_scope = LLVMZigCompileUnitToScope(g->compile_unit);
- LLVMZigDIFile *di_file = nullptr;
+ ZigLLVMDIScope *compile_unit_scope = ZigLLVMCompileUnitToScope(g->compile_unit);
+ ZigLLVMDIFile *di_file = nullptr;
unsigned line = 0;
- entry->di_type = LLVMZigCreateReplaceableCompositeType(g->dbuilder,
- LLVMZigTag_DW_structure_type(), buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateReplaceableCompositeType(g->dbuilder,
+ ZigLLVMTag_DW_structure_type(), buf_ptr(&entry->name),
compile_unit_scope, di_file, line);
if (child_type->zero_bits) {
@@ -589,21 +589,21 @@ TypeTableEntry *get_slice_type(CodeGen *g, TypeTableEntry *child_type, bool is_c
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- LLVMZigDIType *di_element_types[] = {
- LLVMZigCreateDebugMemberType(g->dbuilder, LLVMZigTypeToScope(entry->di_type),
+ ZigLLVMDIType *di_element_types[] = {
+ ZigLLVMCreateDebugMemberType(g->dbuilder, ZigLLVMTypeToScope(entry->di_type),
"len", di_file, line,
len_debug_size_in_bits,
len_debug_align_in_bits,
len_offset_in_bits,
0, usize_type->di_type),
};
- LLVMZigDIType *replacement_di_type = LLVMZigCreateDebugStructType(g->dbuilder,
+ ZigLLVMDIType *replacement_di_type = ZigLLVMCreateDebugStructType(g->dbuilder,
compile_unit_scope,
buf_ptr(&entry->name),
di_file, line, debug_size_in_bits, debug_align_in_bits, 0,
nullptr, di_element_types, 1, 0, nullptr, "");
- LLVMZigReplaceTemporary(g->dbuilder, entry->di_type, replacement_di_type);
+ ZigLLVMReplaceTemporary(g->dbuilder, entry->di_type, replacement_di_type);
entry->di_type = replacement_di_type;
} else {
TypeTableEntry *pointer_type = get_pointer_to_type(g, child_type, is_const);
@@ -630,27 +630,27 @@ TypeTableEntry *get_slice_type(CodeGen *g, TypeTableEntry *child_type, bool is_c
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- LLVMZigDIType *di_element_types[] = {
- LLVMZigCreateDebugMemberType(g->dbuilder, LLVMZigTypeToScope(entry->di_type),
+ ZigLLVMDIType *di_element_types[] = {
+ ZigLLVMCreateDebugMemberType(g->dbuilder, ZigLLVMTypeToScope(entry->di_type),
"ptr", di_file, line,
ptr_debug_size_in_bits,
ptr_debug_align_in_bits,
ptr_offset_in_bits,
0, pointer_type->di_type),
- LLVMZigCreateDebugMemberType(g->dbuilder, LLVMZigTypeToScope(entry->di_type),
+ ZigLLVMCreateDebugMemberType(g->dbuilder, ZigLLVMTypeToScope(entry->di_type),
"len", di_file, line,
len_debug_size_in_bits,
len_debug_align_in_bits,
len_offset_in_bits,
0, usize_type->di_type),
};
- LLVMZigDIType *replacement_di_type = LLVMZigCreateDebugStructType(g->dbuilder,
+ ZigLLVMDIType *replacement_di_type = ZigLLVMCreateDebugStructType(g->dbuilder,
compile_unit_scope,
buf_ptr(&entry->name),
di_file, line, debug_size_in_bits, debug_align_in_bits, 0,
nullptr, di_element_types, 2, 0, nullptr, "");
- LLVMZigReplaceTemporary(g->dbuilder, entry->di_type, replacement_di_type);
+ ZigLLVMReplaceTemporary(g->dbuilder, entry->di_type, replacement_di_type);
entry->di_type = replacement_di_type;
}
@@ -736,7 +736,7 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id, bool gen_debug_inf
// +1 for maybe making the first argument the return value
LLVMTypeRef *gen_param_types = allocate<LLVMTypeRef>(1 + fn_type_id->param_count);
// +1 because 0 is the return type and +1 for maybe making first arg ret val
- LLVMZigDIType **param_di_types = allocate<LLVMZigDIType*>(2 + fn_type_id->param_count);
+ ZigLLVMDIType **param_di_types = allocate<ZigLLVMDIType*>(2 + fn_type_id->param_count);
param_di_types[0] = fn_type_id->return_type->di_type;
int gen_param_index = 0;
TypeTableEntry *gen_return_type;
@@ -788,7 +788,7 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id, bool gen_debug_inf
fn_type->data.fn.raw_type_ref = LLVMFunctionType(gen_return_type->type_ref,
gen_param_types, gen_param_index, fn_type_id->is_var_args);
fn_type->type_ref = LLVMPointerType(fn_type->data.fn.raw_type_ref, 0);
- fn_type->di_type = LLVMZigCreateSubroutineType(g->dbuilder, param_di_types, gen_param_index + 1, 0);
+ fn_type->di_type = ZigLLVMCreateSubroutineType(g->dbuilder, param_di_types, gen_param_index + 1, 0);
}
g->fn_type_table.put(&fn_type->data.fn.fn_type_id, fn_type);
@@ -829,9 +829,9 @@ TypeTableEntry *get_partial_container_type(CodeGen *g, ImportTableEntry *import,
unsigned line = decl_node ? decl_node->line : 0;
entry->type_ref = LLVMStructCreateNamed(LLVMGetGlobalContext(), name);
- entry->di_type = LLVMZigCreateReplaceableCompositeType(g->dbuilder,
- LLVMZigTag_DW_structure_type(), name,
- LLVMZigFileToScope(import->di_file), import->di_file, line + 1);
+ entry->di_type = ZigLLVMCreateReplaceableCompositeType(g->dbuilder,
+ ZigLLVMTag_DW_structure_type(), name,
+ ZigLLVMFileToScope(import->di_file), import->di_file, line + 1);
buf_init_from_str(&entry->name, name);
@@ -1262,13 +1262,13 @@ static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_t
bool is_definition = fn_table_entry->fn_def_node != nullptr;
unsigned flags = 0;
bool is_optimized = g->is_release_build;
- LLVMZigDISubprogram *subprogram = LLVMZigCreateFunction(g->dbuilder,
+ ZigLLVMDISubprogram *subprogram = ZigLLVMCreateFunction(g->dbuilder,
containing_context->di_scope, buf_ptr(&fn_table_entry->symbol_name), "",
import->di_file, line_number,
fn_type->di_type, fn_table_entry->internal_linkage,
is_definition, scope_line, flags, is_optimized, nullptr);
- fn_table_entry->fn_def_node->data.fn_def.block_context->di_scope = LLVMZigSubprogramToScope(subprogram);
+ fn_table_entry->fn_def_node->data.fn_def.block_context->di_scope = ZigLLVMSubprogramToScope(subprogram);
ZigLLVMFnSetSubprogram(fn_table_entry->fn_value, subprogram);
}
}
@@ -1302,11 +1302,11 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
enum_type->data.enumeration.field_count = field_count;
enum_type->data.enumeration.fields = allocate<TypeEnumField>(field_count);
- LLVMZigDIEnumerator **di_enumerators = allocate<LLVMZigDIEnumerator*>(field_count);
+ ZigLLVMDIEnumerator **di_enumerators = allocate<ZigLLVMDIEnumerator*>(field_count);
// we possibly allocate too much here since gen_field_count can be lower than field_count.
// the only problem is potential wasted space though.
- LLVMZigDIType **union_inner_di_types = allocate<LLVMZigDIType*>(field_count);
+ ZigLLVMDIType **union_inner_di_types = allocate<ZigLLVMDIType*>(field_count);
TypeTableEntry *biggest_union_member = nullptr;
uint64_t biggest_align_in_bits = 0;
@@ -1332,7 +1332,7 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
}
- di_enumerators[i] = LLVMZigCreateDebugEnumerator(g->dbuilder, buf_ptr(type_enum_field->name), i);
+ di_enumerators[i] = ZigLLVMCreateDebugEnumerator(g->dbuilder, buf_ptr(type_enum_field->name), i);
if (field_type->id == TypeTableEntryIdStruct) {
resolve_struct_type(g, import, field_type);
@@ -1348,8 +1348,8 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, field_type->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, field_type->type_ref);
- union_inner_di_types[gen_field_index] = LLVMZigCreateDebugMemberType(g->dbuilder,
- LLVMZigTypeToScope(enum_type->di_type), buf_ptr(type_enum_field->name),
+ union_inner_di_types[gen_field_index] = ZigLLVMCreateDebugMemberType(g->dbuilder,
+ ZigLLVMTypeToScope(enum_type->di_type), buf_ptr(type_enum_field->name),
import->di_file, field_node->line + 1,
debug_size_in_bits,
debug_align_in_bits,
@@ -1394,21 +1394,21 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
// create debug type for tag
uint64_t tag_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, tag_type_entry->type_ref);
uint64_t tag_debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, tag_type_entry->type_ref);
- LLVMZigDIType *tag_di_type = LLVMZigCreateDebugEnumerationType(g->dbuilder,
- LLVMZigTypeToScope(enum_type->di_type), "AnonEnum", import->di_file, decl_node->line + 1,
+ ZigLLVMDIType *tag_di_type = ZigLLVMCreateDebugEnumerationType(g->dbuilder,
+ ZigLLVMTypeToScope(enum_type->di_type), "AnonEnum", import->di_file, decl_node->line + 1,
tag_debug_size_in_bits, tag_debug_align_in_bits, di_enumerators, field_count,
tag_type_entry->di_type, "");
// create debug type for union
- LLVMZigDIType *union_di_type = LLVMZigCreateDebugUnionType(g->dbuilder,
- LLVMZigTypeToScope(enum_type->di_type), "AnonUnion", import->di_file, decl_node->line + 1,
+ ZigLLVMDIType *union_di_type = ZigLLVMCreateDebugUnionType(g->dbuilder,
+ ZigLLVMTypeToScope(enum_type->di_type), "AnonUnion", import->di_file, decl_node->line + 1,
biggest_union_member_size_in_bits, biggest_align_in_bits, 0, union_inner_di_types,
gen_field_index, 0, "");
// create debug types for members of root struct
uint64_t tag_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, enum_type->type_ref, 0);
- LLVMZigDIType *tag_member_di_type = LLVMZigCreateDebugMemberType(g->dbuilder,
- LLVMZigTypeToScope(enum_type->di_type), "tag_field",
+ ZigLLVMDIType *tag_member_di_type = ZigLLVMCreateDebugMemberType(g->dbuilder,
+ ZigLLVMTypeToScope(enum_type->di_type), "tag_field",
import->di_file, decl_node->line + 1,
tag_debug_size_in_bits,
tag_debug_align_in_bits,
@@ -1416,8 +1416,8 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
0, tag_di_type);
uint64_t union_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, enum_type->type_ref, 1);
- LLVMZigDIType *union_member_di_type = LLVMZigCreateDebugMemberType(g->dbuilder,
- LLVMZigTypeToScope(enum_type->di_type), "union_field",
+ ZigLLVMDIType *union_member_di_type = ZigLLVMCreateDebugMemberType(g->dbuilder,
+ ZigLLVMTypeToScope(enum_type->di_type), "union_field",
import->di_file, decl_node->line + 1,
biggest_union_member_size_in_bits,
biggest_align_in_bits,
@@ -1425,7 +1425,7 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
0, union_di_type);
// create debug type for root struct
- LLVMZigDIType *di_root_members[] = {
+ ZigLLVMDIType *di_root_members[] = {
tag_member_di_type,
union_member_di_type,
};
@@ -1433,15 +1433,15 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, enum_type->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, enum_type->type_ref);
- LLVMZigDIType *replacement_di_type = LLVMZigCreateDebugStructType(g->dbuilder,
- LLVMZigFileToScope(import->di_file),
+ ZigLLVMDIType *replacement_di_type = ZigLLVMCreateDebugStructType(g->dbuilder,
+ ZigLLVMFileToScope(import->di_file),
buf_ptr(decl_node->data.struct_decl.name),
import->di_file, decl_node->line + 1,
debug_size_in_bits,
debug_align_in_bits,
0, nullptr, di_root_members, 2, 0, nullptr, "");
- LLVMZigReplaceTemporary(g->dbuilder, enum_type->di_type, replacement_di_type);
+ ZigLLVMReplaceTemporary(g->dbuilder, enum_type->di_type, replacement_di_type);
enum_type->di_type = replacement_di_type;
} else {
// create llvm type for root struct
@@ -1450,15 +1450,15 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
// create debug type for tag
uint64_t tag_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, tag_type_entry->type_ref);
uint64_t tag_debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, tag_type_entry->type_ref);
- LLVMZigDIType *tag_di_type = LLVMZigCreateDebugEnumerationType(g->dbuilder,
- LLVMZigFileToScope(import->di_file), buf_ptr(decl_node->data.struct_decl.name),
+ ZigLLVMDIType *tag_di_type = ZigLLVMCreateDebugEnumerationType(g->dbuilder,
+ ZigLLVMFileToScope(import->di_file), buf_ptr(decl_node->data.struct_decl.name),
import->di_file, decl_node->line + 1,
tag_debug_size_in_bits,
tag_debug_align_in_bits,
di_enumerators, field_count,
tag_type_entry->di_type, "");
- LLVMZigReplaceTemporary(g->dbuilder, enum_type->di_type, tag_di_type);
+ ZigLLVMReplaceTemporary(g->dbuilder, enum_type->di_type, tag_di_type);
enum_type->di_type = tag_di_type;
}
@@ -1552,7 +1552,7 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE
int gen_field_count = gen_field_index;
LLVMStructSetBody(struct_type->type_ref, element_types, gen_field_count, false);
- LLVMZigDIType **di_element_types = allocate<LLVMZigDIType*>(gen_field_count);
+ ZigLLVMDIType **di_element_types = allocate<ZigLLVMDIType*>(gen_field_count);
for (int i = 0; i < field_count; i += 1) {
AstNode *field_node = decl_node->data.struct_decl.fields.at(i);
@@ -1568,8 +1568,8 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, field_type->type_ref);
uint64_t debug_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, struct_type->type_ref,
gen_field_index);
- di_element_types[gen_field_index] = LLVMZigCreateDebugMemberType(g->dbuilder,
- LLVMZigTypeToScope(struct_type->di_type), buf_ptr(type_struct_field->name),
+ di_element_types[gen_field_index] = ZigLLVMCreateDebugMemberType(g->dbuilder,
+ ZigLLVMTypeToScope(struct_type->di_type), buf_ptr(type_struct_field->name),
import->di_file, field_node->line + 1,
debug_size_in_bits,
debug_align_in_bits,
@@ -1582,15 +1582,15 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, struct_type->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, struct_type->type_ref);
- LLVMZigDIType *replacement_di_type = LLVMZigCreateDebugStructType(g->dbuilder,
- LLVMZigFileToScope(import->di_file),
+ ZigLLVMDIType *replacement_di_type = ZigLLVMCreateDebugStructType(g->dbuilder,
+ ZigLLVMFileToScope(import->di_file),
buf_ptr(decl_node->data.struct_decl.name),
import->di_file, decl_node->line + 1,
debug_size_in_bits,
debug_align_in_bits,
0, nullptr, di_element_types, gen_field_count, 0, nullptr, "");
- LLVMZigReplaceTemporary(g->dbuilder, struct_type->di_type, replacement_di_type);
+ ZigLLVMReplaceTemporary(g->dbuilder, struct_type->di_type, replacement_di_type);
struct_type->di_type = replacement_di_type;
struct_type->zero_bits = (debug_size_in_bits == 0);
@@ -7059,12 +7059,12 @@ ImportTableEntry *add_source_file(CodeGen *g, PackageTableEntry *package,
//ast_render(stderr, import_entry->root, 4);
}
- import_entry->di_file = LLVMZigCreateFile(g->dbuilder, buf_ptr(src_basename), buf_ptr(src_dirname));
+ import_entry->di_file = ZigLLVMCreateFile(g->dbuilder, buf_ptr(src_basename), buf_ptr(src_dirname));
g->import_table.put(abs_full_path, import_entry);
g->import_queue.append(import_entry);
import_entry->block_context = new_block_context(import_entry->root, nullptr);
- import_entry->block_context->di_scope = LLVMZigFileToScope(import_entry->di_file);
+ import_entry->block_context->di_scope = ZigLLVMFileToScope(import_entry->di_file);
assert(import_entry->root->type == NodeTypeRoot);
src/codegen.cpp
@@ -1144,7 +1144,7 @@ static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) {
}
set_debug_source_node(g, node);
- LLVMValueRef result = LLVMZigBuildCall(g->builder, fn_val,
+ LLVMValueRef result = ZigLLVMBuildCall(g->builder, fn_val,
gen_param_values, gen_param_index, fn_type->data.fn.calling_convention, "");
if (src_return_type->id == TypeTableEntryIdUnreachable) {
@@ -2631,9 +2631,9 @@ static LLVMValueRef gen_if_bool_expr(CodeGen *g, AstNode *node) {
static void gen_var_debug_decl(CodeGen *g, VariableTableEntry *var) {
BlockContext *block_context = var->block_context;
AstNode *source_node = var->decl_node;
- LLVMZigDILocation *debug_loc = LLVMZigGetDebugLoc(source_node->line + 1, source_node->column + 1,
+ ZigLLVMDILocation *debug_loc = ZigLLVMGetDebugLoc(source_node->line + 1, source_node->column + 1,
block_context->di_scope);
- LLVMZigInsertDeclareAtEnd(g->dbuilder, var->value_ref, var->di_loc_var, debug_loc,
+ ZigLLVMInsertDeclareAtEnd(g->dbuilder, var->value_ref, var->di_loc_var, debug_loc,
LLVMGetInsertBlock(g->builder));
}
@@ -3963,7 +3963,7 @@ static void gen_global_var(CodeGen *g, VariableTableEntry *var, LLVMValueRef ini
assert(var->import);
assert(type_entry);
bool is_local_to_unit = true;
- LLVMZigCreateGlobalVariable(g->dbuilder,
+ ZigLLVMCreateGlobalVariable(g->dbuilder,
var->block_context->di_scope, buf_ptr(&var->name),
buf_ptr(&var->name), var->import->di_file, var->decl_node->line + 1,
type_entry->di_type, is_local_to_unit, init_val);
@@ -4073,13 +4073,13 @@ static void do_code_gen(CodeGen *g) {
if (!type_has_bits(fn_type->data.fn.fn_type_id.return_type)) {
// nothing to do
} else if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdPointer) {
- LLVMZigAddNonNullAttr(fn_table_entry->fn_value, 0);
+ ZigLLVMAddNonNullAttr(fn_table_entry->fn_value, 0);
} else if (handle_is_ptr(fn_type->data.fn.fn_type_id.return_type) &&
!fn_type->data.fn.fn_type_id.is_extern)
{
LLVMValueRef first_arg = LLVMGetParam(fn_table_entry->fn_value, 0);
LLVMAddAttribute(first_arg, LLVMStructRetAttribute);
- LLVMZigAddNonNullAttr(fn_table_entry->fn_value, 1);
+ ZigLLVMAddNonNullAttr(fn_table_entry->fn_value, 1);
is_sret = true;
}
if (fn_table_entry->is_pure && !is_sret && g->is_release_build) {
@@ -4112,7 +4112,7 @@ static void do_code_gen(CodeGen *g) {
LLVMAddAttribute(argument_val, LLVMReadOnlyAttribute);
}
if (param_type->id == TypeTableEntryIdPointer) {
- LLVMZigAddNonNullAttr(fn_table_entry->fn_value, gen_index + 1);
+ ZigLLVMAddNonNullAttr(fn_table_entry->fn_value, gen_index + 1);
}
if (is_byval) {
// TODO
@@ -4189,12 +4189,12 @@ static void do_code_gen(CodeGen *g) {
BlockContext *block_context = fn_table_entry->all_block_contexts.at(bc_i);
if (!block_context->di_scope) {
- LLVMZigDILexicalBlock *di_block = LLVMZigCreateLexicalBlock(g->dbuilder,
+ ZigLLVMDILexicalBlock *di_block = ZigLLVMCreateLexicalBlock(g->dbuilder,
block_context->parent->di_scope,
import->di_file,
block_context->node->line + 1,
block_context->node->column + 1);
- block_context->di_scope = LLVMZigLexicalBlockToScope(di_block);
+ block_context->di_scope = ZigLLVMLexicalBlockToScope(di_block);
}
@@ -4237,7 +4237,7 @@ static void do_code_gen(CodeGen *g) {
unsigned align_bytes = ZigLLVMGetPrefTypeAlignment(g->target_data_ref, var->type->type_ref);
LLVMSetAlignment(var->value_ref, align_bytes);
}
- var->di_loc_var = LLVMZigCreateParameterVariable(g->dbuilder, var->block_context->di_scope,
+ var->di_loc_var = ZigLLVMCreateParameterVariable(g->dbuilder, var->block_context->di_scope,
buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
gen_type->di_type, !g->strip_debug_symbols, 0, var->gen_arg_index + 1);
@@ -4248,7 +4248,7 @@ static void do_code_gen(CodeGen *g) {
unsigned align_bytes = ZigLLVMGetPrefTypeAlignment(g->target_data_ref, var->type->type_ref);
LLVMSetAlignment(var->value_ref, align_bytes);
- var->di_loc_var = LLVMZigCreateAutoVariable(g->dbuilder, var->block_context->di_scope,
+ var->di_loc_var = ZigLLVMCreateAutoVariable(g->dbuilder, var->block_context->di_scope,
buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
var->type->di_type, !g->strip_debug_symbols, 0);
}
@@ -4283,7 +4283,7 @@ static void do_code_gen(CodeGen *g) {
}
assert(!g->errors.length);
- LLVMZigDIBuilderFinalize(g->dbuilder);
+ ZigLLVMDIBuilderFinalize(g->dbuilder);
if (g->verbose) {
LLVMDumpModule(g->module);
@@ -4387,21 +4387,21 @@ static void define_builtin_types(CodeGen *g) {
unsigned dwarf_tag;
if (is_signed) {
if (size_in_bits == 8) {
- dwarf_tag = LLVMZigEncoding_DW_ATE_signed_char();
+ dwarf_tag = ZigLLVMEncoding_DW_ATE_signed_char();
} else {
- dwarf_tag = LLVMZigEncoding_DW_ATE_signed();
+ dwarf_tag = ZigLLVMEncoding_DW_ATE_signed();
}
} else {
if (size_in_bits == 8) {
- dwarf_tag = LLVMZigEncoding_DW_ATE_unsigned_char();
+ dwarf_tag = ZigLLVMEncoding_DW_ATE_unsigned_char();
} else {
- dwarf_tag = LLVMZigEncoding_DW_ATE_unsigned();
+ dwarf_tag = ZigLLVMEncoding_DW_ATE_unsigned();
}
}
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits, debug_align_in_bits, dwarf_tag);
entry->data.integral.is_signed = is_signed;
entry->data.integral.bit_count = size_in_bits;
@@ -4424,10 +4424,10 @@ static void define_builtin_types(CodeGen *g) {
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits,
debug_align_in_bits,
- is_signed ? LLVMZigEncoding_DW_ATE_signed() : LLVMZigEncoding_DW_ATE_unsigned());
+ is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned());
entry->data.integral.is_signed = is_signed;
entry->data.integral.bit_count = size_in_bits;
g->primitive_type_table.put(&entry->name, entry);
@@ -4442,10 +4442,10 @@ static void define_builtin_types(CodeGen *g) {
buf_init_from_str(&entry->name, "bool");
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits,
debug_align_in_bits,
- LLVMZigEncoding_DW_ATE_boolean());
+ ZigLLVMEncoding_DW_ATE_boolean());
g->builtin_types.entry_bool = entry;
g->primitive_type_table.put(&entry->name, entry);
}
@@ -4466,10 +4466,10 @@ static void define_builtin_types(CodeGen *g) {
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits,
debug_align_in_bits,
- is_signed ? LLVMZigEncoding_DW_ATE_signed() : LLVMZigEncoding_DW_ATE_unsigned());
+ is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned());
g->primitive_type_table.put(&entry->name, entry);
if (is_signed) {
@@ -4487,10 +4487,10 @@ static void define_builtin_types(CodeGen *g) {
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits,
debug_align_in_bits,
- LLVMZigEncoding_DW_ATE_float());
+ ZigLLVMEncoding_DW_ATE_float());
g->builtin_types.entry_f32 = entry;
g->primitive_type_table.put(&entry->name, entry);
}
@@ -4503,10 +4503,10 @@ static void define_builtin_types(CodeGen *g) {
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits,
debug_align_in_bits,
- LLVMZigEncoding_DW_ATE_float());
+ ZigLLVMEncoding_DW_ATE_float());
g->builtin_types.entry_f64 = entry;
g->primitive_type_table.put(&entry->name, entry);
}
@@ -4519,10 +4519,10 @@ static void define_builtin_types(CodeGen *g) {
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
- entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits,
debug_align_in_bits,
- LLVMZigEncoding_DW_ATE_float());
+ ZigLLVMEncoding_DW_ATE_float());
g->builtin_types.entry_c_long_double = entry;
g->primitive_type_table.put(&entry->name, entry);
}
@@ -4532,10 +4532,10 @@ static void define_builtin_types(CodeGen *g) {
entry->type_ref = LLVMVoidType();
entry->zero_bits = true;
buf_init_from_str(&entry->name, "void");
- entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+ entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
0,
0,
- LLVMZigEncoding_DW_ATE_unsigned());
+ ZigLLVMEncoding_DW_ATE_unsigned());
g->builtin_types.entry_void = entry;
g->primitive_type_table.put(&entry->name, entry);
}
@@ -4884,8 +4884,8 @@ static void init(CodeGen *g, Buf *source_path) {
const char *target_specific_cpu_args;
const char *target_specific_features;
if (g->is_native_target) {
- target_specific_cpu_args = LLVMZigGetHostCPUName();
- target_specific_features = LLVMZigGetNativeFeatures();
+ target_specific_cpu_args = ZigLLVMGetHostCPUName();
+ target_specific_features = ZigLLVMGetNativeFeatures();
} else {
target_specific_cpu_args = "";
target_specific_features = "";
@@ -4904,16 +4904,16 @@ static void init(CodeGen *g, Buf *source_path) {
g->is_big_endian = (LLVMByteOrder(g->target_data_ref) == LLVMBigEndian);
g->builder = LLVMCreateBuilder();
- g->dbuilder = LLVMZigCreateDIBuilder(g->module, true);
+ g->dbuilder = ZigLLVMCreateDIBuilder(g->module, true);
- LLVMZigSetFastMath(g->builder, true);
+ ZigLLVMSetFastMath(g->builder, true);
Buf *producer = buf_sprintf("zig %s", ZIG_VERSION_STRING);
bool is_optimized = g->is_release_build;
const char *flags = "";
unsigned runtime_version = 0;
- g->compile_unit = LLVMZigCreateCompileUnit(g->dbuilder, LLVMZigLang_DW_LANG_C99(),
+ g->compile_unit = ZigLLVMCreateCompileUnit(g->dbuilder, ZigLLVMLang_DW_LANG_C99(),
buf_ptr(source_path), buf_ptr(&g->root_package->root_src_dir),
buf_ptr(producer), is_optimized, flags, runtime_version,
"", 0, !g->strip_debug_symbols);
@@ -4938,7 +4938,7 @@ void codegen_parseh(CodeGen *g, Buf *src_dirname, Buf *src_basename, Buf *source
init(g, full_path);
- import->di_file = LLVMZigCreateFile(g->dbuilder, buf_ptr(src_basename), buf_ptr(src_dirname));
+ import->di_file = ZigLLVMCreateFile(g->dbuilder, buf_ptr(src_basename), buf_ptr(src_dirname));
ZigList<ErrorMsg *> errors = {0};
int err = parse_h_buf(import, &errors, source_code, g, nullptr);
src/link.cpp
@@ -763,7 +763,7 @@ void codegen_link(CodeGen *g, const char *out_file) {
fprintf(stderr, "---------------\n");
}
- LLVMZigOptimizeModule(g->target_machine, g->module);
+ ZigLLVMOptimizeModule(g->target_machine, g->module);
if (g->verbose) {
LLVMDumpModule(g->module);
src/parseh.cpp
@@ -808,11 +808,11 @@ static void add_alias(Context *c, const char *new_name, const char *target_name)
static void replace_with_fwd_decl(Context *c, TypeTableEntry *struct_type, Buf *full_type_name) {
unsigned line = c->source_node ? c->source_node->line : 0;
- LLVMZigDIType *replacement_di_type = LLVMZigCreateDebugForwardDeclType(c->codegen->dbuilder,
- LLVMZigTag_DW_structure_type(), buf_ptr(full_type_name),
- LLVMZigFileToScope(c->import->di_file), c->import->di_file, line);
+ ZigLLVMDIType *replacement_di_type = ZigLLVMCreateDebugForwardDeclType(c->codegen->dbuilder,
+ ZigLLVMTag_DW_structure_type(), buf_ptr(full_type_name),
+ ZigLLVMFileToScope(c->import->di_file), c->import->di_file, line);
- LLVMZigReplaceTemporary(c->codegen->dbuilder, struct_type->di_type, replacement_di_type);
+ ZigLLVMReplaceTemporary(c->codegen->dbuilder, struct_type->di_type, replacement_di_type);
struct_type->di_type = replacement_di_type;
}
@@ -872,7 +872,7 @@ static TypeTableEntry *resolve_enum_decl(Context *c, const EnumDecl *enum_decl)
enum_type->data.enumeration.field_count = field_count;
enum_type->data.enumeration.fields = allocate<TypeEnumField>(field_count);
- LLVMZigDIEnumerator **di_enumerators = allocate<LLVMZigDIEnumerator*>(field_count);
+ ZigLLVMDIEnumerator **di_enumerators = allocate<ZigLLVMDIEnumerator*>(field_count);
uint32_t i = 0;
for (auto it = enum_def->enumerator_begin(),
@@ -894,7 +894,7 @@ static TypeTableEntry *resolve_enum_decl(Context *c, const EnumDecl *enum_decl)
type_enum_field->type_entry = c->codegen->builtin_types.entry_void;
type_enum_field->value = i;
- di_enumerators[i] = LLVMZigCreateDebugEnumerator(c->codegen->dbuilder, buf_ptr(type_enum_field->name), i);
+ di_enumerators[i] = ZigLLVMCreateDebugEnumerator(c->codegen->dbuilder, buf_ptr(type_enum_field->name), i);
// in C each enum value is in the global namespace. so we put them there too.
@@ -913,14 +913,14 @@ static TypeTableEntry *resolve_enum_decl(Context *c, const EnumDecl *enum_decl)
unsigned line = c->source_node ? (c->source_node->line + 1) : 0;
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(c->codegen->target_data_ref, enum_type->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(c->codegen->target_data_ref, enum_type->type_ref);
- LLVMZigDIType *tag_di_type = LLVMZigCreateDebugEnumerationType(c->codegen->dbuilder,
- LLVMZigFileToScope(c->import->di_file), buf_ptr(bare_name),
+ ZigLLVMDIType *tag_di_type = ZigLLVMCreateDebugEnumerationType(c->codegen->dbuilder,
+ ZigLLVMFileToScope(c->import->di_file), buf_ptr(bare_name),
c->import->di_file, line,
debug_size_in_bits,
debug_align_in_bits,
di_enumerators, field_count, tag_type_entry->di_type, "");
- LLVMZigReplaceTemporary(c->codegen->dbuilder, enum_type->di_type, tag_di_type);
+ ZigLLVMReplaceTemporary(c->codegen->dbuilder, enum_type->di_type, tag_di_type);
enum_type->di_type = tag_di_type;
return enum_type;
@@ -1053,7 +1053,7 @@ static TypeTableEntry *resolve_record_decl(Context *c, const RecordDecl *record_
struct_type->data.structure.src_field_count = field_count;
struct_type->data.structure.fields = allocate<TypeStructField>(field_count);
LLVMTypeRef *element_types = allocate<LLVMTypeRef>(field_count);
- LLVMZigDIType **di_element_types = allocate<LLVMZigDIType*>(field_count);
+ ZigLLVMDIType **di_element_types = allocate<ZigLLVMDIType*>(field_count);
// next, populate element_types as its needed for LLVMStructSetBody which is needed for LLVMOffsetOfElement
uint32_t i = 0;
@@ -1094,8 +1094,8 @@ static TypeTableEntry *resolve_record_decl(Context *c, const RecordDecl *record_
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(c->codegen->target_data_ref, field_type->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(c->codegen->target_data_ref, field_type->type_ref);
uint64_t debug_offset_in_bits = 8*LLVMOffsetOfElement(c->codegen->target_data_ref, struct_type->type_ref, i);
- di_element_types[i] = LLVMZigCreateDebugMemberType(c->codegen->dbuilder,
- LLVMZigTypeToScope(struct_type->di_type), buf_ptr(type_struct_field->name),
+ di_element_types[i] = ZigLLVMCreateDebugMemberType(c->codegen->dbuilder,
+ ZigLLVMTypeToScope(struct_type->di_type), buf_ptr(type_struct_field->name),
c->import->di_file, line + 1,
debug_size_in_bits,
debug_align_in_bits,
@@ -1112,15 +1112,15 @@ static TypeTableEntry *resolve_record_decl(Context *c, const RecordDecl *record_
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(c->codegen->target_data_ref, struct_type->type_ref);
uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(c->codegen->target_data_ref, struct_type->type_ref);
- LLVMZigDIType *replacement_di_type = LLVMZigCreateDebugStructType(c->codegen->dbuilder,
- LLVMZigFileToScope(c->import->di_file),
+ ZigLLVMDIType *replacement_di_type = ZigLLVMCreateDebugStructType(c->codegen->dbuilder,
+ ZigLLVMFileToScope(c->import->di_file),
buf_ptr(full_type_name), c->import->di_file, line + 1,
debug_size_in_bits,
debug_align_in_bits,
0,
nullptr, di_element_types, field_count, 0, nullptr, "");
- LLVMZigReplaceTemporary(c->codegen->dbuilder, struct_type->di_type, replacement_di_type);
+ ZigLLVMReplaceTemporary(c->codegen->dbuilder, struct_type->di_type, replacement_di_type);
struct_type->di_type = replacement_di_type;
return struct_type;
src/zig_llvm.cpp
@@ -44,20 +44,20 @@
using namespace llvm;
-void LLVMZigInitializeLoopStrengthReducePass(LLVMPassRegistryRef R) {
+void ZigLLVMInitializeLoopStrengthReducePass(LLVMPassRegistryRef R) {
initializeLoopStrengthReducePass(*unwrap(R));
}
-void LLVMZigInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R) {
+void ZigLLVMInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R) {
initializeLowerIntrinsicsPass(*unwrap(R));
}
-char *LLVMZigGetHostCPUName(void) {
+char *ZigLLVMGetHostCPUName(void) {
std::string str = sys::getHostCPUName();
return strdup(str.c_str());
}
-char *LLVMZigGetNativeFeatures(void) {
+char *ZigLLVMGetNativeFeatures(void) {
SubtargetFeatures features;
StringMap<bool> host_features;
@@ -74,7 +74,7 @@ static void addAddDiscriminatorsPass(const PassManagerBuilder &Builder, legacy::
}
-void LLVMZigOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref) {
+void ZigLLVMOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref) {
TargetMachine* target_machine = reinterpret_cast<TargetMachine*>(targ_machine_ref);
Module* module = unwrap(module_ref);
TargetLibraryInfoImpl tlii(Triple(module->getTargetTriple()));
@@ -129,7 +129,7 @@ void LLVMZigOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef
MPM->run(*module);
}
-LLVMValueRef LLVMZigBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
+LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
unsigned NumArgs, unsigned CC, const char *Name)
{
CallInst *call_inst = CallInst::Create(unwrap(Fn), makeArrayRef(unwrap(Args), NumArgs), Name);
@@ -137,7 +137,7 @@ LLVMValueRef LLVMZigBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *A
return wrap(unwrap(B)->Insert(call_inst));
}
-void LLVMZigAddNonNullAttr(LLVMValueRef fn, unsigned i)
+void ZigLLVMAddNonNullAttr(LLVMValueRef fn, unsigned i)
{
assert( isa<Function>(unwrap(fn)) );
@@ -146,31 +146,31 @@ void LLVMZigAddNonNullAttr(LLVMValueRef fn, unsigned i)
unwrapped_function->addAttribute(i, Attribute::NonNull);
}
-void ZigLLVMFnSetSubprogram(LLVMValueRef fn, LLVMZigDISubprogram *subprogram) {
+void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
assert( isa<Function>(unwrap(fn)) );
Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
unwrapped_function->setSubprogram(reinterpret_cast<DISubprogram*>(subprogram));
}
-LLVMZigDIType *LLVMZigCreateDebugPointerType(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *pointee_type,
+ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *pointee_type,
uint64_t size_in_bits, uint64_t align_in_bits, const char *name)
{
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createPointerType(
reinterpret_cast<DIType*>(pointee_type), size_in_bits, align_in_bits, name);
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-LLVMZigDIType *LLVMZigCreateDebugBasicType(LLVMZigDIBuilder *dibuilder, const char *name,
+ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name,
uint64_t size_in_bits, uint64_t align_in_bits, unsigned encoding)
{
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createBasicType(
name, size_in_bits, align_in_bits, encoding);
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-LLVMZigDIType *LLVMZigCreateDebugArrayType(LLVMZigDIBuilder *dibuilder, uint64_t size_in_bits,
- uint64_t align_in_bits, LLVMZigDIType *elem_type, int elem_count)
+ZigLLVMDIType *ZigLLVMCreateDebugArrayType(ZigLLVMDIBuilder *dibuilder, uint64_t size_in_bits,
+ uint64_t align_in_bits, ZigLLVMDIType *elem_type, int elem_count)
{
SmallVector<Metadata *, 1> subrange;
subrange.push_back(reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateSubrange(0, elem_count));
@@ -178,18 +178,18 @@ LLVMZigDIType *LLVMZigCreateDebugArrayType(LLVMZigDIBuilder *dibuilder, uint64_t
size_in_bits, align_in_bits,
reinterpret_cast<DIType*>(elem_type),
reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(subrange));
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-LLVMZigDIEnumerator *LLVMZigCreateDebugEnumerator(LLVMZigDIBuilder *dibuilder, const char *name, int64_t val) {
+ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumerator(ZigLLVMDIBuilder *dibuilder, const char *name, int64_t val) {
DIEnumerator *di_enumerator = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerator(name, val);
- return reinterpret_cast<LLVMZigDIEnumerator*>(di_enumerator);
+ return reinterpret_cast<ZigLLVMDIEnumerator*>(di_enumerator);
}
-LLVMZigDIType *LLVMZigCreateDebugEnumerationType(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, LLVMZigDIFile *file, unsigned line_number, uint64_t size_in_bits,
- uint64_t align_in_bits, LLVMZigDIEnumerator **enumerator_array, int enumerator_array_len,
- LLVMZigDIType *underlying_type, const char *unique_id)
+ZigLLVMDIType *ZigLLVMCreateDebugEnumerationType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
+ uint64_t align_in_bits, ZigLLVMDIEnumerator **enumerator_array, int enumerator_array_len,
+ ZigLLVMDIType *underlying_type, const char *unique_id)
{
SmallVector<Metadata *, 8> fields;
for (int i = 0; i < enumerator_array_len; i += 1) {
@@ -204,12 +204,12 @@ LLVMZigDIType *LLVMZigCreateDebugEnumerationType(LLVMZigDIBuilder *dibuilder, LL
reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
reinterpret_cast<DIType*>(underlying_type),
unique_id);
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-LLVMZigDIType *LLVMZigCreateDebugMemberType(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, LLVMZigDIFile *file, unsigned line, uint64_t size_in_bits,
- uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags, LLVMZigDIType *type)
+ZigLLVMDIType *ZigLLVMCreateDebugMemberType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, ZigLLVMDIFile *file, unsigned line, uint64_t size_in_bits,
+ uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags, ZigLLVMDIType *type)
{
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createMemberType(
reinterpret_cast<DIScope*>(scope),
@@ -217,12 +217,12 @@ LLVMZigDIType *LLVMZigCreateDebugMemberType(LLVMZigDIBuilder *dibuilder, LLVMZig
reinterpret_cast<DIFile*>(file),
line, size_in_bits, align_in_bits, offset_in_bits, flags,
reinterpret_cast<DIType*>(type));
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-LLVMZigDIType *LLVMZigCreateDebugUnionType(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, LLVMZigDIFile *file, unsigned line_number, uint64_t size_in_bits,
- uint64_t align_in_bits, unsigned flags, LLVMZigDIType **types_array, int types_array_len,
+ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
+ uint64_t align_in_bits, unsigned flags, ZigLLVMDIType **types_array, int types_array_len,
unsigned run_time_lang, const char *unique_id)
{
SmallVector<Metadata *, 8> fields;
@@ -237,13 +237,13 @@ LLVMZigDIType *LLVMZigCreateDebugUnionType(LLVMZigDIBuilder *dibuilder, LLVMZigD
line_number, size_in_bits, align_in_bits, flags,
reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
run_time_lang, unique_id);
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-LLVMZigDIType *LLVMZigCreateDebugStructType(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, LLVMZigDIFile *file, unsigned line_number, uint64_t size_in_bits,
- uint64_t align_in_bits, unsigned flags, LLVMZigDIType *derived_from,
- LLVMZigDIType **types_array, int types_array_len, unsigned run_time_lang, LLVMZigDIType *vtable_holder,
+ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
+ uint64_t align_in_bits, unsigned flags, ZigLLVMDIType *derived_from,
+ ZigLLVMDIType **types_array, int types_array_len, unsigned run_time_lang, ZigLLVMDIType *vtable_holder,
const char *unique_id)
{
SmallVector<Metadata *, 8> fields;
@@ -261,41 +261,41 @@ LLVMZigDIType *LLVMZigCreateDebugStructType(LLVMZigDIBuilder *dibuilder, LLVMZig
run_time_lang,
reinterpret_cast<DIType*>(vtable_holder),
unique_id);
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-LLVMZigDIType *LLVMZigCreateReplaceableCompositeType(LLVMZigDIBuilder *dibuilder, unsigned tag,
- const char *name, LLVMZigDIScope *scope, LLVMZigDIFile *file, unsigned line)
+ZigLLVMDIType *ZigLLVMCreateReplaceableCompositeType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
+ const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line)
{
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createReplaceableCompositeType(
tag, name,
reinterpret_cast<DIScope*>(scope),
reinterpret_cast<DIFile*>(file),
line);
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-LLVMZigDIType *LLVMZigCreateDebugForwardDeclType(LLVMZigDIBuilder *dibuilder, unsigned tag,
- const char *name, LLVMZigDIScope *scope, LLVMZigDIFile *file, unsigned line)
+ZigLLVMDIType *ZigLLVMCreateDebugForwardDeclType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
+ const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line)
{
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createForwardDecl(
tag, name,
reinterpret_cast<DIScope*>(scope),
reinterpret_cast<DIFile*>(file),
line);
- return reinterpret_cast<LLVMZigDIType*>(di_type);
+ return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
-void LLVMZigReplaceTemporary(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *type,
- LLVMZigDIType *replacement)
+void ZigLLVMReplaceTemporary(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
+ ZigLLVMDIType *replacement)
{
reinterpret_cast<DIBuilder*>(dibuilder)->replaceTemporary(
TempDIType(reinterpret_cast<DIType*>(type)),
reinterpret_cast<DIType*>(replacement));
}
-void LLVMZigReplaceDebugArrays(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *type,
- LLVMZigDIType **types_array, int types_array_len)
+void ZigLLVMReplaceDebugArrays(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
+ ZigLLVMDIType **types_array, int types_array_len)
{
SmallVector<Metadata *, 8> fields;
for (int i = 0; i < types_array_len; i += 1) {
@@ -308,8 +308,8 @@ void LLVMZigReplaceDebugArrays(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *type,
reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields));
}
-LLVMZigDIType *LLVMZigCreateSubroutineType(LLVMZigDIBuilder *dibuilder_wrapped,
- LLVMZigDIType **types_array, int types_array_len, unsigned flags)
+ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped,
+ ZigLLVMDIType **types_array, int types_array_len, unsigned flags)
{
SmallVector<Metadata *, 8> types;
for (int i = 0; i < types_array_len; i += 1) {
@@ -321,51 +321,51 @@ LLVMZigDIType *LLVMZigCreateSubroutineType(LLVMZigDIBuilder *dibuilder_wrapped,
dibuilder->getOrCreateTypeArray(types),
flags);
DIType *ditype = subroutine_type;
- return reinterpret_cast<LLVMZigDIType*>(ditype);
+ return reinterpret_cast<ZigLLVMDIType*>(ditype);
}
-unsigned LLVMZigEncoding_DW_ATE_unsigned(void) {
+unsigned ZigLLVMEncoding_DW_ATE_unsigned(void) {
return dwarf::DW_ATE_unsigned;
}
-unsigned LLVMZigEncoding_DW_ATE_signed(void) {
+unsigned ZigLLVMEncoding_DW_ATE_signed(void) {
return dwarf::DW_ATE_signed;
}
-unsigned LLVMZigEncoding_DW_ATE_float(void) {
+unsigned ZigLLVMEncoding_DW_ATE_float(void) {
return dwarf::DW_ATE_float;
}
-unsigned LLVMZigEncoding_DW_ATE_boolean(void) {
+unsigned ZigLLVMEncoding_DW_ATE_boolean(void) {
return dwarf::DW_ATE_boolean;
}
-unsigned LLVMZigEncoding_DW_ATE_unsigned_char(void) {
+unsigned ZigLLVMEncoding_DW_ATE_unsigned_char(void) {
return dwarf::DW_ATE_unsigned_char;
}
-unsigned LLVMZigEncoding_DW_ATE_signed_char(void) {
+unsigned ZigLLVMEncoding_DW_ATE_signed_char(void) {
return dwarf::DW_ATE_signed_char;
}
-unsigned LLVMZigLang_DW_LANG_C99(void) {
+unsigned ZigLLVMLang_DW_LANG_C99(void) {
return dwarf::DW_LANG_C99;
}
-unsigned LLVMZigTag_DW_variable(void) {
+unsigned ZigLLVMTag_DW_variable(void) {
return dwarf::DW_TAG_variable;
}
-unsigned LLVMZigTag_DW_structure_type(void) {
+unsigned ZigLLVMTag_DW_structure_type(void) {
return dwarf::DW_TAG_structure_type;
}
-LLVMZigDIBuilder *LLVMZigCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved) {
+ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved) {
DIBuilder *di_builder = new DIBuilder(*unwrap(module), allow_unresolved);
- return reinterpret_cast<LLVMZigDIBuilder *>(di_builder);
+ return reinterpret_cast<ZigLLVMDIBuilder *>(di_builder);
}
-void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, LLVMZigDIScope *scope) {
+void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, ZigLLVMDIScope *scope) {
unwrap(builder)->SetCurrentDebugLocation(DebugLoc::get(
line, column, reinterpret_cast<DIScope*>(scope)));
}
@@ -375,20 +375,20 @@ void ZigLLVMClearCurrentDebugLocation(LLVMBuilderRef builder) {
}
-LLVMZigDILexicalBlock *LLVMZigCreateLexicalBlock(LLVMZigDIBuilder *dbuilder, LLVMZigDIScope *scope,
- LLVMZigDIFile *file, unsigned line, unsigned col)
+ZigLLVMDILexicalBlock *ZigLLVMCreateLexicalBlock(ZigLLVMDIBuilder *dbuilder, ZigLLVMDIScope *scope,
+ ZigLLVMDIFile *file, unsigned line, unsigned col)
{
DILexicalBlock *result = reinterpret_cast<DIBuilder*>(dbuilder)->createLexicalBlock(
reinterpret_cast<DIScope*>(scope),
reinterpret_cast<DIFile*>(file),
line,
col);
- return reinterpret_cast<LLVMZigDILexicalBlock*>(result);
+ return reinterpret_cast<ZigLLVMDILexicalBlock*>(result);
}
-LLVMZigDILocalVariable *LLVMZigCreateAutoVariable(LLVMZigDIBuilder *dbuilder,
- LLVMZigDIScope *scope, const char *name, LLVMZigDIFile *file, unsigned line_no,
- LLVMZigDIType *type, bool always_preserve, unsigned flags)
+ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
+ ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
+ ZigLLVMDIType *type, bool always_preserve, unsigned flags)
{
DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createAutoVariable(
reinterpret_cast<DIScope*>(scope),
@@ -398,12 +398,12 @@ LLVMZigDILocalVariable *LLVMZigCreateAutoVariable(LLVMZigDIBuilder *dbuilder,
reinterpret_cast<DIType*>(type),
always_preserve,
flags);
- return reinterpret_cast<LLVMZigDILocalVariable*>(result);
+ return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
}
-LLVMZigDIGlobalVariable *LLVMZigCreateGlobalVariable(LLVMZigDIBuilder *dbuilder,
- LLVMZigDIScope *scope, const char *name, const char *linkage_name, LLVMZigDIFile *file,
- unsigned line_no, LLVMZigDIType *di_type, bool is_local_to_unit, LLVMValueRef constant_val)
+ZigLLVMDIGlobalVariable *ZigLLVMCreateGlobalVariable(ZigLLVMDIBuilder *dbuilder,
+ ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file,
+ unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit, LLVMValueRef constant_val)
{
DIGlobalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createGlobalVariable(
reinterpret_cast<DIScope*>(scope),
@@ -414,12 +414,12 @@ LLVMZigDIGlobalVariable *LLVMZigCreateGlobalVariable(LLVMZigDIBuilder *dbuilder,
reinterpret_cast<DIType*>(di_type),
is_local_to_unit,
reinterpret_cast<llvm::Constant *>(constant_val));
- return reinterpret_cast<LLVMZigDIGlobalVariable*>(result);
+ return reinterpret_cast<ZigLLVMDIGlobalVariable*>(result);
}
-LLVMZigDILocalVariable *LLVMZigCreateParameterVariable(LLVMZigDIBuilder *dbuilder,
- LLVMZigDIScope *scope, const char *name, LLVMZigDIFile *file, unsigned line_no,
- LLVMZigDIType *type, bool always_preserve, unsigned flags, unsigned arg_no)
+ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilder,
+ ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
+ ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no)
{
DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createParameterVariable(
reinterpret_cast<DIScope*>(scope),
@@ -430,54 +430,54 @@ LLVMZigDILocalVariable *LLVMZigCreateParameterVariable(LLVMZigDIBuilder *dbuilde
reinterpret_cast<DIType*>(type),
always_preserve,
flags);
- return reinterpret_cast<LLVMZigDILocalVariable*>(result);
+ return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
}
-LLVMZigDIScope *LLVMZigLexicalBlockToScope(LLVMZigDILexicalBlock *lexical_block) {
+ZigLLVMDIScope *ZigLLVMLexicalBlockToScope(ZigLLVMDILexicalBlock *lexical_block) {
DIScope *scope = reinterpret_cast<DILexicalBlock*>(lexical_block);
- return reinterpret_cast<LLVMZigDIScope*>(scope);
+ return reinterpret_cast<ZigLLVMDIScope*>(scope);
}
-LLVMZigDIScope *LLVMZigCompileUnitToScope(LLVMZigDICompileUnit *compile_unit) {
+ZigLLVMDIScope *ZigLLVMCompileUnitToScope(ZigLLVMDICompileUnit *compile_unit) {
DIScope *scope = reinterpret_cast<DICompileUnit*>(compile_unit);
- return reinterpret_cast<LLVMZigDIScope*>(scope);
+ return reinterpret_cast<ZigLLVMDIScope*>(scope);
}
-LLVMZigDIScope *LLVMZigFileToScope(LLVMZigDIFile *difile) {
+ZigLLVMDIScope *ZigLLVMFileToScope(ZigLLVMDIFile *difile) {
DIScope *scope = reinterpret_cast<DIFile*>(difile);
- return reinterpret_cast<LLVMZigDIScope*>(scope);
+ return reinterpret_cast<ZigLLVMDIScope*>(scope);
}
-LLVMZigDIScope *LLVMZigSubprogramToScope(LLVMZigDISubprogram *subprogram) {
+ZigLLVMDIScope *ZigLLVMSubprogramToScope(ZigLLVMDISubprogram *subprogram) {
DIScope *scope = reinterpret_cast<DISubprogram*>(subprogram);
- return reinterpret_cast<LLVMZigDIScope*>(scope);
+ return reinterpret_cast<ZigLLVMDIScope*>(scope);
}
-LLVMZigDIScope *LLVMZigTypeToScope(LLVMZigDIType *type) {
+ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type) {
DIScope *scope = reinterpret_cast<DIType*>(type);
- return reinterpret_cast<LLVMZigDIScope*>(scope);
+ return reinterpret_cast<ZigLLVMDIScope*>(scope);
}
-LLVMZigDICompileUnit *LLVMZigCreateCompileUnit(LLVMZigDIBuilder *dibuilder,
+ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder,
unsigned lang, const char *file, const char *dir, const char *producer,
bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
uint64_t dwo_id, bool emit_debug_info)
{
DICompileUnit *result = reinterpret_cast<DIBuilder*>(dibuilder)->createCompileUnit(
lang, file, dir, producer, is_optimized, flags, runtime_version, split_name);
- return reinterpret_cast<LLVMZigDICompileUnit*>(result);
+ return reinterpret_cast<ZigLLVMDICompileUnit*>(result);
}
-LLVMZigDIFile *LLVMZigCreateFile(LLVMZigDIBuilder *dibuilder, const char *filename, const char *directory) {
+ZigLLVMDIFile *ZigLLVMCreateFile(ZigLLVMDIBuilder *dibuilder, const char *filename, const char *directory) {
DIFile *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFile(filename, directory);
- return reinterpret_cast<LLVMZigDIFile*>(result);
+ return reinterpret_cast<ZigLLVMDIFile*>(result);
}
-LLVMZigDISubprogram *LLVMZigCreateFunction(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, const char *linkage_name, LLVMZigDIFile *file, unsigned lineno,
- LLVMZigDIType *fn_di_type, bool is_local_to_unit, bool is_definition, unsigned scope_line,
- unsigned flags, bool is_optimized, LLVMZigDISubprogram *decl_subprogram)
+ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, const char *linkage_name, ZigLLVMDIFile *file, unsigned lineno,
+ ZigLLVMDIType *fn_di_type, bool is_local_to_unit, bool is_definition, unsigned scope_line,
+ unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram)
{
DISubroutineType *di_sub_type = static_cast<DISubroutineType*>(reinterpret_cast<DIType*>(fn_di_type));
DISubprogram *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFunction(
@@ -489,26 +489,26 @@ LLVMZigDISubprogram *LLVMZigCreateFunction(LLVMZigDIBuilder *dibuilder, LLVMZigD
is_local_to_unit, is_definition, scope_line, flags, is_optimized,
nullptr,
reinterpret_cast<DISubprogram *>(decl_subprogram));
- return reinterpret_cast<LLVMZigDISubprogram*>(result);
+ return reinterpret_cast<ZigLLVMDISubprogram*>(result);
}
-void LLVMZigDIBuilderFinalize(LLVMZigDIBuilder *dibuilder) {
+void ZigLLVMDIBuilderFinalize(ZigLLVMDIBuilder *dibuilder) {
reinterpret_cast<DIBuilder*>(dibuilder)->finalize();
}
-LLVMZigInsertionPoint *LLVMZigSaveInsertPoint(LLVMBuilderRef builder_wrapped) {
+ZigLLVMInsertionPoint *ZigLLVMSaveInsertPoint(LLVMBuilderRef builder_wrapped) {
IRBuilderBase::InsertPoint *ip = new IRBuilderBase::InsertPoint();
*ip = unwrap(builder_wrapped)->saveIP();
- return reinterpret_cast<LLVMZigInsertionPoint*>(ip);
+ return reinterpret_cast<ZigLLVMInsertionPoint*>(ip);
}
-void LLVMZigRestoreInsertPoint(LLVMBuilderRef builder, LLVMZigInsertionPoint *ip_wrapped) {
+void ZigLLVMRestoreInsertPoint(LLVMBuilderRef builder, ZigLLVMInsertionPoint *ip_wrapped) {
IRBuilderBase::InsertPoint *ip = reinterpret_cast<IRBuilderBase::InsertPoint*>(ip_wrapped);
unwrap(builder)->restoreIP(*ip);
}
-LLVMValueRef LLVMZigInsertDeclareAtEnd(LLVMZigDIBuilder *dibuilder, LLVMValueRef storage,
- LLVMZigDILocalVariable *var_info, LLVMZigDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref)
+LLVMValueRef ZigLLVMInsertDeclareAtEnd(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
+ ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref)
{
Instruction *result = reinterpret_cast<DIBuilder*>(dibuilder)->insertDeclare(
unwrap(storage),
@@ -519,8 +519,8 @@ LLVMValueRef LLVMZigInsertDeclareAtEnd(LLVMZigDIBuilder *dibuilder, LLVMValueRef
return wrap(result);
}
-LLVMValueRef LLVMZigInsertDeclare(LLVMZigDIBuilder *dibuilder, LLVMValueRef storage,
- LLVMZigDILocalVariable *var_info, LLVMZigDILocation *debug_loc, LLVMValueRef insert_before_instr)
+LLVMValueRef ZigLLVMInsertDeclare(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
+ ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMValueRef insert_before_instr)
{
Instruction *result = reinterpret_cast<DIBuilder*>(dibuilder)->insertDeclare(
unwrap(storage),
@@ -531,12 +531,12 @@ LLVMValueRef LLVMZigInsertDeclare(LLVMZigDIBuilder *dibuilder, LLVMValueRef stor
return wrap(result);
}
-LLVMZigDILocation *LLVMZigGetDebugLoc(unsigned line, unsigned col, LLVMZigDIScope *scope) {
+ZigLLVMDILocation *ZigLLVMGetDebugLoc(unsigned line, unsigned col, ZigLLVMDIScope *scope) {
DebugLoc debug_loc = DebugLoc::get(line, col, reinterpret_cast<DIScope*>(scope), nullptr);
- return reinterpret_cast<LLVMZigDILocation*>(debug_loc.get());
+ return reinterpret_cast<ZigLLVMDILocation*>(debug_loc.get());
}
-void LLVMZigSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state) {
+void ZigLLVMSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state) {
if (on_state) {
FastMathFlags fmf;
fmf.setUnsafeAlgebra();
src/zig_llvm.hpp
@@ -14,29 +14,29 @@
#include <llvm-c/Initialization.h>
#include <llvm-c/TargetMachine.h>
-struct LLVMZigDIType;
-struct LLVMZigDIBuilder;
-struct LLVMZigDICompileUnit;
-struct LLVMZigDIScope;
-struct LLVMZigDIFile;
-struct LLVMZigDILexicalBlock;
-struct LLVMZigDISubprogram;
-struct LLVMZigDISubroutineType;
-struct LLVMZigDILocalVariable;
-struct LLVMZigDIGlobalVariable;
-struct LLVMZigDILocation;
-struct LLVMZigDIEnumerator;
-struct LLVMZigInsertionPoint;
-
-void LLVMZigInitializeLoopStrengthReducePass(LLVMPassRegistryRef R);
-void LLVMZigInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R);
-
-char *LLVMZigGetHostCPUName(void);
-char *LLVMZigGetNativeFeatures(void);
-
-void LLVMZigOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref);
-
-LLVMValueRef LLVMZigBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
+struct ZigLLVMDIType;
+struct ZigLLVMDIBuilder;
+struct ZigLLVMDICompileUnit;
+struct ZigLLVMDIScope;
+struct ZigLLVMDIFile;
+struct ZigLLVMDILexicalBlock;
+struct ZigLLVMDISubprogram;
+struct ZigLLVMDISubroutineType;
+struct ZigLLVMDILocalVariable;
+struct ZigLLVMDIGlobalVariable;
+struct ZigLLVMDILocation;
+struct ZigLLVMDIEnumerator;
+struct ZigLLVMInsertionPoint;
+
+void ZigLLVMInitializeLoopStrengthReducePass(LLVMPassRegistryRef R);
+void ZigLLVMInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R);
+
+char *ZigLLVMGetHostCPUName(void);
+char *ZigLLVMGetNativeFeatures(void);
+
+void ZigLLVMOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref);
+
+LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
unsigned NumArgs, unsigned CC, const char *Name);
LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
@@ -51,118 +51,118 @@ LLVMValueRef ZigLLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS,
LLVMValueRef RHS, const char *Name);
// 0 is return value, 1 is first arg
-void LLVMZigAddNonNullAttr(LLVMValueRef fn, unsigned i);
+void ZigLLVMAddNonNullAttr(LLVMValueRef fn, unsigned i);
-LLVMZigDIType *LLVMZigCreateDebugPointerType(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *pointee_type,
+ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *pointee_type,
uint64_t size_in_bits, uint64_t align_in_bits, const char *name);
-LLVMZigDIType *LLVMZigCreateDebugBasicType(LLVMZigDIBuilder *dibuilder, const char *name,
+ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name,
uint64_t size_in_bits, uint64_t align_in_bits, unsigned encoding);
-LLVMZigDIType *LLVMZigCreateDebugArrayType(LLVMZigDIBuilder *dibuilder,
- uint64_t size_in_bits, uint64_t align_in_bits, LLVMZigDIType *elem_type,
+ZigLLVMDIType *ZigLLVMCreateDebugArrayType(ZigLLVMDIBuilder *dibuilder,
+ uint64_t size_in_bits, uint64_t align_in_bits, ZigLLVMDIType *elem_type,
int elem_count);
-LLVMZigDIEnumerator *LLVMZigCreateDebugEnumerator(LLVMZigDIBuilder *dibuilder, const char *name, int64_t val);
+ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumerator(ZigLLVMDIBuilder *dibuilder, const char *name, int64_t val);
-LLVMZigDIType *LLVMZigCreateDebugEnumerationType(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, LLVMZigDIFile *file, unsigned line_number, uint64_t size_in_bits,
- uint64_t align_in_bits, LLVMZigDIEnumerator **enumerator_array, int enumerator_array_len,
- LLVMZigDIType *underlying_type, const char *unique_id);
+ZigLLVMDIType *ZigLLVMCreateDebugEnumerationType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
+ uint64_t align_in_bits, ZigLLVMDIEnumerator **enumerator_array, int enumerator_array_len,
+ ZigLLVMDIType *underlying_type, const char *unique_id);
-LLVMZigDIType *LLVMZigCreateDebugStructType(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, LLVMZigDIFile *file, unsigned line_number, uint64_t size_in_bits,
- uint64_t align_in_bits, unsigned flags, LLVMZigDIType *derived_from,
- LLVMZigDIType **types_array, int types_array_len, unsigned run_time_lang, LLVMZigDIType *vtable_holder,
+ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
+ uint64_t align_in_bits, unsigned flags, ZigLLVMDIType *derived_from,
+ ZigLLVMDIType **types_array, int types_array_len, unsigned run_time_lang, ZigLLVMDIType *vtable_holder,
const char *unique_id);
-LLVMZigDIType *LLVMZigCreateDebugUnionType(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, LLVMZigDIFile *file, unsigned line_number, uint64_t size_in_bits,
- uint64_t align_in_bits, unsigned flags, LLVMZigDIType **types_array, int types_array_len,
+ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
+ uint64_t align_in_bits, unsigned flags, ZigLLVMDIType **types_array, int types_array_len,
unsigned run_time_lang, const char *unique_id);
-LLVMZigDIType *LLVMZigCreateDebugMemberType(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, LLVMZigDIFile *file, unsigned line, uint64_t size_in_bits,
- uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags, LLVMZigDIType *type);
+ZigLLVMDIType *ZigLLVMCreateDebugMemberType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, ZigLLVMDIFile *file, unsigned line, uint64_t size_in_bits,
+ uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags, ZigLLVMDIType *type);
-LLVMZigDIType *LLVMZigCreateReplaceableCompositeType(LLVMZigDIBuilder *dibuilder, unsigned tag,
- const char *name, LLVMZigDIScope *scope, LLVMZigDIFile *file, unsigned line);
+ZigLLVMDIType *ZigLLVMCreateReplaceableCompositeType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
+ const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line);
-LLVMZigDIType *LLVMZigCreateDebugForwardDeclType(LLVMZigDIBuilder *dibuilder, unsigned tag,
- const char *name, LLVMZigDIScope *scope, LLVMZigDIFile *file, unsigned line);
+ZigLLVMDIType *ZigLLVMCreateDebugForwardDeclType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
+ const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line);
-void LLVMZigReplaceTemporary(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *type,
- LLVMZigDIType *replacement);
+void ZigLLVMReplaceTemporary(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
+ ZigLLVMDIType *replacement);
-void LLVMZigReplaceDebugArrays(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *type,
- LLVMZigDIType **types_array, int types_array_len);
+void ZigLLVMReplaceDebugArrays(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
+ ZigLLVMDIType **types_array, int types_array_len);
-LLVMZigDIType *LLVMZigCreateSubroutineType(LLVMZigDIBuilder *dibuilder_wrapped,
- LLVMZigDIType **types_array, int types_array_len, unsigned flags);
+ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped,
+ ZigLLVMDIType **types_array, int types_array_len, unsigned flags);
-unsigned LLVMZigEncoding_DW_ATE_unsigned(void);
-unsigned LLVMZigEncoding_DW_ATE_signed(void);
-unsigned LLVMZigEncoding_DW_ATE_float(void);
-unsigned LLVMZigEncoding_DW_ATE_boolean(void);
-unsigned LLVMZigEncoding_DW_ATE_unsigned_char(void);
-unsigned LLVMZigEncoding_DW_ATE_signed_char(void);
-unsigned LLVMZigLang_DW_LANG_C99(void);
-unsigned LLVMZigTag_DW_variable(void);
-unsigned LLVMZigTag_DW_structure_type(void);
+unsigned ZigLLVMEncoding_DW_ATE_unsigned(void);
+unsigned ZigLLVMEncoding_DW_ATE_signed(void);
+unsigned ZigLLVMEncoding_DW_ATE_float(void);
+unsigned ZigLLVMEncoding_DW_ATE_boolean(void);
+unsigned ZigLLVMEncoding_DW_ATE_unsigned_char(void);
+unsigned ZigLLVMEncoding_DW_ATE_signed_char(void);
+unsigned ZigLLVMLang_DW_LANG_C99(void);
+unsigned ZigLLVMTag_DW_variable(void);
+unsigned ZigLLVMTag_DW_structure_type(void);
-LLVMZigDIBuilder *LLVMZigCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved);
+ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved);
void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module);
-void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, LLVMZigDIScope *scope);
+void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, ZigLLVMDIScope *scope);
void ZigLLVMClearCurrentDebugLocation(LLVMBuilderRef builder);
-LLVMZigDIScope *LLVMZigLexicalBlockToScope(LLVMZigDILexicalBlock *lexical_block);
-LLVMZigDIScope *LLVMZigCompileUnitToScope(LLVMZigDICompileUnit *compile_unit);
-LLVMZigDIScope *LLVMZigFileToScope(LLVMZigDIFile *difile);
-LLVMZigDIScope *LLVMZigSubprogramToScope(LLVMZigDISubprogram *subprogram);
-LLVMZigDIScope *LLVMZigTypeToScope(LLVMZigDIType *type);
+ZigLLVMDIScope *ZigLLVMLexicalBlockToScope(ZigLLVMDILexicalBlock *lexical_block);
+ZigLLVMDIScope *ZigLLVMCompileUnitToScope(ZigLLVMDICompileUnit *compile_unit);
+ZigLLVMDIScope *ZigLLVMFileToScope(ZigLLVMDIFile *difile);
+ZigLLVMDIScope *ZigLLVMSubprogramToScope(ZigLLVMDISubprogram *subprogram);
+ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type);
-LLVMZigDILocalVariable *LLVMZigCreateAutoVariable(LLVMZigDIBuilder *dbuilder,
- LLVMZigDIScope *scope, const char *name, LLVMZigDIFile *file, unsigned line_no,
- LLVMZigDIType *type, bool always_preserve, unsigned flags);
+ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
+ ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
+ ZigLLVMDIType *type, bool always_preserve, unsigned flags);
-LLVMZigDIGlobalVariable *LLVMZigCreateGlobalVariable(LLVMZigDIBuilder *dbuilder,
- LLVMZigDIScope *scope, const char *name, const char *linkage_name, LLVMZigDIFile *file,
- unsigned line_no, LLVMZigDIType *di_type, bool is_local_to_unit, LLVMValueRef constant_val);
+ZigLLVMDIGlobalVariable *ZigLLVMCreateGlobalVariable(ZigLLVMDIBuilder *dbuilder,
+ ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file,
+ unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit, LLVMValueRef constant_val);
-LLVMZigDILocalVariable *LLVMZigCreateParameterVariable(LLVMZigDIBuilder *dbuilder,
- LLVMZigDIScope *scope, const char *name, LLVMZigDIFile *file, unsigned line_no,
- LLVMZigDIType *type, bool always_preserve, unsigned flags, unsigned arg_no);
+ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilder,
+ ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
+ ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no);
-LLVMZigDILexicalBlock *LLVMZigCreateLexicalBlock(LLVMZigDIBuilder *dbuilder, LLVMZigDIScope *scope,
- LLVMZigDIFile *file, unsigned line, unsigned col);
+ZigLLVMDILexicalBlock *ZigLLVMCreateLexicalBlock(ZigLLVMDIBuilder *dbuilder, ZigLLVMDIScope *scope,
+ ZigLLVMDIFile *file, unsigned line, unsigned col);
-LLVMZigDICompileUnit *LLVMZigCreateCompileUnit(LLVMZigDIBuilder *dibuilder,
+ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder,
unsigned lang, const char *file, const char *dir, const char *producer,
bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
uint64_t dwo_id, bool emit_debug_info);
-LLVMZigDIFile *LLVMZigCreateFile(LLVMZigDIBuilder *dibuilder, const char *filename, const char *directory);
+ZigLLVMDIFile *ZigLLVMCreateFile(ZigLLVMDIBuilder *dibuilder, const char *filename, const char *directory);
-LLVMZigDISubprogram *LLVMZigCreateFunction(LLVMZigDIBuilder *dibuilder, LLVMZigDIScope *scope,
- const char *name, const char *linkage_name, LLVMZigDIFile *file, unsigned lineno,
- LLVMZigDIType *fn_di_type, bool is_local_to_unit, bool is_definition, unsigned scope_line,
- unsigned flags, bool is_optimized, LLVMZigDISubprogram *decl_subprogram);
+ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
+ const char *name, const char *linkage_name, ZigLLVMDIFile *file, unsigned lineno,
+ ZigLLVMDIType *fn_di_type, bool is_local_to_unit, bool is_definition, unsigned scope_line,
+ unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram);
-void ZigLLVMFnSetSubprogram(LLVMValueRef fn, LLVMZigDISubprogram *subprogram);
+void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram);
-void LLVMZigDIBuilderFinalize(LLVMZigDIBuilder *dibuilder);
+void ZigLLVMDIBuilderFinalize(ZigLLVMDIBuilder *dibuilder);
-LLVMZigInsertionPoint *LLVMZigSaveInsertPoint(LLVMBuilderRef builder);
-void LLVMZigRestoreInsertPoint(LLVMBuilderRef builder, LLVMZigInsertionPoint *point);
+ZigLLVMInsertionPoint *ZigLLVMSaveInsertPoint(LLVMBuilderRef builder);
+void ZigLLVMRestoreInsertPoint(LLVMBuilderRef builder, ZigLLVMInsertionPoint *point);
-LLVMValueRef LLVMZigInsertDeclareAtEnd(LLVMZigDIBuilder *dibuilder, LLVMValueRef storage,
- LLVMZigDILocalVariable *var_info, LLVMZigDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref);
-LLVMValueRef LLVMZigInsertDeclare(LLVMZigDIBuilder *dibuilder, LLVMValueRef storage,
- LLVMZigDILocalVariable *var_info, LLVMZigDILocation *debug_loc, LLVMValueRef insert_before_instr);
-LLVMZigDILocation *LLVMZigGetDebugLoc(unsigned line, unsigned col, LLVMZigDIScope *scope);
+LLVMValueRef ZigLLVMInsertDeclareAtEnd(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
+ ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref);
+LLVMValueRef ZigLLVMInsertDeclare(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
+ ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMValueRef insert_before_instr);
+ZigLLVMDILocation *ZigLLVMGetDebugLoc(unsigned line, unsigned col, ZigLLVMDIScope *scope);
-void LLVMZigSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state);
+void ZigLLVMSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state);
void ZigLLVMAddFunctionAttr(LLVMValueRef fn, const char *attr_name, const char *attr_value);