Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update to llvm 4.0

Browse Source
This commit is contained in:
Andrew Kelley 2017-03-10 02:29:01 -05:00
parent 47f267d25f
commit cd31f875a6
9 changed files with 210 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -87,8 +87,8 @@ the Zig compiler itself:
These libraries must be installed on your system, with the development files These libraries must be installed on your system, with the development files
available. The Zig compiler dynamically links against them. available. The Zig compiler dynamically links against them.
* LLVM == 3.9.x * LLVM == 4.x
* libclang == 3.9.x * libclang == 4.x
### Debug / Development Build ### Debug / Development Build

4
cmake/Findclang.cmake
View File

@ -8,14 +8,14 @@
find_path(CLANG_INCLUDE_DIRS NAMES clang/Frontend/ASTUnit.h find_path(CLANG_INCLUDE_DIRS NAMES clang/Frontend/ASTUnit.h
PATHS PATHS
/usr/lib/llvm-3.9/include /usr/lib/llvm-4/include
/mingw64/include) /mingw64/include)
macro(FIND_AND_ADD_CLANG_LIB _libname_) macro(FIND_AND_ADD_CLANG_LIB _libname_)
string(TOUPPER ${_libname_} _prettylibname_) string(TOUPPER ${_libname_} _prettylibname_)
find_library(CLANG_${_prettylibname_}_LIB NAMES ${_libname_} find_library(CLANG_${_prettylibname_}_LIB NAMES ${_libname_}
PATHS PATHS
/usr/lib/llvm-3.9/lib /usr/lib/llvm-4/lib
/mingw64/lib) /mingw64/lib)
if(CLANG_${_prettylibname_}_LIB) if(CLANG_${_prettylibname_}_LIB)
set(CLANG_LIBRARIES ${CLANG_LIBRARIES} ${CLANG_${_prettylibname_}_LIB}) set(CLANG_LIBRARIES ${CLANG_LIBRARIES} ${CLANG_${_prettylibname_}_LIB})

2
cmake/Findllvm.cmake
View File

@ -7,7 +7,7 @@
# LLVM_LIBRARIES # LLVM_LIBRARIES
# LLVM_LIBDIRS # 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( execute_process(
COMMAND ${LLVM_CONFIG_EXE} --libs COMMAND ${LLVM_CONFIG_EXE} --libs

4
src/analyze.cpp
View File

@ -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_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, dwarf_tag);
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.is_signed = is_signed;
entry->data.integral.bit_count = size_in_bits; entry->data.integral.bit_count = size_in_bits;
return entry; return entry;

67
src/codegen.cpp
View File

