Commit cd31f875a6
Changed files (9)
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})
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
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;
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.
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;
}
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();
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<Function>(unwrap(fn)) );
-
- Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
-
- unwrapped_function->addAttribute(i, Attribute::NonNull);
-}
-
void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
assert( isa<Function>(unwrap(fn)) );
Function *unwrapped_function = reinterpret_cast<Function*>(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*>(dibuilder)->createBasicType(
- name, size_in_bits, align_in_bits, encoding);
+ name, size_in_bits, encoding);
return reinterpret_cast<ZigLLVMDIType*>(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*>(dibuilder)->createMemberType(
reinterpret_cast<DIScope*>(scope),
name,
reinterpret_cast<DIFile*>(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<DIType*>(type));
return reinterpret_cast<ZigLLVMDIType*>(di_type);
}
@@ -230,11 +222,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMD
DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
fields.push_back(ditype);
}
+ assert(flags == 0);
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createUnionType(
reinterpret_cast<DIScope*>(scope),
name,
reinterpret_cast<DIFile*>(file),
- line_number, size_in_bits, align_in_bits, flags,
+ line_number, size_in_bits, align_in_bits, DINode::FlagZero,
reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
run_time_lang, unique_id);
return reinterpret_cast<ZigLLVMDIType*>(di_type);
@@ -251,11 +244,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVM
DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
fields.push_back(ditype);
}
+ assert(flags == 0);
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createStructType(
reinterpret_cast<DIScope*>(scope),
name,
reinterpret_cast<DIFile*>(file),
- line_number, size_in_bits, align_in_bits, flags,
+ line_number, size_in_bits, align_in_bits, DINode::FlagZero,
reinterpret_cast<DIType*>(derived_from),
reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
run_time_lang,
@@ -316,10 +310,11 @@ ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped,
DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
types.push_back(ditype);
}
+ assert(flags == 0);
DIBuilder *dibuilder = reinterpret_cast<DIBuilder*>(dibuilder_wrapped);
DISubroutineType *subroutine_type = dibuilder->createSubroutineType(
dibuilder->getOrCreateTypeArray(types),
- flags);
+ DINode::FlagZero);
DIType *ditype = subroutine_type;
return reinterpret_cast<ZigLLVMDIType*>(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<DIBuilder*>(dbuilder)->createAutoVariable(
reinterpret_cast<DIScope*>(scope),
name,
@@ -397,23 +393,22 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
line_no,
reinterpret_cast<DIType*>(type),
always_preserve,
- flags);
+ DINode::FlagZero);
return reinterpret_cast<ZigLLVMDILocalVariable*>(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<DIBuilder*>(dbuilder)->createGlobalVariable(
+ DIGlobalVariableExpression *result = reinterpret_cast<DIBuilder*>(dbuilder)->createGlobalVariableExpression(
reinterpret_cast<DIScope*>(scope),
name,
linkage_name,
reinterpret_cast<DIFile*>(file),
line_no,
reinterpret_cast<DIType*>(di_type),
- is_local_to_unit,
- reinterpret_cast<llvm::Constant *>(constant_val));
+ is_local_to_unit);
return reinterpret_cast<ZigLLVMDIGlobalVariable*>(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<DIBuilder*>(dbuilder)->createParameterVariable(
reinterpret_cast<DIScope*>(scope),
name,
@@ -429,7 +425,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilde
line_no,
reinterpret_cast<DIType*>(type),
always_preserve,
- flags);
+ DINode::FlagZero);
return reinterpret_cast<ZigLLVMDILocalVariable*>(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*>(dibuilder)->createCompileUnit(
- lang, file, dir, producer, is_optimized, flags, runtime_version, split_name);
+ lang,
+ reinterpret_cast<DIFile*>(difile),
+ producer, is_optimized, flags, runtime_version, split_name,
+ (emit_debug_info ? DICompileUnit::DebugEmissionKind::FullDebug : DICompileUnit::DebugEmissionKind::NoDebug),
+ dwo_id);
return reinterpret_cast<ZigLLVMDICompileUnit*>(result);
}
@@ -480,13 +480,14 @@ ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMD
unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram)
{
DISubroutineType *di_sub_type = static_cast<DISubroutineType*>(reinterpret_cast<DIType*>(fn_di_type));
+ assert(flags == 0);
DISubprogram *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFunction(
reinterpret_cast<DIScope*>(scope),
name, linkage_name,
reinterpret_cast<DIFile*>(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<DISubprogram *>(decl_subprogram));
return reinterpret_cast<ZigLLVMDISubprogram*>(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"
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_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_LastArchType = ZigLLVM_renderscript64
+ 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_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
};
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_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_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_LastVendorType = ZigLLVM_Mesa
};
+
enum ZigLLVM_OSType {
- 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_LastOSType = ZigLLVM_Mesa3D
+ ZigLLVM_UnknownOS,
+
+ 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_Contiki
};
+
enum ZigLLVM_EnvironmentType {
- 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_MSVC,
- ZigLLVM_Itanium,
- ZigLLVM_Cygnus,
- ZigLLVM_AMDOpenCL,
- ZigLLVM_CoreCLR,
-
- ZigLLVM_LastEnvironmentType = ZigLLVM_CoreCLR
+ 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_MSVC,
+ ZigLLVM_Itanium,
+ ZigLLVM_Cygnus,
+ ZigLLVM_AMDOpenCL,
+ ZigLLVM_CoreCLR,
+ ZigLLVM_OpenCL,
+
+ ZigLLVM_LastEnvironmentType = ZigLLVM_OpenCL
};
+
enum ZigLLVM_ObjectFormatType {
ZigLLVM_UnknownObjectFormat,
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