From 1fa4d2a5afd35ebb58c84ea030046fc557ffad01 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 9 Sep 2016 12:25:16 -0400 Subject: [PATCH] rename LLVMZig to ZigLLVM --- src/all_types.hpp | 14 ++-- src/analyze.cpp | 136 +++++++++++++++--------------- src/codegen.cpp | 74 ++++++++-------- src/link.cpp | 2 +- src/parseh.cpp | 30 +++---- src/zig_llvm.cpp | 210 +++++++++++++++++++++++----------------------- src/zig_llvm.hpp | 184 ++++++++++++++++++++-------------------- 7 files changed, 325 insertions(+), 325 deletions(-) diff --git a/src/all_types.hpp b/src/all_types.hpp index 9d5980f23a..d5b24b121d 100644 --- a/src/all_types.hpp +++ b/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 *line_offsets; BlockContext *block_context; @@ -1190,8 +1190,8 @@ struct CodeGen { LLVMModuleRef module; ZigList errors; LLVMBuilderRef builder; - LLVMZigDIBuilder *dbuilder; - LLVMZigDICompileUnit *compile_unit; + ZigLLVMDIBuilder *dbuilder; + ZigLLVMDICompileUnit *compile_unit; ZigList 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 diff --git a/src/analyze.cpp b/src/analyze.cpp index 298842c345..0660e70a45 100644 --- a/src/analyze.cpp +++ b/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(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(2 + fn_type_id->param_count); + ZigLLVMDIType **param_di_types = allocate(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(field_count); - LLVMZigDIEnumerator **di_enumerators = allocate(field_count); + ZigLLVMDIEnumerator **di_enumerators = allocate(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(field_count); + ZigLLVMDIType **union_inner_di_types = allocate(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(gen_field_count); + ZigLLVMDIType **di_element_types = allocate(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); diff --git a/src/codegen.cpp b/src/codegen.cpp index cf8b4f0891..41a1a394cd 100644 --- a/src/codegen.cpp +++ b/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 errors = {0}; int err = parse_h_buf(import, &errors, source_code, g, nullptr); diff --git a/src/link.cpp b/src/link.cpp index 2ee7d2d111..6b3d3dce83 100644 --- a/src/link.cpp +++ b/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); diff --git a/src/parseh.cpp b/src/parseh.cpp index 64838bb496..99907b2c2e 100644 --- a/src/parseh.cpp +++ b/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(field_count); - LLVMZigDIEnumerator **di_enumerators = allocate(field_count); + ZigLLVMDIEnumerator **di_enumerators = allocate(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(field_count); LLVMTypeRef *element_types = allocate(field_count); - LLVMZigDIType **di_element_types = allocate(field_count); + ZigLLVMDIType **di_element_types = allocate(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; diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp index 969e624d4c..a16d624f29 100644 --- a/src/zig_llvm.cpp +++ b/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 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(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(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(unwrap(fn)) ); Function *unwrapped_function = reinterpret_cast(unwrap(fn)); unwrapped_function->setSubprogram(reinterpret_cast(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)->createPointerType( reinterpret_cast(pointee_type), size_in_bits, align_in_bits, name); - return reinterpret_cast(di_type); + return reinterpret_cast(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)->createBasicType( name, size_in_bits, align_in_bits, encoding); - return reinterpret_cast(di_type); + return reinterpret_cast(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 subrange; subrange.push_back(reinterpret_cast(dibuilder)->getOrCreateSubrange(0, elem_count)); @@ -178,18 +178,18 @@ LLVMZigDIType *LLVMZigCreateDebugArrayType(LLVMZigDIBuilder *dibuilder, uint64_t size_in_bits, align_in_bits, reinterpret_cast(elem_type), reinterpret_cast(dibuilder)->getOrCreateArray(subrange)); - return reinterpret_cast(di_type); + return reinterpret_cast(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)->createEnumerator(name, val); - return reinterpret_cast(di_enumerator); + return reinterpret_cast(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 fields; for (int i = 0; i < enumerator_array_len; i += 1) { @@ -204,12 +204,12 @@ LLVMZigDIType *LLVMZigCreateDebugEnumerationType(LLVMZigDIBuilder *dibuilder, LL reinterpret_cast(dibuilder)->getOrCreateArray(fields), reinterpret_cast(underlying_type), unique_id); - return reinterpret_cast(di_type); + return reinterpret_cast(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)->createMemberType( reinterpret_cast(scope), @@ -217,12 +217,12 @@ LLVMZigDIType *LLVMZigCreateDebugMemberType(LLVMZigDIBuilder *dibuilder, LLVMZig reinterpret_cast(file), line, size_in_bits, align_in_bits, offset_in_bits, flags, reinterpret_cast(type)); - return reinterpret_cast(di_type); + return reinterpret_cast(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 fields; @@ -237,13 +237,13 @@ LLVMZigDIType *LLVMZigCreateDebugUnionType(LLVMZigDIBuilder *dibuilder, LLVMZigD line_number, size_in_bits, align_in_bits, flags, reinterpret_cast(dibuilder)->getOrCreateArray(fields), run_time_lang, unique_id); - return reinterpret_cast(di_type); + return reinterpret_cast(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 fields; @@ -261,41 +261,41 @@ LLVMZigDIType *LLVMZigCreateDebugStructType(LLVMZigDIBuilder *dibuilder, LLVMZig run_time_lang, reinterpret_cast(vtable_holder), unique_id); - return reinterpret_cast(di_type); + return reinterpret_cast(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)->createReplaceableCompositeType( tag, name, reinterpret_cast(scope), reinterpret_cast(file), line); - return reinterpret_cast(di_type); + return reinterpret_cast(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)->createForwardDecl( tag, name, reinterpret_cast(scope), reinterpret_cast(file), line); - return reinterpret_cast(di_type); + return reinterpret_cast(di_type); } -void LLVMZigReplaceTemporary(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *type, - LLVMZigDIType *replacement) +void ZigLLVMReplaceTemporary(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type, + ZigLLVMDIType *replacement) { reinterpret_cast(dibuilder)->replaceTemporary( TempDIType(reinterpret_cast(type)), reinterpret_cast(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 fields; for (int i = 0; i < types_array_len; i += 1) { @@ -308,8 +308,8 @@ void LLVMZigReplaceDebugArrays(LLVMZigDIBuilder *dibuilder, LLVMZigDIType *type, reinterpret_cast(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 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(ditype); + return reinterpret_cast(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(di_builder); + return reinterpret_cast(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(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(dbuilder)->createLexicalBlock( reinterpret_cast(scope), reinterpret_cast(file), line, col); - return reinterpret_cast(result); + return reinterpret_cast(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(dbuilder)->createAutoVariable( reinterpret_cast(scope), @@ -398,12 +398,12 @@ LLVMZigDILocalVariable *LLVMZigCreateAutoVariable(LLVMZigDIBuilder *dbuilder, reinterpret_cast(type), always_preserve, flags); - return reinterpret_cast(result); + return reinterpret_cast(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(dbuilder)->createGlobalVariable( reinterpret_cast(scope), @@ -414,12 +414,12 @@ LLVMZigDIGlobalVariable *LLVMZigCreateGlobalVariable(LLVMZigDIBuilder *dbuilder, reinterpret_cast(di_type), is_local_to_unit, reinterpret_cast(constant_val)); - return reinterpret_cast(result); + return reinterpret_cast(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(dbuilder)->createParameterVariable( reinterpret_cast(scope), @@ -430,54 +430,54 @@ LLVMZigDILocalVariable *LLVMZigCreateParameterVariable(LLVMZigDIBuilder *dbuilde reinterpret_cast(type), always_preserve, flags); - return reinterpret_cast(result); + return reinterpret_cast(result); } -LLVMZigDIScope *LLVMZigLexicalBlockToScope(LLVMZigDILexicalBlock *lexical_block) { +ZigLLVMDIScope *ZigLLVMLexicalBlockToScope(ZigLLVMDILexicalBlock *lexical_block) { DIScope *scope = reinterpret_cast(lexical_block); - return reinterpret_cast(scope); + return reinterpret_cast(scope); } -LLVMZigDIScope *LLVMZigCompileUnitToScope(LLVMZigDICompileUnit *compile_unit) { +ZigLLVMDIScope *ZigLLVMCompileUnitToScope(ZigLLVMDICompileUnit *compile_unit) { DIScope *scope = reinterpret_cast(compile_unit); - return reinterpret_cast(scope); + return reinterpret_cast(scope); } -LLVMZigDIScope *LLVMZigFileToScope(LLVMZigDIFile *difile) { +ZigLLVMDIScope *ZigLLVMFileToScope(ZigLLVMDIFile *difile) { DIScope *scope = reinterpret_cast(difile); - return reinterpret_cast(scope); + return reinterpret_cast(scope); } -LLVMZigDIScope *LLVMZigSubprogramToScope(LLVMZigDISubprogram *subprogram) { +ZigLLVMDIScope *ZigLLVMSubprogramToScope(ZigLLVMDISubprogram *subprogram) { DIScope *scope = reinterpret_cast(subprogram); - return reinterpret_cast(scope); + return reinterpret_cast(scope); } -LLVMZigDIScope *LLVMZigTypeToScope(LLVMZigDIType *type) { +ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type) { DIScope *scope = reinterpret_cast(type); - return reinterpret_cast(scope); + return reinterpret_cast(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)->createCompileUnit( lang, file, dir, producer, is_optimized, flags, runtime_version, split_name); - return reinterpret_cast(result); + return reinterpret_cast(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)->createFile(filename, directory); - return reinterpret_cast(result); + return reinterpret_cast(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(reinterpret_cast(fn_di_type)); DISubprogram *result = reinterpret_cast(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(decl_subprogram)); - return reinterpret_cast(result); + return reinterpret_cast(result); } -void LLVMZigDIBuilderFinalize(LLVMZigDIBuilder *dibuilder) { +void ZigLLVMDIBuilderFinalize(ZigLLVMDIBuilder *dibuilder) { reinterpret_cast(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(ip); + return reinterpret_cast(ip); } -void LLVMZigRestoreInsertPoint(LLVMBuilderRef builder, LLVMZigInsertionPoint *ip_wrapped) { +void ZigLLVMRestoreInsertPoint(LLVMBuilderRef builder, ZigLLVMInsertionPoint *ip_wrapped) { IRBuilderBase::InsertPoint *ip = reinterpret_cast(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)->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)->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(scope), nullptr); - return reinterpret_cast(debug_loc.get()); + return reinterpret_cast(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(); diff --git a/src/zig_llvm.hpp b/src/zig_llvm.hpp index 34367403da..84ca275ecd 100644 --- a/src/zig_llvm.hpp +++ b/src/zig_llvm.hpp @@ -14,29 +14,29 @@ #include #include -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; +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 LLVMZigInitializeLoopStrengthReducePass(LLVMPassRegistryRef R); -void LLVMZigInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R); +void ZigLLVMInitializeLoopStrengthReducePass(LLVMPassRegistryRef R); +void ZigLLVMInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R); -char *LLVMZigGetHostCPUName(void); -char *LLVMZigGetNativeFeatures(void); +char *ZigLLVMGetHostCPUName(void); +char *ZigLLVMGetNativeFeatures(void); -void LLVMZigOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref); +void ZigLLVMOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref); -LLVMValueRef LLVMZigBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args, +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);