@ -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 void render_const_val_global(CodeGen *g, ConstExprValue *const_val, const char *name);
static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val); 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) { static LLVMValueRef fn_llvm_value(CodeGen *g, FnTableEntry *fn_table_entry) {
if (fn_table_entry->llvm_value) if (fn_table_entry->llvm_value)
return 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) { switch (fn_table_entry->fn_inline) {
case FnInlineAlways: case FnInlineAlways:
LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMAlwaysInlineAttribute); addLLVMFnAttr(fn_table_entry->llvm_value, "alwaysinline");
break; break;
case FnInlineNever: case FnInlineNever:
LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoInlineAttribute); addLLVMFnAttr(fn_table_entry->llvm_value, "noinline");
break; break;
case FnInlineAuto: case FnInlineAuto:
break; break;
} }
if (fn_type->data.fn.fn_type_id.is_naked) { 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 ? LLVMSetLinkage(fn_table_entry->llvm_value, fn_table_entry->internal_linkage ?
LLVMInternalLinkage : LLVMExternalLinkage); LLVMInternalLinkage : LLVMExternalLinkage);
if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdUnreachable) { 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); LLVMSetFunctionCallConv(fn_table_entry->llvm_value, fn_type->data.fn.calling_convention);
if (fn_type->data.fn.fn_type_id.is_cold) { if (fn_type->data.fn.fn_type_id.is_cold) {
ZigLLVMAddFunctionAttrCold(fn_table_entry->llvm_value); 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) { 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", "true");
ZigLLVMAddFunctionAttr(fn_table_entry->llvm_value, "no-frame-pointer-elim-non-leaf", nullptr); 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) { if (type_entry->data.integral.is_signed) {
return LLVMBuildExactSDiv(g->builder, val1, val2, ""); return LLVMBuildExactSDiv(g->builder, val1, val2, "");
} else { } else {
return ZigLLVMBuildExactUDiv(g->builder, val1, val2, ""); return LLVMBuildExactUDiv(g->builder, val1, val2, "");
} }
} else { } else {
if (type_entry->data.integral.is_signed) { 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); 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 { } else {
zig_unreachable(); zig_unreachable();
} }
@ -3183,7 +3198,8 @@ static void gen_global_var(CodeGen *g, VariableTableEntry *var, LLVMValueRef ini
bool is_local_to_unit = true; bool is_local_to_unit = true;
ZigLLVMCreateGlobalVariable(g->dbuilder, get_di_scope(g, var->parent_scope), buf_ptr(&var->name), 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, 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) { 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 || } else if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdPointer ||
fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdFn) 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) && } else if (handle_is_ptr(fn_type->data.fn.fn_type_id.return_type) &&
!fn_type->data.fn.fn_type_id.is_extern) !fn_type->data.fn.fn_type_id.is_extern)
{ {
LLVMValueRef first_arg = LLVMGetParam(fn_val, 0); addLLVMArgAttr(fn_val, 0, "sret");
LLVMAddAttribute(first_arg, LLVMStructRetAttribute); addLLVMArgAttr(fn_val, 0, "nonnull");
ZigLLVMAddNonNullAttr(fn_val, 1);
} }
@ -3307,19 +3322,17 @@ static void do_code_gen(CodeGen *g) {
FnTypeParamInfo *param_info = &fn_type_id->param_info[param_i]; FnTypeParamInfo *param_info = &fn_type_id->param_info[param_i];
TypeTableEntry *param_type = gen_info->type; TypeTableEntry *param_type = gen_info->type;
LLVMValueRef argument_val = LLVMGetParam(fn_val, gen_index);
if (param_info->is_noalias) { 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) { 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) { if (param_type->id == TypeTableEntryIdPointer) {
ZigLLVMAddNonNullAttr(fn_val, gen_index + 1); addLLVMArgAttr(fn_val, gen_index, "nonnull");
} }
if (is_byval) { if (is_byval) {
// TODO // TODO add byval attr?
//LLVMAddAttribute(argument_val, LLVMByValAttribute);
} }
} }
@ -3613,10 +3626,8 @@ static void define_builtin_types(CodeGen *g) {
buf_init_from_str(&entry->name, info->name); 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_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), entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits, debug_size_in_bits,
debug_align_in_bits,
is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned()); is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned());
entry->data.integral.is_signed = is_signed; entry->data.integral.is_signed = is_signed;
entry->data.integral.bit_count = size_in_bits; entry->data.integral.bit_count = size_in_bits;
@ -3630,10 +3641,8 @@ static void define_builtin_types(CodeGen *g) {
entry->type_ref = LLVMInt1Type(); entry->type_ref = LLVMInt1Type();
buf_init_from_str(&entry->name, "bool"); 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_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), entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits, debug_size_in_bits,
debug_align_in_bits,
ZigLLVMEncoding_DW_ATE_boolean()); ZigLLVMEncoding_DW_ATE_boolean());
g->builtin_types.entry_bool = entry; g->builtin_types.entry_bool = entry;
g->primitive_type_table.put(&entry->name, 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; 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_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), entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits, debug_size_in_bits,
debug_align_in_bits,
is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned()); is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned());
g->primitive_type_table.put(&entry->name, entry); 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; entry->data.floating.bit_count = 32;
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref); 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), entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits, debug_size_in_bits,
debug_align_in_bits,
ZigLLVMEncoding_DW_ATE_float()); ZigLLVMEncoding_DW_ATE_float());
g->builtin_types.entry_f32 = entry; g->builtin_types.entry_f32 = entry;
g->primitive_type_table.put(&entry->name, 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; entry->data.floating.bit_count = 64;
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref); 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), entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits, debug_size_in_bits,
debug_align_in_bits,
ZigLLVMEncoding_DW_ATE_float()); ZigLLVMEncoding_DW_ATE_float());
g->builtin_types.entry_f64 = entry; g->builtin_types.entry_f64 = entry;
g->primitive_type_table.put(&entry->name, 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; entry->data.floating.bit_count = 80;
uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref); 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), entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
debug_size_in_bits, debug_size_in_bits,
debug_align_in_bits,
ZigLLVMEncoding_DW_ATE_float()); ZigLLVMEncoding_DW_ATE_float());
g->builtin_types.entry_c_long_double = entry; g->builtin_types.entry_c_long_double = entry;
g->primitive_type_table.put(&entry->name, entry); g->primitive_type_table.put(&entry->name, entry);
@ -3717,7 +3718,6 @@ static void define_builtin_types(CodeGen *g) {
entry->zero_bits = true; entry->zero_bits = true;
buf_init_from_str(&entry->name, "void"); buf_init_from_str(&entry->name, "void");
entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
0,
0, 0,
ZigLLVMEncoding_DW_ATE_unsigned()); ZigLLVMEncoding_DW_ATE_unsigned());
g->builtin_types.entry_void = entry; 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; bool is_optimized = g->is_release_build;
const char *flags = ""; const char *flags = "";
unsigned runtime_version = 0; 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(), g->compile_unit = ZigLLVMCreateCompileUnit(g->dbuilder, ZigLLVMLang_DW_LANG_C99(),
buf_ptr(source_path), buf_ptr(&g->root_package->root_src_dir), compile_unit_file, buf_ptr(producer), is_optimized, flags, runtime_version,
buf_ptr(producer), is_optimized, flags, runtime_version,
"", 0, !g->strip_debug_symbols); "", 0, !g->strip_debug_symbols);
// This is for debug stuff that doesn't have a real file. // This is for debug stuff that doesn't have a real file.

