From cd31f875a68fba0519f20c561b11b5dfb9524a8b Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 10 Mar 2017 02:29:01 -0500 Subject: [PATCH] update to llvm 4.0 --- README.md | 4 +- cmake/Findclang.cmake | 4 +- cmake/Findllvm.cmake | 2 +- src/analyze.cpp | 4 +- src/codegen.cpp | 67 ++++++------ src/parseh.cpp | 4 + src/target.cpp | 8 ++ src/zig_llvm.cpp | 67 ++++++------ src/zig_llvm.hpp | 248 +++++++++++++++++++++--------------------- 9 files changed, 210 insertions(+), 198 deletions(-) diff --git a/README.md b/README.md index 368d0b407b..594abcaa5e 100644 --- a/README.md +++ b/README.md @@ -87,8 +87,8 @@ the Zig compiler itself: These libraries must be installed on your system, with the development files available. The Zig compiler dynamically links against them. - * LLVM == 3.9.x - * libclang == 3.9.x + * LLVM == 4.x + * libclang == 4.x ### Debug / Development Build diff --git a/cmake/Findclang.cmake b/cmake/Findclang.cmake index b2b8f5ae39..27f1b6df6b 100644 --- a/cmake/Findclang.cmake +++ b/cmake/Findclang.cmake @@ -8,14 +8,14 @@ find_path(CLANG_INCLUDE_DIRS NAMES clang/Frontend/ASTUnit.h PATHS - /usr/lib/llvm-3.9/include + /usr/lib/llvm-4/include /mingw64/include) macro(FIND_AND_ADD_CLANG_LIB _libname_) string(TOUPPER ${_libname_} _prettylibname_) find_library(CLANG_${_prettylibname_}_LIB NAMES ${_libname_} PATHS - /usr/lib/llvm-3.9/lib + /usr/lib/llvm-4/lib /mingw64/lib) if(CLANG_${_prettylibname_}_LIB) set(CLANG_LIBRARIES ${CLANG_LIBRARIES} ${CLANG_${_prettylibname_}_LIB}) diff --git a/cmake/Findllvm.cmake b/cmake/Findllvm.cmake index cf65a5bcd5..e1d55fb3fd 100644 --- a/cmake/Findllvm.cmake +++ b/cmake/Findllvm.cmake @@ -7,7 +7,7 @@ # LLVM_LIBRARIES # LLVM_LIBDIRS -find_program(LLVM_CONFIG_EXE NAMES llvm-config llvm-config-3.9) +find_program(LLVM_CONFIG_EXE NAMES llvm-config llvm-config-4) execute_process( COMMAND ${LLVM_CONFIG_EXE} --libs diff --git a/src/analyze.cpp b/src/analyze.cpp index 453cefc2f8..b1753af264 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -3950,9 +3950,7 @@ TypeTableEntry *make_int_type(CodeGen *g, bool is_signed, size_t size_in_bits) { } 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 = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), - debug_size_in_bits, debug_align_in_bits, dwarf_tag); + entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), debug_size_in_bits, dwarf_tag); entry->data.integral.is_signed = is_signed; entry->data.integral.bit_count = size_in_bits; return entry; diff --git a/src/codegen.cpp b/src/codegen.cpp index 14d2f68116..d75a198926 100644 --- a/src/codegen.cpp +++ b/src/codegen.cpp @@ -236,6 +236,21 @@ static void render_const_val(CodeGen *g, ConstExprValue *const_val); static void render_const_val_global(CodeGen *g, ConstExprValue *const_val, const char *name); static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val); +static void addLLVMAttr(LLVMValueRef val, LLVMAttributeIndex attr_index, const char *attr_name) { + unsigned kind_id = LLVMGetEnumAttributeKindForName(attr_name, strlen(attr_name)); + assert(kind_id != 0); + LLVMAttributeRef llvm_attr = LLVMCreateEnumAttribute(LLVMGetGlobalContext(), kind_id, 0); + LLVMAddAttributeAtIndex(val, attr_index, llvm_attr); +} + +static void addLLVMFnAttr(LLVMValueRef fn_val, const char *attr_name) { + return addLLVMAttr(fn_val, -1, attr_name); +} + +static void addLLVMArgAttr(LLVMValueRef arg_val, unsigned param_index, const char *attr_name) { + return addLLVMAttr(arg_val, param_index + 1, attr_name); +} + static LLVMValueRef fn_llvm_value(CodeGen *g, FnTableEntry *fn_table_entry) { if (fn_table_entry->llvm_value) return fn_table_entry->llvm_value; @@ -252,29 +267,29 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, FnTableEntry *fn_table_entry) { switch (fn_table_entry->fn_inline) { case FnInlineAlways: - LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMAlwaysInlineAttribute); + addLLVMFnAttr(fn_table_entry->llvm_value, "alwaysinline"); break; case FnInlineNever: - LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoInlineAttribute); + addLLVMFnAttr(fn_table_entry->llvm_value, "noinline"); break; case FnInlineAuto: break; } if (fn_type->data.fn.fn_type_id.is_naked) { - LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNakedAttribute); + addLLVMFnAttr(fn_table_entry->llvm_value, "naked"); } LLVMSetLinkage(fn_table_entry->llvm_value, fn_table_entry->internal_linkage ? LLVMInternalLinkage : LLVMExternalLinkage); if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdUnreachable) { - LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoReturnAttribute); + addLLVMFnAttr(fn_table_entry->llvm_value, "noreturn"); } LLVMSetFunctionCallConv(fn_table_entry->llvm_value, fn_type->data.fn.calling_convention); if (fn_type->data.fn.fn_type_id.is_cold) { ZigLLVMAddFunctionAttrCold(fn_table_entry->llvm_value); } - LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoUnwindAttribute); + addLLVMFnAttr(fn_table_entry->llvm_value, "nounwind"); if (!g->is_release_build && fn_table_entry->fn_inline != FnInlineAlways) { ZigLLVMAddFunctionAttr(fn_table_entry->llvm_value, "no-frame-pointer-elim", "true"); ZigLLVMAddFunctionAttr(fn_table_entry->llvm_value, "no-frame-pointer-elim-non-leaf", nullptr); @@ -891,7 +906,7 @@ static LLVMValueRef gen_div(CodeGen *g, bool want_debug_safety, LLVMValueRef val if (type_entry->data.integral.is_signed) { return LLVMBuildExactSDiv(g->builder, val1, val2, ""); } else { - return ZigLLVMBuildExactUDiv(g->builder, val1, val2, ""); + return LLVMBuildExactUDiv(g->builder, val1, val2, ""); } } else { if (type_entry->data.integral.is_signed) { @@ -1125,7 +1140,7 @@ static LLVMValueRef ir_render_cast(CodeGen *g, IrExecutable *executable, LLVMPositionBuilderAtEnd(g->builder, ok_block); } - new_len = ZigLLVMBuildExactUDiv(g->builder, src_len, dest_size_val, ""); + new_len = LLVMBuildExactUDiv(g->builder, src_len, dest_size_val, ""); } else { zig_unreachable(); } @@ -3183,7 +3198,8 @@ static void gen_global_var(CodeGen *g, VariableTableEntry *var, LLVMValueRef ini bool is_local_to_unit = true; ZigLLVMCreateGlobalVariable(g->dbuilder, get_di_scope(g, var->parent_scope), buf_ptr(&var->name), buf_ptr(&var->name), import->di_file, var->decl_node->line + 1, - type_entry->di_type, is_local_to_unit, init_val); + type_entry->di_type, is_local_to_unit); + // TODO ^^ make an actual global variable } static LLVMValueRef build_alloca(CodeGen *g, TypeTableEntry *type_entry, const char *name) { @@ -3284,13 +3300,12 @@ static void do_code_gen(CodeGen *g) { } else if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdPointer || fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdFn) { - ZigLLVMAddNonNullAttr(fn_val, 0); + addLLVMAttr(fn_val, 0, "nonnull"); } 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_val, 0); - LLVMAddAttribute(first_arg, LLVMStructRetAttribute); - ZigLLVMAddNonNullAttr(fn_val, 1); + addLLVMArgAttr(fn_val, 0, "sret"); + addLLVMArgAttr(fn_val, 0, "nonnull"); } @@ -3307,19 +3322,17 @@ static void do_code_gen(CodeGen *g) { FnTypeParamInfo *param_info = &fn_type_id->param_info[param_i]; TypeTableEntry *param_type = gen_info->type; - LLVMValueRef argument_val = LLVMGetParam(fn_val, gen_index); if (param_info->is_noalias) { - LLVMAddAttribute(argument_val, LLVMNoAliasAttribute); + addLLVMArgAttr(fn_val, gen_index, "noalias"); } if ((param_type->id == TypeTableEntryIdPointer && param_type->data.pointer.is_const) || is_byval) { - LLVMAddAttribute(argument_val, LLVMReadOnlyAttribute); + addLLVMArgAttr(fn_val, gen_index, "readonly"); } if (param_type->id == TypeTableEntryIdPointer) { - ZigLLVMAddNonNullAttr(fn_val, gen_index + 1); + addLLVMArgAttr(fn_val, gen_index, "nonnull"); } if (is_byval) { - // TODO - //LLVMAddAttribute(argument_val, LLVMByValAttribute); + // TODO add byval attr? } } @@ -3613,10 +3626,8 @@ static void define_builtin_types(CodeGen *g) { buf_init_from_str(&entry->name, info->name); 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 = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), debug_size_in_bits, - debug_align_in_bits, 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; @@ -3630,10 +3641,8 @@ static void define_builtin_types(CodeGen *g) { entry->type_ref = LLVMInt1Type(); 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 = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), debug_size_in_bits, - debug_align_in_bits, ZigLLVMEncoding_DW_ATE_boolean()); g->builtin_types.entry_bool = entry; g->primitive_type_table.put(&entry->name, entry); @@ -3653,10 +3662,8 @@ static void define_builtin_types(CodeGen *g) { entry->data.integral.bit_count = g->pointer_size_bytes * 8; 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 = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), debug_size_in_bits, - debug_align_in_bits, is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned()); g->primitive_type_table.put(&entry->name, entry); @@ -3673,10 +3680,8 @@ static void define_builtin_types(CodeGen *g) { entry->data.floating.bit_count = 32; 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 = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), debug_size_in_bits, - debug_align_in_bits, ZigLLVMEncoding_DW_ATE_float()); g->builtin_types.entry_f32 = entry; g->primitive_type_table.put(&entry->name, entry); @@ -3688,10 +3693,8 @@ static void define_builtin_types(CodeGen *g) { entry->data.floating.bit_count = 64; 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 = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), debug_size_in_bits, - debug_align_in_bits, ZigLLVMEncoding_DW_ATE_float()); g->builtin_types.entry_f64 = entry; g->primitive_type_table.put(&entry->name, entry); @@ -3703,10 +3706,8 @@ static void define_builtin_types(CodeGen *g) { entry->data.floating.bit_count = 80; 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 = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), debug_size_in_bits, - debug_align_in_bits, ZigLLVMEncoding_DW_ATE_float()); g->builtin_types.entry_c_long_double = entry; g->primitive_type_table.put(&entry->name, entry); @@ -3717,7 +3718,6 @@ static void define_builtin_types(CodeGen *g) { entry->zero_bits = true; buf_init_from_str(&entry->name, "void"); entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), - 0, 0, ZigLLVMEncoding_DW_ATE_unsigned()); g->builtin_types.entry_void = entry; @@ -4098,9 +4098,10 @@ static void init(CodeGen *g, Buf *source_path) { bool is_optimized = g->is_release_build; const char *flags = ""; unsigned runtime_version = 0; + ZigLLVMDIFile *compile_unit_file = ZigLLVMCreateFile(g->dbuilder, buf_ptr(source_path), + buf_ptr(&g->root_package->root_src_dir)); 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, + compile_unit_file, buf_ptr(producer), is_optimized, flags, runtime_version, "", 0, !g->strip_debug_symbols); // This is for debug stuff that doesn't have a real file. diff --git a/src/parseh.cpp b/src/parseh.cpp index ca7d9e1cd8..810acf07bf 100644 --- a/src/parseh.cpp +++ b/src/parseh.cpp @@ -466,6 +466,9 @@ static TypeTableEntry *resolve_type_with_table(Context *c, const Type *ty, const case CC_X86_64SysV: // __attribute__((sysv_abi)) emit_warning(c, decl, "function type has x86 64sysv calling convention"); return c->codegen->builtin_types.entry_invalid; + case CC_X86RegCall: + emit_warning(c, decl, "function type has x86 reg calling convention"); + return c->codegen->builtin_types.entry_invalid; case CC_AAPCS: // __attribute__((pcs("aapcs"))) emit_warning(c, decl, "function type has aapcs calling convention"); return c->codegen->builtin_types.entry_invalid; @@ -598,6 +601,7 @@ static TypeTableEntry *resolve_type_with_table(Context *c, const Type *ty, const case Type::ObjCObjectPointer: case Type::Atomic: case Type::Pipe: + case Type::ObjCTypeParam: emit_warning(c, decl, "missed a '%s' type", ty->getTypeClassName()); return c->codegen->builtin_types.entry_invalid; } diff --git a/src/target.cpp b/src/target.cpp index 1f43a4f176..cca869e471 100644 --- a/src/target.cpp +++ b/src/target.cpp @@ -351,6 +351,8 @@ void resolve_target_object_format(ZigTarget *target) { case ZigLLVM_r600: case ZigLLVM_renderscript32: case ZigLLVM_renderscript64: + case ZigLLVM_riscv32: + case ZigLLVM_riscv64: case ZigLLVM_shave: case ZigLLVM_sparc: case ZigLLVM_sparcel: @@ -359,6 +361,7 @@ void resolve_target_object_format(ZigTarget *target) { case ZigLLVM_spir64: case ZigLLVM_systemz: case ZigLLVM_tce: + case ZigLLVM_tcele: case ZigLLVM_thumbeb: case ZigLLVM_wasm32: case ZigLLVM_wasm64: @@ -396,9 +399,11 @@ static int get_arch_pointer_bit_width(ZigLLVM_ArchType arch) { case ZigLLVM_nvptx: case ZigLLVM_ppc: case ZigLLVM_r600: + case ZigLLVM_riscv32: case ZigLLVM_sparc: case ZigLLVM_sparcel: case ZigLLVM_tce: + case ZigLLVM_tcele: case ZigLLVM_thumb: case ZigLLVM_thumbeb: case ZigLLVM_x86: @@ -424,6 +429,7 @@ static int get_arch_pointer_bit_width(ZigLLVM_ArchType arch) { case ZigLLVM_nvptx64: case ZigLLVM_ppc64: case ZigLLVM_ppc64le: + case ZigLLVM_riscv64: case ZigLLVM_sparcv9: case ZigLLVM_systemz: case ZigLLVM_x86_64: @@ -515,6 +521,8 @@ int get_c_type_size_in_bits(const ZigTarget *target, CIntType id) { case ZigLLVM_TvOS: case ZigLLVM_WatchOS: case ZigLLVM_Mesa3D: + case ZigLLVM_Fuchsia: + case ZigLLVM_Contiki: zig_panic("TODO c type size in bits for this target"); } zig_unreachable(); diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp index c59a533a05..21ea54b794 100644 --- a/src/zig_llvm.cpp +++ b/src/zig_llvm.cpp @@ -137,15 +137,6 @@ LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *A return wrap(unwrap(B)->Insert(call_inst)); } -void ZigLLVMAddNonNullAttr(LLVMValueRef fn, unsigned i) -{ - assert( isa(unwrap(fn)) ); - - Function *unwrapped_function = reinterpret_cast(unwrap(fn)); - - unwrapped_function->addAttribute(i, Attribute::NonNull); -} - void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) { assert( isa(unwrap(fn)) ); Function *unwrapped_function = reinterpret_cast(unwrap(fn)); @@ -162,10 +153,10 @@ ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLV } ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name, - uint64_t size_in_bits, uint64_t align_in_bits, unsigned encoding) + uint64_t size_in_bits, unsigned encoding) { DIType *di_type = reinterpret_cast(dibuilder)->createBasicType( - name, size_in_bits, align_in_bits, encoding); + name, size_in_bits, encoding); return reinterpret_cast(di_type); } @@ -211,11 +202,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugMemberType(ZigLLVMDIBuilder *dibuilder, ZigLLVM 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) { + assert(flags == 0); DIType *di_type = reinterpret_cast(dibuilder)->createMemberType( reinterpret_cast(scope), name, reinterpret_cast(file), - line, size_in_bits, align_in_bits, offset_in_bits, flags, + line, size_in_bits, align_in_bits, offset_in_bits, DINode::FlagZero, reinterpret_cast(type)); return reinterpret_cast(di_type); } @@ -230,11 +222,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMD DIType *ditype = reinterpret_cast(types_array[i]); fields.push_back(ditype); } + assert(flags == 0); DIType *di_type = reinterpret_cast(dibuilder)->createUnionType( reinterpret_cast(scope), name, reinterpret_cast(file), - line_number, size_in_bits, align_in_bits, flags, + line_number, size_in_bits, align_in_bits, DINode::FlagZero, reinterpret_cast(dibuilder)->getOrCreateArray(fields), run_time_lang, unique_id); return reinterpret_cast(di_type); @@ -251,11 +244,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVM DIType *ditype = reinterpret_cast(types_array[i]); fields.push_back(ditype); } + assert(flags == 0); DIType *di_type = reinterpret_cast(dibuilder)->createStructType( reinterpret_cast(scope), name, reinterpret_cast(file), - line_number, size_in_bits, align_in_bits, flags, + line_number, size_in_bits, align_in_bits, DINode::FlagZero, reinterpret_cast(derived_from), reinterpret_cast(dibuilder)->getOrCreateArray(fields), run_time_lang, @@ -316,10 +310,11 @@ ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped, DIType *ditype = reinterpret_cast(types_array[i]); types.push_back(ditype); } + assert(flags == 0); DIBuilder *dibuilder = reinterpret_cast(dibuilder_wrapped); DISubroutineType *subroutine_type = dibuilder->createSubroutineType( dibuilder->getOrCreateTypeArray(types), - flags); + DINode::FlagZero); DIType *ditype = subroutine_type; return reinterpret_cast(ditype); } @@ -390,6 +385,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder, ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no, ZigLLVMDIType *type, bool always_preserve, unsigned flags) { + assert(flags == 0); DILocalVariable *result = reinterpret_cast(dbuilder)->createAutoVariable( reinterpret_cast(scope), name, @@ -397,23 +393,22 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder, line_no, reinterpret_cast(type), always_preserve, - flags); + DINode::FlagZero); return reinterpret_cast(result); } 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) + unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit) { - DIGlobalVariable *result = reinterpret_cast(dbuilder)->createGlobalVariable( + DIGlobalVariableExpression *result = reinterpret_cast(dbuilder)->createGlobalVariableExpression( reinterpret_cast(scope), name, linkage_name, reinterpret_cast(file), line_no, reinterpret_cast(di_type), - is_local_to_unit, - reinterpret_cast(constant_val)); + is_local_to_unit); return reinterpret_cast(result); } @@ -421,6 +416,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilde ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no, ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no) { + assert(flags == 0); DILocalVariable *result = reinterpret_cast(dbuilder)->createParameterVariable( reinterpret_cast(scope), name, @@ -429,7 +425,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilde line_no, reinterpret_cast(type), always_preserve, - flags); + DINode::FlagZero); return reinterpret_cast(result); } @@ -459,12 +455,16 @@ ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type) { } ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder, - unsigned lang, const char *file, const char *dir, const char *producer, + unsigned lang, ZigLLVMDIFile *difile, 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); + lang, + reinterpret_cast(difile), + producer, is_optimized, flags, runtime_version, split_name, + (emit_debug_info ? DICompileUnit::DebugEmissionKind::FullDebug : DICompileUnit::DebugEmissionKind::NoDebug), + dwo_id); return reinterpret_cast(result); } @@ -480,13 +480,14 @@ ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMD unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram) { DISubroutineType *di_sub_type = static_cast(reinterpret_cast(fn_di_type)); + assert(flags == 0); DISubprogram *result = reinterpret_cast(dibuilder)->createFunction( reinterpret_cast(scope), name, linkage_name, reinterpret_cast(file), lineno, di_sub_type, - is_local_to_unit, is_definition, scope_line, flags, is_optimized, + is_local_to_unit, is_definition, scope_line, DINode::FlagZero, is_optimized, nullptr, reinterpret_cast(decl_subprogram)); return reinterpret_cast(result); @@ -581,19 +582,19 @@ static_assert((Triple::ObjectFormatType)ZigLLVM_ELF == Triple::ELF, ""); static_assert((Triple::ObjectFormatType)ZigLLVM_MachO == Triple::MachO, ""); const char *ZigLLVMGetArchTypeName(ZigLLVM_ArchType arch) { - return Triple::getArchTypeName((Triple::ArchType)arch); + return (const char*)Triple::getArchTypeName((Triple::ArchType)arch).bytes_begin(); } const char *ZigLLVMGetVendorTypeName(ZigLLVM_VendorType vendor) { - return Triple::getVendorTypeName((Triple::VendorType)vendor); + return (const char*)Triple::getVendorTypeName((Triple::VendorType)vendor).bytes_begin(); } const char *ZigLLVMGetOSTypeName(ZigLLVM_OSType os) { - return Triple::getOSTypeName((Triple::OSType)os); + return (const char*)Triple::getOSTypeName((Triple::OSType)os).bytes_begin(); } const char *ZigLLVMGetEnvironmentTypeName(ZigLLVM_EnvironmentType env_type) { - return Triple::getEnvironmentTypeName((Triple::EnvironmentType)env_type); + return (const char*)Triple::getEnvironmentTypeName((Triple::EnvironmentType)env_type).bytes_begin(); } void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *sub_arch_type, @@ -623,6 +624,8 @@ const char *ZigLLVMGetSubArchTypeName(ZigLLVM_SubArchType sub_arch) { return "v8_1a"; case ZigLLVM_ARMSubArch_v8: return "v8"; + case ZigLLVM_ARMSubArch_v8r: + return "v8r"; case ZigLLVM_ARMSubArch_v8m_baseline: return "v8m_baseline"; case ZigLLVM_ARMSubArch_v8m_mainline: @@ -704,14 +707,6 @@ LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMVa return wrap(unwrap(builder)->CreateShl(unwrap(LHS), unwrap(RHS), name, false, true)); } -LLVMValueRef ZigLLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS, - LLVMValueRef RHS, const char *Name) -{ - return wrap(unwrap(B)->CreateExactUDiv(unwrap(LHS), unwrap(RHS), Name)); -} - - - //------------------------------------ #include "buffer.hpp" diff --git a/src/zig_llvm.hpp b/src/zig_llvm.hpp index 0062757b95..8e73fffc93 100644 --- a/src/zig_llvm.hpp +++ b/src/zig_llvm.hpp @@ -47,17 +47,12 @@ LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMVa const char *name); LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, const char *name); -LLVMValueRef ZigLLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS, - LLVMValueRef RHS, const char *Name); - -// 0 is return value, 1 is first arg -void ZigLLVMAddNonNullAttr(LLVMValueRef fn, unsigned i); ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *pointee_type, uint64_t size_in_bits, uint64_t align_in_bits, const char *name); ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name, - uint64_t size_in_bits, uint64_t align_in_bits, unsigned encoding); + uint64_t size_in_bits, unsigned encoding); ZigLLVMDIType *ZigLLVMCreateDebugArrayType(ZigLLVMDIBuilder *dibuilder, uint64_t size_in_bits, uint64_t align_in_bits, ZigLLVMDIType *elem_type, @@ -128,7 +123,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder, 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); + unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit); ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilder, ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no, @@ -138,7 +133,7 @@ ZigLLVMDILexicalBlock *ZigLLVMCreateLexicalBlock(ZigLLVMDIBuilder *dbuilder, Zig ZigLLVMDIFile *file, unsigned line, unsigned col); ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder, - unsigned lang, const char *file, const char *dir, const char *producer, + unsigned lang, ZigLLVMDIFile *difile, const char *producer, bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name, uint64_t dwo_id, bool emit_debug_info); @@ -173,55 +168,58 @@ unsigned ZigLLVMGetPrefTypeAlignment(LLVMTargetDataRef TD, LLVMTypeRef Ty); // copied from include/llvm/ADT/Triple.h enum ZigLLVM_ArchType { - ZigLLVM_UnknownArch, + ZigLLVM_UnknownArch, - ZigLLVM_arm, // ARM (little endian): arm, armv.*, xscale - ZigLLVM_armeb, // ARM (big endian): armeb - ZigLLVM_aarch64, // AArch64 (little endian): aarch64 - ZigLLVM_aarch64_be, // AArch64 (big endian): aarch64_be - ZigLLVM_avr, // AVR: Atmel AVR microcontroller - ZigLLVM_bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) - ZigLLVM_bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian) - ZigLLVM_hexagon, // Hexagon: hexagon - ZigLLVM_mips, // MIPS: mips, mipsallegrex - ZigLLVM_mipsel, // MIPSEL: mipsel, mipsallegrexel - ZigLLVM_mips64, // MIPS64: mips64 - ZigLLVM_mips64el, // MIPS64EL: mips64el - ZigLLVM_msp430, // MSP430: msp430 - ZigLLVM_ppc, // PPC: powerpc - ZigLLVM_ppc64, // PPC64: powerpc64, ppu - ZigLLVM_ppc64le, // PPC64LE: powerpc64le - ZigLLVM_r600, // R600: AMD GPUs HD2XXX - HD6XXX - ZigLLVM_amdgcn, // AMDGCN: AMD GCN GPUs - ZigLLVM_sparc, // Sparc: sparc - ZigLLVM_sparcv9, // Sparcv9: Sparcv9 - ZigLLVM_sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant - ZigLLVM_systemz, // SystemZ: s390x - ZigLLVM_tce, // TCE (http://tce.cs.tut.fi/): tce - ZigLLVM_thumb, // Thumb (little endian): thumb, thumbv.* - ZigLLVM_thumbeb, // Thumb (big endian): thumbeb - ZigLLVM_x86, // X86: i[3-9]86 - ZigLLVM_x86_64, // X86-64: amd64, x86_64 - ZigLLVM_xcore, // XCore: xcore - ZigLLVM_nvptx, // NVPTX: 32-bit - ZigLLVM_nvptx64, // NVPTX: 64-bit - ZigLLVM_le32, // le32: generic little-endian 32-bit CPU (PNaCl) - ZigLLVM_le64, // le64: generic little-endian 64-bit CPU (PNaCl) - ZigLLVM_amdil, // AMDIL - ZigLLVM_amdil64, // AMDIL with 64-bit pointers - ZigLLVM_hsail, // AMD HSAIL - ZigLLVM_hsail64, // AMD HSAIL with 64-bit pointers - ZigLLVM_spir, // SPIR: standard portable IR for OpenCL 32-bit version - ZigLLVM_spir64, // SPIR: standard portable IR for OpenCL 64-bit version - ZigLLVM_kalimba, // Kalimba: generic kalimba - ZigLLVM_shave, // SHAVE: Movidius vector VLIW processors - ZigLLVM_lanai, // Lanai: Lanai 32-bit - ZigLLVM_wasm32, // WebAssembly with 32-bit pointers - ZigLLVM_wasm64, // WebAssembly with 64-bit pointers - ZigLLVM_renderscript32, // 32-bit RenderScript - ZigLLVM_renderscript64, // 64-bit RenderScript + ZigLLVM_arm, // ARM (little endian): arm, armv.*, xscale + ZigLLVM_armeb, // ARM (big endian): armeb + ZigLLVM_aarch64, // AArch64 (little endian): aarch64 + ZigLLVM_aarch64_be, // AArch64 (big endian): aarch64_be + ZigLLVM_avr, // AVR: Atmel AVR microcontroller + ZigLLVM_bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) + ZigLLVM_bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian) + ZigLLVM_hexagon, // Hexagon: hexagon + ZigLLVM_mips, // MIPS: mips, mipsallegrex + ZigLLVM_mipsel, // MIPSEL: mipsel, mipsallegrexel + ZigLLVM_mips64, // MIPS64: mips64 + ZigLLVM_mips64el, // MIPS64EL: mips64el + ZigLLVM_msp430, // MSP430: msp430 + ZigLLVM_ppc, // PPC: powerpc + ZigLLVM_ppc64, // PPC64: powerpc64, ppu + ZigLLVM_ppc64le, // PPC64LE: powerpc64le + ZigLLVM_r600, // R600: AMD GPUs HD2XXX - HD6XXX + ZigLLVM_amdgcn, // AMDGCN: AMD GCN GPUs + ZigLLVM_riscv32, // RISC-V (32-bit): riscv32 + ZigLLVM_riscv64, // RISC-V (64-bit): riscv64 + ZigLLVM_sparc, // Sparc: sparc + ZigLLVM_sparcv9, // Sparcv9: Sparcv9 + ZigLLVM_sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant + ZigLLVM_systemz, // SystemZ: s390x + ZigLLVM_tce, // TCE (http://tce.cs.tut.fi/): tce + ZigLLVM_tcele, // TCE little endian (http://tce.cs.tut.fi/): tcele + ZigLLVM_thumb, // Thumb (little endian): thumb, thumbv.* + ZigLLVM_thumbeb, // Thumb (big endian): thumbeb + ZigLLVM_x86, // X86: i[3-9]86 + ZigLLVM_x86_64, // X86-64: amd64, x86_64 + ZigLLVM_xcore, // XCore: xcore + ZigLLVM_nvptx, // NVPTX: 32-bit + ZigLLVM_nvptx64, // NVPTX: 64-bit + ZigLLVM_le32, // le32: generic little-endian 32-bit CPU (PNaCl) + ZigLLVM_le64, // le64: generic little-endian 64-bit CPU (PNaCl) + ZigLLVM_amdil, // AMDIL + ZigLLVM_amdil64, // AMDIL with 64-bit pointers + ZigLLVM_hsail, // AMD HSAIL + ZigLLVM_hsail64, // AMD HSAIL with 64-bit pointers + ZigLLVM_spir, // SPIR: standard portable IR for OpenCL 32-bit version + ZigLLVM_spir64, // SPIR: standard portable IR for OpenCL 64-bit version + ZigLLVM_kalimba, // Kalimba: generic kalimba + ZigLLVM_shave, // SHAVE: Movidius vector VLIW processors + ZigLLVM_lanai, // Lanai: Lanai 32-bit + ZigLLVM_wasm32, // WebAssembly with 32-bit pointers + ZigLLVM_wasm64, // WebAssembly with 64-bit pointers + ZigLLVM_renderscript32, // 32-bit RenderScript + ZigLLVM_renderscript64, // 64-bit RenderScript - ZigLLVM_LastArchType = ZigLLVM_renderscript64 + ZigLLVM_LastArchType = ZigLLVM_renderscript64 }; enum ZigLLVM_SubArchType { @@ -230,6 +228,7 @@ enum ZigLLVM_SubArchType { ZigLLVM_ARMSubArch_v8_2a, ZigLLVM_ARMSubArch_v8_1a, ZigLLVM_ARMSubArch_v8, + ZigLLVM_ARMSubArch_v8r, ZigLLVM_ARMSubArch_v8m_baseline, ZigLLVM_ARMSubArch_v8m_mainline, ZigLLVM_ARMSubArch_v7, @@ -247,86 +246,93 @@ enum ZigLLVM_SubArchType { ZigLLVM_KalimbaSubArch_v3, ZigLLVM_KalimbaSubArch_v4, - ZigLLVM_KalimbaSubArch_v5 + ZigLLVM_KalimbaSubArch_v5, }; + enum ZigLLVM_VendorType { - ZigLLVM_UnknownVendor, + ZigLLVM_UnknownVendor, - ZigLLVM_Apple, - ZigLLVM_PC, - ZigLLVM_SCEI, - ZigLLVM_BGP, - ZigLLVM_BGQ, - ZigLLVM_Freescale, - ZigLLVM_IBM, - ZigLLVM_ImaginationTechnologies, - ZigLLVM_MipsTechnologies, - ZigLLVM_NVIDIA, - ZigLLVM_CSR, - ZigLLVM_Myriad, - ZigLLVM_AMD, - ZigLLVM_Mesa, + ZigLLVM_Apple, + ZigLLVM_PC, + ZigLLVM_SCEI, + ZigLLVM_BGP, + ZigLLVM_BGQ, + ZigLLVM_Freescale, + ZigLLVM_IBM, + ZigLLVM_ImaginationTechnologies, + ZigLLVM_MipsTechnologies, + ZigLLVM_NVIDIA, + ZigLLVM_CSR, + ZigLLVM_Myriad, + ZigLLVM_AMD, + ZigLLVM_Mesa, - ZigLLVM_LastVendorType = ZigLLVM_Mesa + ZigLLVM_LastVendorType = ZigLLVM_Mesa }; + enum ZigLLVM_OSType { - ZigLLVM_UnknownOS, + ZigLLVM_UnknownOS, - ZigLLVM_CloudABI, - ZigLLVM_Darwin, - ZigLLVM_DragonFly, - ZigLLVM_FreeBSD, - ZigLLVM_IOS, - ZigLLVM_KFreeBSD, - ZigLLVM_Linux, - ZigLLVM_Lv2, // PS3 - ZigLLVM_MacOSX, - ZigLLVM_NetBSD, - ZigLLVM_OpenBSD, - ZigLLVM_Solaris, - ZigLLVM_Win32, - ZigLLVM_Haiku, - ZigLLVM_Minix, - ZigLLVM_RTEMS, - ZigLLVM_NaCl, // Native Client - ZigLLVM_CNK, // BG/P Compute-Node Kernel - ZigLLVM_Bitrig, - ZigLLVM_AIX, - ZigLLVM_CUDA, // NVIDIA CUDA - ZigLLVM_NVCL, // NVIDIA OpenCL - ZigLLVM_AMDHSA, // AMD HSA Runtime - ZigLLVM_PS4, - ZigLLVM_ELFIAMCU, - ZigLLVM_TvOS, // Apple tvOS - ZigLLVM_WatchOS, // Apple watchOS - ZigLLVM_Mesa3D, + ZigLLVM_CloudABI, + ZigLLVM_Darwin, + ZigLLVM_DragonFly, + ZigLLVM_FreeBSD, + ZigLLVM_Fuchsia, + ZigLLVM_IOS, + ZigLLVM_KFreeBSD, + ZigLLVM_Linux, + ZigLLVM_Lv2, // PS3 + ZigLLVM_MacOSX, + ZigLLVM_NetBSD, + ZigLLVM_OpenBSD, + ZigLLVM_Solaris, + ZigLLVM_Win32, + ZigLLVM_Haiku, + ZigLLVM_Minix, + ZigLLVM_RTEMS, + ZigLLVM_NaCl, // Native Client + ZigLLVM_CNK, // BG/P Compute-Node Kernel + ZigLLVM_Bitrig, + ZigLLVM_AIX, + ZigLLVM_CUDA, // NVIDIA CUDA + ZigLLVM_NVCL, // NVIDIA OpenCL + ZigLLVM_AMDHSA, // AMD HSA Runtime + ZigLLVM_PS4, + ZigLLVM_ELFIAMCU, + ZigLLVM_TvOS, // Apple tvOS + ZigLLVM_WatchOS, // Apple watchOS + ZigLLVM_Mesa3D, + ZigLLVM_Contiki, - ZigLLVM_LastOSType = ZigLLVM_Mesa3D + ZigLLVM_LastOSType = ZigLLVM_Contiki }; + enum ZigLLVM_EnvironmentType { - ZigLLVM_UnknownEnvironment, + ZigLLVM_UnknownEnvironment, - ZigLLVM_GNU, - ZigLLVM_GNUABI64, - ZigLLVM_GNUEABI, - ZigLLVM_GNUEABIHF, - ZigLLVM_GNUX32, - ZigLLVM_CODE16, - ZigLLVM_EABI, - ZigLLVM_EABIHF, - ZigLLVM_Android, - ZigLLVM_Musl, - ZigLLVM_MuslEABI, - ZigLLVM_MuslEABIHF, + ZigLLVM_GNU, + ZigLLVM_GNUABI64, + ZigLLVM_GNUEABI, + ZigLLVM_GNUEABIHF, + ZigLLVM_GNUX32, + ZigLLVM_CODE16, + ZigLLVM_EABI, + ZigLLVM_EABIHF, + ZigLLVM_Android, + ZigLLVM_Musl, + ZigLLVM_MuslEABI, + ZigLLVM_MuslEABIHF, - ZigLLVM_MSVC, - ZigLLVM_Itanium, - ZigLLVM_Cygnus, - ZigLLVM_AMDOpenCL, - ZigLLVM_CoreCLR, + ZigLLVM_MSVC, + ZigLLVM_Itanium, + ZigLLVM_Cygnus, + ZigLLVM_AMDOpenCL, + ZigLLVM_CoreCLR, + ZigLLVM_OpenCL, - ZigLLVM_LastEnvironmentType = ZigLLVM_CoreCLR + ZigLLVM_LastEnvironmentType = ZigLLVM_OpenCL }; + enum ZigLLVM_ObjectFormatType { ZigLLVM_UnknownObjectFormat,