4
src/parseh.cpp
View File

@ -466,6 +466,9 @@ static TypeTableEntry *resolve_type_with_table(Context *c, const Type *ty, const
case CC_X86_64SysV: // __attribute__((sysv_abi)) case CC_X86_64SysV: // __attribute__((sysv_abi))
emit_warning(c, decl, "function type has x86 64sysv calling convention"); emit_warning(c, decl, "function type has x86 64sysv calling convention");
return c->codegen->builtin_types.entry_invalid; 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"))) case CC_AAPCS: // __attribute__((pcs("aapcs")))
emit_warning(c, decl, "function type has aapcs calling convention"); emit_warning(c, decl, "function type has aapcs calling convention");
return c->codegen->builtin_types.entry_invalid; 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::ObjCObjectPointer:
case Type::Atomic: case Type::Atomic:
case Type::Pipe: case Type::Pipe:
case Type::ObjCTypeParam:
emit_warning(c, decl, "missed a '%s' type", ty->getTypeClassName()); emit_warning(c, decl, "missed a '%s' type", ty->getTypeClassName());
return c->codegen->builtin_types.entry_invalid; return c->codegen->builtin_types.entry_invalid;
} }

8
src/target.cpp
View File

@ -351,6 +351,8 @@ void resolve_target_object_format(ZigTarget *target) {
case ZigLLVM_r600: case ZigLLVM_r600:
case ZigLLVM_renderscript32: case ZigLLVM_renderscript32:
case ZigLLVM_renderscript64: case ZigLLVM_renderscript64:
case ZigLLVM_riscv32:
case ZigLLVM_riscv64:
case ZigLLVM_shave: case ZigLLVM_shave:
case ZigLLVM_sparc: case ZigLLVM_sparc:
case ZigLLVM_sparcel: case ZigLLVM_sparcel:
@ -359,6 +361,7 @@ void resolve_target_object_format(ZigTarget *target) {
case ZigLLVM_spir64: case ZigLLVM_spir64:
case ZigLLVM_systemz: case ZigLLVM_systemz:
case ZigLLVM_tce: case ZigLLVM_tce:
case ZigLLVM_tcele:
case ZigLLVM_thumbeb: case ZigLLVM_thumbeb:
case ZigLLVM_wasm32: case ZigLLVM_wasm32:
case ZigLLVM_wasm64: case ZigLLVM_wasm64:
@ -396,9 +399,11 @@ static int get_arch_pointer_bit_width(ZigLLVM_ArchType arch) {
case ZigLLVM_nvptx: case ZigLLVM_nvptx:
case ZigLLVM_ppc: case ZigLLVM_ppc:
case ZigLLVM_r600: case ZigLLVM_r600:
case ZigLLVM_riscv32:
case ZigLLVM_sparc: case ZigLLVM_sparc:
case ZigLLVM_sparcel: case ZigLLVM_sparcel:
case ZigLLVM_tce: case ZigLLVM_tce:
case ZigLLVM_tcele:
case ZigLLVM_thumb: case ZigLLVM_thumb:
case ZigLLVM_thumbeb: case ZigLLVM_thumbeb:
case ZigLLVM_x86: case ZigLLVM_x86:
@ -424,6 +429,7 @@ static int get_arch_pointer_bit_width(ZigLLVM_ArchType arch) {
case ZigLLVM_nvptx64: case ZigLLVM_nvptx64:
case ZigLLVM_ppc64: case ZigLLVM_ppc64:
case ZigLLVM_ppc64le: case ZigLLVM_ppc64le:
case ZigLLVM_riscv64:
case ZigLLVM_sparcv9: case ZigLLVM_sparcv9:
case ZigLLVM_systemz: case ZigLLVM_systemz:
case ZigLLVM_x86_64: 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_TvOS:
case ZigLLVM_WatchOS: case ZigLLVM_WatchOS:
case ZigLLVM_Mesa3D: case ZigLLVM_Mesa3D:
case ZigLLVM_Fuchsia:
case ZigLLVM_Contiki:
zig_panic("TODO c type size in bits for this target"); zig_panic("TODO c type size in bits for this target");
} }
zig_unreachable(); zig_unreachable();

67
src/zig_llvm.cpp
View File

@ -137,15 +137,6 @@ LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *A
return wrap(unwrap(B)->Insert(call_inst)); 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) { void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
assert( isa<Function>(unwrap(fn)) ); assert( isa<Function>(unwrap(fn)) );
Function *unwrapped_function = reinterpret_cast<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, 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( 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); 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, 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) 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( DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createMemberType(
reinterpret_cast<DIScope*>(scope), reinterpret_cast<DIScope*>(scope),
name, name,
reinterpret_cast<DIFile*>(file), 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)); reinterpret_cast<DIType*>(type));
return reinterpret_cast<ZigLLVMDIType*>(di_type); return reinterpret_cast<ZigLLVMDIType*>(di_type);
} }
@ -230,11 +222,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMD
DIType *ditype = reinterpret_cast<DIType*>(types_array[i]); DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
fields.push_back(ditype); fields.push_back(ditype);
} }
assert(flags == 0);
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createUnionType( DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createUnionType(
reinterpret_cast<DIScope*>(scope), reinterpret_cast<DIScope*>(scope),
name, name,
reinterpret_cast<DIFile*>(file), 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), reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
run_time_lang, unique_id); run_time_lang, unique_id);
return reinterpret_cast<ZigLLVMDIType*>(di_type); return reinterpret_cast<ZigLLVMDIType*>(di_type);
@ -251,11 +244,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVM
DIType *ditype = reinterpret_cast<DIType*>(types_array[i]); DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
fields.push_back(ditype); fields.push_back(ditype);
} }
assert(flags == 0);
DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createStructType( DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createStructType(
reinterpret_cast<DIScope*>(scope), reinterpret_cast<DIScope*>(scope),
name, name,
reinterpret_cast<DIFile*>(file), 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<DIType*>(derived_from),
reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields), reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
run_time_lang, run_time_lang,
@ -316,10 +310,11 @@ ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped,
DIType *ditype = reinterpret_cast<DIType*>(types_array[i]); DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
types.push_back(ditype); types.push_back(ditype);
} }
assert(flags == 0);
DIBuilder *dibuilder = reinterpret_cast<DIBuilder*>(dibuilder_wrapped); DIBuilder *dibuilder = reinterpret_cast<DIBuilder*>(dibuilder_wrapped);
DISubroutineType *subroutine_type = dibuilder->createSubroutineType( DISubroutineType *subroutine_type = dibuilder->createSubroutineType(
dibuilder->getOrCreateTypeArray(types), dibuilder->getOrCreateTypeArray(types),
flags); DINode::FlagZero);
DIType *ditype = subroutine_type; DIType *ditype = subroutine_type;
return reinterpret_cast<ZigLLVMDIType*>(ditype); return reinterpret_cast<ZigLLVMDIType*>(ditype);
} }
@ -390,6 +385,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no, ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
ZigLLVMDIType *type, bool always_preserve, unsigned flags) ZigLLVMDIType *type, bool always_preserve, unsigned flags)
{ {
assert(flags == 0);
DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createAutoVariable( DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createAutoVariable(
reinterpret_cast<DIScope*>(scope), reinterpret_cast<DIScope*>(scope),
name, name,
@ -397,23 +393,22 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
line_no, line_no,
reinterpret_cast<DIType*>(type), reinterpret_cast<DIType*>(type),
always_preserve, always_preserve,
flags); DINode::FlagZero);
return reinterpret_cast<ZigLLVMDILocalVariable*>(result); return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
} }
ZigLLVMDIGlobalVariable *ZigLLVMCreateGlobalVariable(ZigLLVMDIBuilder *dbuilder, ZigLLVMDIGlobalVariable *ZigLLVMCreateGlobalVariable(ZigLLVMDIBuilder *dbuilder,
ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file, 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), reinterpret_cast<DIScope*>(scope),
name, name,
linkage_name, linkage_name,
reinterpret_cast<DIFile*>(file), reinterpret_cast<DIFile*>(file),
line_no, line_no,
reinterpret_cast<DIType*>(di_type), reinterpret_cast<DIType*>(di_type),
is_local_to_unit, is_local_to_unit);
reinterpret_cast<llvm::Constant *>(constant_val));
return reinterpret_cast<ZigLLVMDIGlobalVariable*>(result); return reinterpret_cast<ZigLLVMDIGlobalVariable*>(result);
} }
@ -421,6 +416,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilde
ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no, ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no) ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no)
{ {
assert(flags == 0);
DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createParameterVariable( DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createParameterVariable(
reinterpret_cast<DIScope*>(scope), reinterpret_cast<DIScope*>(scope),
name, name,
@ -429,7 +425,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilde
line_no, line_no,
reinterpret_cast<DIType*>(type), reinterpret_cast<DIType*>(type),
always_preserve, always_preserve,
flags); DINode::FlagZero);
return reinterpret_cast<ZigLLVMDILocalVariable*>(result); return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
} }
@ -459,12 +455,16 @@ ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type) {
} }
ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder, 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, bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
uint64_t dwo_id, bool emit_debug_info) uint64_t dwo_id, bool emit_debug_info)
{ {
DICompileUnit *result = reinterpret_cast<DIBuilder*>(dibuilder)->createCompileUnit( 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); return reinterpret_cast<ZigLLVMDICompileUnit*>(result);
} }
@ -480,13 +480,14 @@ ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMD
unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram) unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram)
{ {
DISubroutineType *di_sub_type = static_cast<DISubroutineType*>(reinterpret_cast<DIType*>(fn_di_type)); DISubroutineType *di_sub_type = static_cast<DISubroutineType*>(reinterpret_cast<DIType*>(fn_di_type));
assert(flags == 0);
DISubprogram *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFunction( DISubprogram *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFunction(
reinterpret_cast<DIScope*>(scope), reinterpret_cast<DIScope*>(scope),
name, linkage_name, name, linkage_name,
reinterpret_cast<DIFile*>(file), reinterpret_cast<DIFile*>(file),
lineno, lineno,
di_sub_type, 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, nullptr,
reinterpret_cast<DISubprogram *>(decl_subprogram)); reinterpret_cast<DISubprogram *>(decl_subprogram));
return reinterpret_cast<ZigLLVMDISubprogram*>(result); 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, ""); static_assert((Triple::ObjectFormatType)ZigLLVM_MachO == Triple::MachO, "");
const char *ZigLLVMGetArchTypeName(ZigLLVM_ArchType arch) { 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) { 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) { 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) { 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, 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"; return "v8_1a";
case ZigLLVM_ARMSubArch_v8: case ZigLLVM_ARMSubArch_v8:
return "v8"; return "v8";
case ZigLLVM_ARMSubArch_v8r:
return "v8r";
case ZigLLVM_ARMSubArch_v8m_baseline: case ZigLLVM_ARMSubArch_v8m_baseline:
return "v8m_baseline"; return "v8m_baseline";
case ZigLLVM_ARMSubArch_v8m_mainline: 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)); 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" #include "buffer.hpp"

248
src/zig_llvm.hpp
View File

@ -47,17 +47,12 @@ LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMVa
const char *name); const char *name);
LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
const char *name); 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, ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *pointee_type,
uint64_t size_in_bits, uint64_t align_in_bits, const char *name); uint64_t size_in_bits, uint64_t align_in_bits, const char *name);
ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, 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, ZigLLVMDIType *ZigLLVMCreateDebugArrayType(ZigLLVMDIBuilder *dibuilder,
uint64_t size_in_bits, uint64_t align_in_bits, ZigLLVMDIType *elem_type, 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, ZigLLVMDIGlobalVariable *ZigLLVMCreateGlobalVariable(ZigLLVMDIBuilder *dbuilder,
ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file, 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, ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilder,
ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no, 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); ZigLLVMDIFile *file, unsigned line, unsigned col);
ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder, 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, bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
uint64_t dwo_id, bool emit_debug_info); 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 // copied from include/llvm/ADT/Triple.h
enum ZigLLVM_ArchType { enum ZigLLVM_ArchType {
ZigLLVM_UnknownArch, ZigLLVM_UnknownArch,
ZigLLVM_arm, // ARM (little endian): arm, armv.*, xscale ZigLLVM_arm, // ARM (little endian): arm, armv.*, xscale
ZigLLVM_armeb, // ARM (big endian): armeb ZigLLVM_armeb, // ARM (big endian): armeb
ZigLLVM_aarch64, // AArch64 (little endian): aarch64 ZigLLVM_aarch64, // AArch64 (little endian): aarch64
ZigLLVM_aarch64_be, // AArch64 (big endian): aarch64_be ZigLLVM_aarch64_be, // AArch64 (big endian): aarch64_be
ZigLLVM_avr, // AVR: Atmel AVR microcontroller ZigLLVM_avr, // AVR: Atmel AVR microcontroller
ZigLLVM_bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) 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_bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian)
ZigLLVM_hexagon, // Hexagon: hexagon ZigLLVM_hexagon, // Hexagon: hexagon
ZigLLVM_mips, // MIPS: mips, mipsallegrex ZigLLVM_mips, // MIPS: mips, mipsallegrex
ZigLLVM_mipsel, // MIPSEL: mipsel, mipsallegrexel ZigLLVM_mipsel, // MIPSEL: mipsel, mipsallegrexel
ZigLLVM_mips64, // MIPS64: mips64 ZigLLVM_mips64, // MIPS64: mips64
ZigLLVM_mips64el, // MIPS64EL: mips64el ZigLLVM_mips64el, // MIPS64EL: mips64el
ZigLLVM_msp430, // MSP430: msp430 ZigLLVM_msp430, // MSP430: msp430
ZigLLVM_ppc, // PPC: powerpc ZigLLVM_ppc, // PPC: powerpc
ZigLLVM_ppc64, // PPC64: powerpc64, ppu ZigLLVM_ppc64, // PPC64: powerpc64, ppu
ZigLLVM_ppc64le, // PPC64LE: powerpc64le ZigLLVM_ppc64le, // PPC64LE: powerpc64le
ZigLLVM_r600, // R600: AMD GPUs HD2XXX - HD6XXX ZigLLVM_r600, // R600: AMD GPUs HD2XXX - HD6XXX
ZigLLVM_amdgcn, // AMDGCN: AMD GCN GPUs ZigLLVM_amdgcn, // AMDGCN: AMD GCN GPUs
ZigLLVM_sparc, // Sparc: sparc ZigLLVM_riscv32, // RISC-V (32-bit): riscv32
ZigLLVM_sparcv9, // Sparcv9: Sparcv9 ZigLLVM_riscv64, // RISC-V (64-bit): riscv64
ZigLLVM_sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant ZigLLVM_sparc, // Sparc: sparc
ZigLLVM_systemz, // SystemZ: s390x ZigLLVM_sparcv9, // Sparcv9: Sparcv9
ZigLLVM_tce, // TCE (http://tce.cs.tut.fi/): tce ZigLLVM_sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
ZigLLVM_thumb, // Thumb (little endian): thumb, thumbv.* ZigLLVM_systemz, // SystemZ: s390x
ZigLLVM_thumbeb, // Thumb (big endian): thumbeb ZigLLVM_tce, // TCE (http://tce.cs.tut.fi/): tce
ZigLLVM_x86, // X86: i[3-9]86 ZigLLVM_tcele, // TCE little endian (http://tce.cs.tut.fi/): tcele
ZigLLVM_x86_64, // X86-64: amd64, x86_64 ZigLLVM_thumb, // Thumb (little endian): thumb, thumbv.*
ZigLLVM_xcore, // XCore: xcore ZigLLVM_thumbeb, // Thumb (big endian): thumbeb
ZigLLVM_nvptx, // NVPTX: 32-bit ZigLLVM_x86, // X86: i[3-9]86
ZigLLVM_nvptx64, // NVPTX: 64-bit ZigLLVM_x86_64, // X86-64: amd64, x86_64
ZigLLVM_le32, // le32: generic little-endian 32-bit CPU (PNaCl) ZigLLVM_xcore, // XCore: xcore
ZigLLVM_le64, // le64: generic little-endian 64-bit CPU (PNaCl) ZigLLVM_nvptx, // NVPTX: 32-bit
ZigLLVM_amdil, // AMDIL ZigLLVM_nvptx64, // NVPTX: 64-bit
ZigLLVM_amdil64, // AMDIL with 64-bit pointers ZigLLVM_le32, // le32: generic little-endian 32-bit CPU (PNaCl)
ZigLLVM_hsail, // AMD HSAIL ZigLLVM_le64, // le64: generic little-endian 64-bit CPU (PNaCl)
ZigLLVM_hsail64, // AMD HSAIL with 64-bit pointers ZigLLVM_amdil, // AMDIL
ZigLLVM_spir, // SPIR: standard portable IR for OpenCL 32-bit version ZigLLVM_amdil64, // AMDIL with 64-bit pointers
ZigLLVM_spir64, // SPIR: standard portable IR for OpenCL 64-bit version ZigLLVM_hsail, // AMD HSAIL
ZigLLVM_kalimba, // Kalimba: generic kalimba ZigLLVM_hsail64, // AMD HSAIL with 64-bit pointers
ZigLLVM_shave, // SHAVE: Movidius vector VLIW processors ZigLLVM_spir, // SPIR: standard portable IR for OpenCL 32-bit version
ZigLLVM_lanai, // Lanai: Lanai 32-bit ZigLLVM_spir64, // SPIR: standard portable IR for OpenCL 64-bit version
ZigLLVM_wasm32, // WebAssembly with 32-bit pointers ZigLLVM_kalimba, // Kalimba: generic kalimba
ZigLLVM_wasm64, // WebAssembly with 64-bit pointers ZigLLVM_shave, // SHAVE: Movidius vector VLIW processors
ZigLLVM_renderscript32, // 32-bit RenderScript ZigLLVM_lanai, // Lanai: Lanai 32-bit
ZigLLVM_renderscript64, // 64-bit RenderScript 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 { enum ZigLLVM_SubArchType {
@ -230,6 +228,7 @@ enum ZigLLVM_SubArchType {
ZigLLVM_ARMSubArch_v8_2a, ZigLLVM_ARMSubArch_v8_2a,
ZigLLVM_ARMSubArch_v8_1a, ZigLLVM_ARMSubArch_v8_1a,
ZigLLVM_ARMSubArch_v8, ZigLLVM_ARMSubArch_v8,
ZigLLVM_ARMSubArch_v8r,
ZigLLVM_ARMSubArch_v8m_baseline, ZigLLVM_ARMSubArch_v8m_baseline,
ZigLLVM_ARMSubArch_v8m_mainline, ZigLLVM_ARMSubArch_v8m_mainline,
ZigLLVM_ARMSubArch_v7, ZigLLVM_ARMSubArch_v7,
@ -247,86 +246,93 @@ enum ZigLLVM_SubArchType {
ZigLLVM_KalimbaSubArch_v3, ZigLLVM_KalimbaSubArch_v3,
ZigLLVM_KalimbaSubArch_v4, ZigLLVM_KalimbaSubArch_v4,
ZigLLVM_KalimbaSubArch_v5 ZigLLVM_KalimbaSubArch_v5,
}; };
enum ZigLLVM_VendorType { enum ZigLLVM_VendorType {
ZigLLVM_UnknownVendor, ZigLLVM_UnknownVendor,
ZigLLVM_Apple, ZigLLVM_Apple,
ZigLLVM_PC, ZigLLVM_PC,
ZigLLVM_SCEI, ZigLLVM_SCEI,
ZigLLVM_BGP, ZigLLVM_BGP,
ZigLLVM_BGQ, ZigLLVM_BGQ,
ZigLLVM_Freescale, ZigLLVM_Freescale,
ZigLLVM_IBM, ZigLLVM_IBM,
ZigLLVM_ImaginationTechnologies, ZigLLVM_ImaginationTechnologies,
ZigLLVM_MipsTechnologies, ZigLLVM_MipsTechnologies,
ZigLLVM_NVIDIA, ZigLLVM_NVIDIA,
ZigLLVM_CSR, ZigLLVM_CSR,
ZigLLVM_Myriad, ZigLLVM_Myriad,
ZigLLVM_AMD, ZigLLVM_AMD,
ZigLLVM_Mesa, ZigLLVM_Mesa,
ZigLLVM_LastVendorType = ZigLLVM_Mesa ZigLLVM_LastVendorType = ZigLLVM_Mesa
}; };
enum ZigLLVM_OSType { enum ZigLLVM_OSType {
ZigLLVM_UnknownOS, ZigLLVM_UnknownOS,
ZigLLVM_CloudABI, ZigLLVM_CloudABI,
ZigLLVM_Darwin, ZigLLVM_Darwin,
ZigLLVM_DragonFly, ZigLLVM_DragonFly,
ZigLLVM_FreeBSD, ZigLLVM_FreeBSD,
ZigLLVM_IOS, ZigLLVM_Fuchsia,
ZigLLVM_KFreeBSD, ZigLLVM_IOS,
ZigLLVM_Linux, ZigLLVM_KFreeBSD,
ZigLLVM_Lv2, // PS3 ZigLLVM_Linux,
ZigLLVM_MacOSX, ZigLLVM_Lv2, // PS3
ZigLLVM_NetBSD, ZigLLVM_MacOSX,
ZigLLVM_OpenBSD, ZigLLVM_NetBSD,
ZigLLVM_Solaris, ZigLLVM_OpenBSD,
ZigLLVM_Win32, ZigLLVM_Solaris,
ZigLLVM_Haiku, ZigLLVM_Win32,
ZigLLVM_Minix, ZigLLVM_Haiku,
ZigLLVM_RTEMS, ZigLLVM_Minix,
ZigLLVM_NaCl, // Native Client ZigLLVM_RTEMS,
ZigLLVM_CNK, // BG/P Compute-Node Kernel ZigLLVM_NaCl, // Native Client
ZigLLVM_Bitrig, ZigLLVM_CNK, // BG/P Compute-Node Kernel
ZigLLVM_AIX, ZigLLVM_Bitrig,
ZigLLVM_CUDA, // NVIDIA CUDA ZigLLVM_AIX,
ZigLLVM_NVCL, // NVIDIA OpenCL ZigLLVM_CUDA, // NVIDIA CUDA
ZigLLVM_AMDHSA, // AMD HSA Runtime ZigLLVM_NVCL, // NVIDIA OpenCL
ZigLLVM_PS4, ZigLLVM_AMDHSA, // AMD HSA Runtime
ZigLLVM_ELFIAMCU, ZigLLVM_PS4,
ZigLLVM_TvOS, // Apple tvOS ZigLLVM_ELFIAMCU,
ZigLLVM_WatchOS, // Apple watchOS ZigLLVM_TvOS, // Apple tvOS
ZigLLVM_Mesa3D, ZigLLVM_WatchOS, // Apple watchOS
ZigLLVM_Mesa3D,
ZigLLVM_Contiki,
ZigLLVM_LastOSType = ZigLLVM_Mesa3D ZigLLVM_LastOSType = ZigLLVM_Contiki
}; };
enum ZigLLVM_EnvironmentType { enum ZigLLVM_EnvironmentType {
ZigLLVM_UnknownEnvironment, ZigLLVM_UnknownEnvironment,
ZigLLVM_GNU, ZigLLVM_GNU,
ZigLLVM_GNUABI64, ZigLLVM_GNUABI64,
ZigLLVM_GNUEABI, ZigLLVM_GNUEABI,
ZigLLVM_GNUEABIHF, ZigLLVM_GNUEABIHF,
ZigLLVM_GNUX32, ZigLLVM_GNUX32,
ZigLLVM_CODE16, ZigLLVM_CODE16,
ZigLLVM_EABI, ZigLLVM_EABI,
ZigLLVM_EABIHF, ZigLLVM_EABIHF,
ZigLLVM_Android, ZigLLVM_Android,
ZigLLVM_Musl, ZigLLVM_Musl,
ZigLLVM_MuslEABI, ZigLLVM_MuslEABI,
ZigLLVM_MuslEABIHF, ZigLLVM_MuslEABIHF,
ZigLLVM_MSVC, ZigLLVM_MSVC,
ZigLLVM_Itanium, ZigLLVM_Itanium,
ZigLLVM_Cygnus, ZigLLVM_Cygnus,
ZigLLVM_AMDOpenCL, ZigLLVM_AMDOpenCL,
ZigLLVM_CoreCLR, ZigLLVM_CoreCLR,
ZigLLVM_OpenCL,
ZigLLVM_LastEnvironmentType = ZigLLVM_CoreCLR ZigLLVM_LastEnvironmentType = ZigLLVM_OpenCL
}; };
enum ZigLLVM_ObjectFormatType { enum ZigLLVM_ObjectFormatType {
ZigLLVM_UnknownObjectFormat, ZigLLVM_UnknownObjectFormat,