authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-03-10 02:29:01-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-03-10 02:29:01-05:00
logcd31f875a68fba0519f20c561b11b5dfb9524a8b
tree2ec16185cd997c6e18ef04875ed654840480f732
parent47f267d25fcf1a85b983e6f059c18e6163324897

update to llvm 4.0

9 files changed, 219 insertions(+), 207 deletions(-)

README.md+2-2
......@@ -87,8 +87,8 @@ the Zig compiler itself:
8787These libraries must be installed on your system, with the development files
8888available. The Zig compiler dynamically links against them.
8989
90 * LLVM == 3.9.x
91 * libclang == 3.9.x
90 * LLVM == 4.x
91 * libclang == 4.x
9292
9393### Debug / Development Build
9494
cmake/Findclang.cmake+2-2
......@@ -8,14 +8,14 @@
88
99find_path(CLANG_INCLUDE_DIRS NAMES clang/Frontend/ASTUnit.h
1010 PATHS
11 /usr/lib/llvm-3.9/include
11 /usr/lib/llvm-4/include
1212 /mingw64/include)
1313
1414macro(FIND_AND_ADD_CLANG_LIB _libname_)
1515 string(TOUPPER ${_libname_} _prettylibname_)
1616 find_library(CLANG_${_prettylibname_}_LIB NAMES ${_libname_}
1717 PATHS
18 /usr/lib/llvm-3.9/lib
18 /usr/lib/llvm-4/lib
1919 /mingw64/lib)
2020 if(CLANG_${_prettylibname_}_LIB)
2121 set(CLANG_LIBRARIES ${CLANG_LIBRARIES} ${CLANG_${_prettylibname_}_LIB})
cmake/Findllvm.cmake+1-1
......@@ -7,7 +7,7 @@
77# LLVM_LIBRARIES
88# LLVM_LIBDIRS
99
10find_program(LLVM_CONFIG_EXE NAMES llvm-config llvm-config-3.9)
10find_program(LLVM_CONFIG_EXE NAMES llvm-config llvm-config-4)
1111
1212execute_process(
1313 COMMAND ${LLVM_CONFIG_EXE} --libs
src/analyze.cpp+1-3
......@@ -3950,9 +3950,7 @@ TypeTableEntry *make_int_type(CodeGen *g, bool is_signed, size_t size_in_bits) {
39503950 }
39513951
39523952 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
3953 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
3954 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
3955 debug_size_in_bits, debug_align_in_bits, dwarf_tag);
3953 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), debug_size_in_bits, dwarf_tag);
39563954 entry->data.integral.is_signed = is_signed;
39573955 entry->data.integral.bit_count = size_in_bits;
39583956 return entry;
src/codegen.cpp+34-33
......@@ -236,6 +236,21 @@ static void render_const_val(CodeGen *g, ConstExprValue *const_val);
236236static void render_const_val_global(CodeGen *g, ConstExprValue *const_val, const char *name);
237237static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val);
238238
239static void addLLVMAttr(LLVMValueRef val, LLVMAttributeIndex attr_index, const char *attr_name) {
240 unsigned kind_id = LLVMGetEnumAttributeKindForName(attr_name, strlen(attr_name));
241 assert(kind_id != 0);
242 LLVMAttributeRef llvm_attr = LLVMCreateEnumAttribute(LLVMGetGlobalContext(), kind_id, 0);
243 LLVMAddAttributeAtIndex(val, attr_index, llvm_attr);
244}
245
246static void addLLVMFnAttr(LLVMValueRef fn_val, const char *attr_name) {
247 return addLLVMAttr(fn_val, -1, attr_name);
248}
249
250static void addLLVMArgAttr(LLVMValueRef arg_val, unsigned param_index, const char *attr_name) {
251 return addLLVMAttr(arg_val, param_index + 1, attr_name);
252}
253
239254static LLVMValueRef fn_llvm_value(CodeGen *g, FnTableEntry *fn_table_entry) {
240255 if (fn_table_entry->llvm_value)
241256 return fn_table_entry->llvm_value;
......@@ -252,29 +267,29 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, FnTableEntry *fn_table_entry) {
252267
253268 switch (fn_table_entry->fn_inline) {
254269 case FnInlineAlways:
255 LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMAlwaysInlineAttribute);
270 addLLVMFnAttr(fn_table_entry->llvm_value, "alwaysinline");
256271 break;
257272 case FnInlineNever:
258 LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoInlineAttribute);
273 addLLVMFnAttr(fn_table_entry->llvm_value, "noinline");
259274 break;
260275 case FnInlineAuto:
261276 break;
262277 }
263278 if (fn_type->data.fn.fn_type_id.is_naked) {
264 LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNakedAttribute);
279 addLLVMFnAttr(fn_table_entry->llvm_value, "naked");
265280 }
266281
267282 LLVMSetLinkage(fn_table_entry->llvm_value, fn_table_entry->internal_linkage ?
268283 LLVMInternalLinkage : LLVMExternalLinkage);
269284
270285 if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdUnreachable) {
271 LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoReturnAttribute);
286 addLLVMFnAttr(fn_table_entry->llvm_value, "noreturn");
272287 }
273288 LLVMSetFunctionCallConv(fn_table_entry->llvm_value, fn_type->data.fn.calling_convention);
274289 if (fn_type->data.fn.fn_type_id.is_cold) {
275290 ZigLLVMAddFunctionAttrCold(fn_table_entry->llvm_value);
276291 }
277 LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoUnwindAttribute);
292 addLLVMFnAttr(fn_table_entry->llvm_value, "nounwind");
278293 if (!g->is_release_build && fn_table_entry->fn_inline != FnInlineAlways) {
279294 ZigLLVMAddFunctionAttr(fn_table_entry->llvm_value, "no-frame-pointer-elim", "true");
280295 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
891906 if (type_entry->data.integral.is_signed) {
892907 return LLVMBuildExactSDiv(g->builder, val1, val2, "");
893908 } else {
894 return ZigLLVMBuildExactUDiv(g->builder, val1, val2, "");
909 return LLVMBuildExactUDiv(g->builder, val1, val2, "");
895910 }
896911 } else {
897912 if (type_entry->data.integral.is_signed) {
......@@ -1125,7 +1140,7 @@ static LLVMValueRef ir_render_cast(CodeGen *g, IrExecutable *executable,
11251140
11261141 LLVMPositionBuilderAtEnd(g->builder, ok_block);
11271142 }
1128 new_len = ZigLLVMBuildExactUDiv(g->builder, src_len, dest_size_val, "");
1143 new_len = LLVMBuildExactUDiv(g->builder, src_len, dest_size_val, "");
11291144 } else {
11301145 zig_unreachable();
11311146 }
......@@ -3183,7 +3198,8 @@ static void gen_global_var(CodeGen *g, VariableTableEntry *var, LLVMValueRef ini
31833198 bool is_local_to_unit = true;
31843199 ZigLLVMCreateGlobalVariable(g->dbuilder, get_di_scope(g, var->parent_scope), buf_ptr(&var->name),
31853200 buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
3186 type_entry->di_type, is_local_to_unit, init_val);
3201 type_entry->di_type, is_local_to_unit);
3202 // TODO ^^ make an actual global variable
31873203}
31883204
31893205static LLVMValueRef build_alloca(CodeGen *g, TypeTableEntry *type_entry, const char *name) {
......@@ -3284,13 +3300,12 @@ static void do_code_gen(CodeGen *g) {
32843300 } else if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdPointer ||
32853301 fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdFn)
32863302 {
3287 ZigLLVMAddNonNullAttr(fn_val, 0);
3303 addLLVMAttr(fn_val, 0, "nonnull");
32883304 } else if (handle_is_ptr(fn_type->data.fn.fn_type_id.return_type) &&
32893305 !fn_type->data.fn.fn_type_id.is_extern)
32903306 {
3291 LLVMValueRef first_arg = LLVMGetParam(fn_val, 0);
3292 LLVMAddAttribute(first_arg, LLVMStructRetAttribute);
3293 ZigLLVMAddNonNullAttr(fn_val, 1);
3307 addLLVMArgAttr(fn_val, 0, "sret");
3308 addLLVMArgAttr(fn_val, 0, "nonnull");
32943309 }
32953310
32963311
......@@ -3307,19 +3322,17 @@ static void do_code_gen(CodeGen *g) {
33073322 FnTypeParamInfo *param_info = &fn_type_id->param_info[param_i];
33083323
33093324 TypeTableEntry *param_type = gen_info->type;
3310 LLVMValueRef argument_val = LLVMGetParam(fn_val, gen_index);
33113325 if (param_info->is_noalias) {
3312 LLVMAddAttribute(argument_val, LLVMNoAliasAttribute);
3326 addLLVMArgAttr(fn_val, gen_index, "noalias");
33133327 }
33143328 if ((param_type->id == TypeTableEntryIdPointer && param_type->data.pointer.is_const) || is_byval) {
3315 LLVMAddAttribute(argument_val, LLVMReadOnlyAttribute);
3329 addLLVMArgAttr(fn_val, gen_index, "readonly");
33163330 }
33173331 if (param_type->id == TypeTableEntryIdPointer) {
3318 ZigLLVMAddNonNullAttr(fn_val, gen_index + 1);
3332 addLLVMArgAttr(fn_val, gen_index, "nonnull");
33193333 }
33203334 if (is_byval) {
3321 // TODO
3322 //LLVMAddAttribute(argument_val, LLVMByValAttribute);
3335 // TODO add byval attr?
33233336 }
33243337 }
33253338
......@@ -3613,10 +3626,8 @@ static void define_builtin_types(CodeGen *g) {
36133626 buf_init_from_str(&entry->name, info->name);
36143627
36153628 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
3616 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
36173629 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
36183630 debug_size_in_bits,
3619 debug_align_in_bits,
36203631 is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned());
36213632 entry->data.integral.is_signed = is_signed;
36223633 entry->data.integral.bit_count = size_in_bits;
......@@ -3630,10 +3641,8 @@ static void define_builtin_types(CodeGen *g) {
36303641 entry->type_ref = LLVMInt1Type();
36313642 buf_init_from_str(&entry->name, "bool");
36323643 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
3633 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
36343644 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
36353645 debug_size_in_bits,
3636 debug_align_in_bits,
36373646 ZigLLVMEncoding_DW_ATE_boolean());
36383647 g->builtin_types.entry_bool = entry;
36393648 g->primitive_type_table.put(&entry->name, entry);
......@@ -3653,10 +3662,8 @@ static void define_builtin_types(CodeGen *g) {
36533662 entry->data.integral.bit_count = g->pointer_size_bytes * 8;
36543663
36553664 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
3656 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
36573665 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
36583666 debug_size_in_bits,
3659 debug_align_in_bits,
36603667 is_signed ? ZigLLVMEncoding_DW_ATE_signed() : ZigLLVMEncoding_DW_ATE_unsigned());
36613668 g->primitive_type_table.put(&entry->name, entry);
36623669
......@@ -3673,10 +3680,8 @@ static void define_builtin_types(CodeGen *g) {
36733680 entry->data.floating.bit_count = 32;
36743681
36753682 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
3676 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
36773683 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
36783684 debug_size_in_bits,
3679 debug_align_in_bits,
36803685 ZigLLVMEncoding_DW_ATE_float());
36813686 g->builtin_types.entry_f32 = entry;
36823687 g->primitive_type_table.put(&entry->name, entry);
......@@ -3688,10 +3693,8 @@ static void define_builtin_types(CodeGen *g) {
36883693 entry->data.floating.bit_count = 64;
36893694
36903695 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
3691 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
36923696 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
36933697 debug_size_in_bits,
3694 debug_align_in_bits,
36953698 ZigLLVMEncoding_DW_ATE_float());
36963699 g->builtin_types.entry_f64 = entry;
36973700 g->primitive_type_table.put(&entry->name, entry);
......@@ -3703,10 +3706,8 @@ static void define_builtin_types(CodeGen *g) {
37033706 entry->data.floating.bit_count = 80;
37043707
37053708 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
3706 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
37073709 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
37083710 debug_size_in_bits,
3709 debug_align_in_bits,
37103711 ZigLLVMEncoding_DW_ATE_float());
37113712 g->builtin_types.entry_c_long_double = entry;
37123713 g->primitive_type_table.put(&entry->name, entry);
......@@ -3717,7 +3718,6 @@ static void define_builtin_types(CodeGen *g) {
37173718 entry->zero_bits = true;
37183719 buf_init_from_str(&entry->name, "void");
37193720 entry->di_type = ZigLLVMCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
3720 0,
37213721 0,
37223722 ZigLLVMEncoding_DW_ATE_unsigned());
37233723 g->builtin_types.entry_void = entry;
......@@ -4098,9 +4098,10 @@ static void init(CodeGen *g, Buf *source_path) {
40984098 bool is_optimized = g->is_release_build;
40994099 const char *flags = "";
41004100 unsigned runtime_version = 0;
4101 ZigLLVMDIFile *compile_unit_file = ZigLLVMCreateFile(g->dbuilder, buf_ptr(source_path),
4102 buf_ptr(&g->root_package->root_src_dir));
41014103 g->compile_unit = ZigLLVMCreateCompileUnit(g->dbuilder, ZigLLVMLang_DW_LANG_C99(),
4102 buf_ptr(source_path), buf_ptr(&g->root_package->root_src_dir),
4103 buf_ptr(producer), is_optimized, flags, runtime_version,
4104 compile_unit_file, buf_ptr(producer), is_optimized, flags, runtime_version,
41044105 "", 0, !g->strip_debug_symbols);
41054106
41064107 // This is for debug stuff that doesn't have a real file.
src/parseh.cpp+4
......@@ -466,6 +466,9 @@ static TypeTableEntry *resolve_type_with_table(Context *c, const Type *ty, const
466466 case CC_X86_64SysV: // __attribute__((sysv_abi))
467467 emit_warning(c, decl, "function type has x86 64sysv calling convention");
468468 return c->codegen->builtin_types.entry_invalid;
469 case CC_X86RegCall:
470 emit_warning(c, decl, "function type has x86 reg calling convention");
471 return c->codegen->builtin_types.entry_invalid;
469472 case CC_AAPCS: // __attribute__((pcs("aapcs")))
470473 emit_warning(c, decl, "function type has aapcs calling convention");
471474 return c->codegen->builtin_types.entry_invalid;
......@@ -598,6 +601,7 @@ static TypeTableEntry *resolve_type_with_table(Context *c, const Type *ty, const
598601 case Type::ObjCObjectPointer:
599602 case Type::Atomic:
600603 case Type::Pipe:
604 case Type::ObjCTypeParam:
601605 emit_warning(c, decl, "missed a '%s' type", ty->getTypeClassName());
602606 return c->codegen->builtin_types.entry_invalid;
603607 }
src/target.cpp+8
......@@ -351,6 +351,8 @@ void resolve_target_object_format(ZigTarget *target) {
351351 case ZigLLVM_r600:
352352 case ZigLLVM_renderscript32:
353353 case ZigLLVM_renderscript64:
354 case ZigLLVM_riscv32:
355 case ZigLLVM_riscv64:
354356 case ZigLLVM_shave:
355357 case ZigLLVM_sparc:
356358 case ZigLLVM_sparcel:
......@@ -359,6 +361,7 @@ void resolve_target_object_format(ZigTarget *target) {
359361 case ZigLLVM_spir64:
360362 case ZigLLVM_systemz:
361363 case ZigLLVM_tce:
364 case ZigLLVM_tcele:
362365 case ZigLLVM_thumbeb:
363366 case ZigLLVM_wasm32:
364367 case ZigLLVM_wasm64:
......@@ -396,9 +399,11 @@ static int get_arch_pointer_bit_width(ZigLLVM_ArchType arch) {
396399 case ZigLLVM_nvptx:
397400 case ZigLLVM_ppc:
398401 case ZigLLVM_r600:
402 case ZigLLVM_riscv32:
399403 case ZigLLVM_sparc:
400404 case ZigLLVM_sparcel:
401405 case ZigLLVM_tce:
406 case ZigLLVM_tcele:
402407 case ZigLLVM_thumb:
403408 case ZigLLVM_thumbeb:
404409 case ZigLLVM_x86:
......@@ -424,6 +429,7 @@ static int get_arch_pointer_bit_width(ZigLLVM_ArchType arch) {
424429 case ZigLLVM_nvptx64:
425430 case ZigLLVM_ppc64:
426431 case ZigLLVM_ppc64le:
432 case ZigLLVM_riscv64:
427433 case ZigLLVM_sparcv9:
428434 case ZigLLVM_systemz:
429435 case ZigLLVM_x86_64:
......@@ -515,6 +521,8 @@ int get_c_type_size_in_bits(const ZigTarget *target, CIntType id) {
515521 case ZigLLVM_TvOS:
516522 case ZigLLVM_WatchOS:
517523 case ZigLLVM_Mesa3D:
524 case ZigLLVM_Fuchsia:
525 case ZigLLVM_Contiki:
518526 zig_panic("TODO c type size in bits for this target");
519527 }
520528 zig_unreachable();
src/zig_llvm.cpp+31-36
......@@ -137,15 +137,6 @@ LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *A
137137 return wrap(unwrap(B)->Insert(call_inst));
138138}
139139
140void ZigLLVMAddNonNullAttr(LLVMValueRef fn, unsigned i)
141{
142 assert( isa<Function>(unwrap(fn)) );
143
144 Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
145
146 unwrapped_function->addAttribute(i, Attribute::NonNull);
147}
148
149140void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
150141 assert( isa<Function>(unwrap(fn)) );
151142 Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
......@@ -162,10 +153,10 @@ ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLV
162153}
163154
164155ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name,
165 uint64_t size_in_bits, uint64_t align_in_bits, unsigned encoding)
156 uint64_t size_in_bits, unsigned encoding)
166157{
167158 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createBasicType(
168 name, size_in_bits, align_in_bits, encoding);
159 name, size_in_bits, encoding);
169160 return reinterpret_cast<ZigLLVMDIType*>(di_type);
170161}
171162
......@@ -211,11 +202,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugMemberType(ZigLLVMDIBuilder *dibuilder, ZigLLVM
211202 const char *name, ZigLLVMDIFile *file, unsigned line, uint64_t size_in_bits,
212203 uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags, ZigLLVMDIType *type)
213204{
205 assert(flags == 0);
214206 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createMemberType(
215207 reinterpret_cast<DIScope*>(scope),
216208 name,
217209 reinterpret_cast<DIFile*>(file),
218 line, size_in_bits, align_in_bits, offset_in_bits, flags,
210 line, size_in_bits, align_in_bits, offset_in_bits, DINode::FlagZero,
219211 reinterpret_cast<DIType*>(type));
220212 return reinterpret_cast<ZigLLVMDIType*>(di_type);
221213}
......@@ -230,11 +222,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMD
230222 DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
231223 fields.push_back(ditype);
232224 }
225 assert(flags == 0);
233226 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createUnionType(
234227 reinterpret_cast<DIScope*>(scope),
235228 name,
236229 reinterpret_cast<DIFile*>(file),
237 line_number, size_in_bits, align_in_bits, flags,
230 line_number, size_in_bits, align_in_bits, DINode::FlagZero,
238231 reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
239232 run_time_lang, unique_id);
240233 return reinterpret_cast<ZigLLVMDIType*>(di_type);
......@@ -251,11 +244,12 @@ ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVM
251244 DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
252245 fields.push_back(ditype);
253246 }
247 assert(flags == 0);
254248 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createStructType(
255249 reinterpret_cast<DIScope*>(scope),
256250 name,
257251 reinterpret_cast<DIFile*>(file),
258 line_number, size_in_bits, align_in_bits, flags,
252 line_number, size_in_bits, align_in_bits, DINode::FlagZero,
259253 reinterpret_cast<DIType*>(derived_from),
260254 reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
261255 run_time_lang,
......@@ -316,10 +310,11 @@ ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped,
316310 DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
317311 types.push_back(ditype);
318312 }
313 assert(flags == 0);
319314 DIBuilder *dibuilder = reinterpret_cast<DIBuilder*>(dibuilder_wrapped);
320315 DISubroutineType *subroutine_type = dibuilder->createSubroutineType(
321316 dibuilder->getOrCreateTypeArray(types),
322 flags);
317 DINode::FlagZero);
323318 DIType *ditype = subroutine_type;
324319 return reinterpret_cast<ZigLLVMDIType*>(ditype);
325320}
......@@ -390,6 +385,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
390385 ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
391386 ZigLLVMDIType *type, bool always_preserve, unsigned flags)
392387{
388 assert(flags == 0);
393389 DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createAutoVariable(
394390 reinterpret_cast<DIScope*>(scope),
395391 name,
......@@ -397,23 +393,22 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
397393 line_no,
398394 reinterpret_cast<DIType*>(type),
399395 always_preserve,
400 flags);
396 DINode::FlagZero);
401397 return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
402398}
403399
404400ZigLLVMDIGlobalVariable *ZigLLVMCreateGlobalVariable(ZigLLVMDIBuilder *dbuilder,
405401 ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file,
406 unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit, LLVMValueRef constant_val)
402 unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit)
407403{
408 DIGlobalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createGlobalVariable(
404 DIGlobalVariableExpression *result = reinterpret_cast<DIBuilder*>(dbuilder)->createGlobalVariableExpression(
409405 reinterpret_cast<DIScope*>(scope),
410406 name,
411407 linkage_name,
412408 reinterpret_cast<DIFile*>(file),
413409 line_no,
414410 reinterpret_cast<DIType*>(di_type),
415 is_local_to_unit,
416 reinterpret_cast<llvm::Constant *>(constant_val));
411 is_local_to_unit);
417412 return reinterpret_cast<ZigLLVMDIGlobalVariable*>(result);
418413}
419414
......@@ -421,6 +416,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilde
421416 ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
422417 ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no)
423418{
419 assert(flags == 0);
424420 DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createParameterVariable(
425421 reinterpret_cast<DIScope*>(scope),
426422 name,
......@@ -429,7 +425,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilde
429425 line_no,
430426 reinterpret_cast<DIType*>(type),
431427 always_preserve,
432 flags);
428 DINode::FlagZero);
433429 return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
434430}
435431
......@@ -459,12 +455,16 @@ ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type) {
459455}
460456
461457ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder,
462 unsigned lang, const char *file, const char *dir, const char *producer,
458 unsigned lang, ZigLLVMDIFile *difile, const char *producer,
463459 bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
464460 uint64_t dwo_id, bool emit_debug_info)
465461{
466462 DICompileUnit *result = reinterpret_cast<DIBuilder*>(dibuilder)->createCompileUnit(
467 lang, file, dir, producer, is_optimized, flags, runtime_version, split_name);
463 lang,
464 reinterpret_cast<DIFile*>(difile),
465 producer, is_optimized, flags, runtime_version, split_name,
466 (emit_debug_info ? DICompileUnit::DebugEmissionKind::FullDebug : DICompileUnit::DebugEmissionKind::NoDebug),
467 dwo_id);
468468 return reinterpret_cast<ZigLLVMDICompileUnit*>(result);
469469}
470470
......@@ -480,13 +480,14 @@ ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMD
480480 unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram)
481481{
482482 DISubroutineType *di_sub_type = static_cast<DISubroutineType*>(reinterpret_cast<DIType*>(fn_di_type));
483 assert(flags == 0);
483484 DISubprogram *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFunction(
484485 reinterpret_cast<DIScope*>(scope),
485486 name, linkage_name,
486487 reinterpret_cast<DIFile*>(file),
487488 lineno,
488489 di_sub_type,
489 is_local_to_unit, is_definition, scope_line, flags, is_optimized,
490 is_local_to_unit, is_definition, scope_line, DINode::FlagZero, is_optimized,
490491 nullptr,
491492 reinterpret_cast<DISubprogram *>(decl_subprogram));
492493 return reinterpret_cast<ZigLLVMDISubprogram*>(result);
......@@ -581,19 +582,19 @@ static_assert((Triple::ObjectFormatType)ZigLLVM_ELF == Triple::ELF, "");
581582static_assert((Triple::ObjectFormatType)ZigLLVM_MachO == Triple::MachO, "");
582583
583584const char *ZigLLVMGetArchTypeName(ZigLLVM_ArchType arch) {
584 return Triple::getArchTypeName((Triple::ArchType)arch);
585 return (const char*)Triple::getArchTypeName((Triple::ArchType)arch).bytes_begin();
585586}
586587
587588const char *ZigLLVMGetVendorTypeName(ZigLLVM_VendorType vendor) {
588 return Triple::getVendorTypeName((Triple::VendorType)vendor);
589 return (const char*)Triple::getVendorTypeName((Triple::VendorType)vendor).bytes_begin();
589590}
590591
591592const char *ZigLLVMGetOSTypeName(ZigLLVM_OSType os) {
592 return Triple::getOSTypeName((Triple::OSType)os);
593 return (const char*)Triple::getOSTypeName((Triple::OSType)os).bytes_begin();
593594}
594595
595596const char *ZigLLVMGetEnvironmentTypeName(ZigLLVM_EnvironmentType env_type) {
596 return Triple::getEnvironmentTypeName((Triple::EnvironmentType)env_type);
597 return (const char*)Triple::getEnvironmentTypeName((Triple::EnvironmentType)env_type).bytes_begin();
597598}
598599
599600void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *sub_arch_type,
......@@ -623,6 +624,8 @@ const char *ZigLLVMGetSubArchTypeName(ZigLLVM_SubArchType sub_arch) {
623624 return "v8_1a";
624625 case ZigLLVM_ARMSubArch_v8:
625626 return "v8";
627 case ZigLLVM_ARMSubArch_v8r:
628 return "v8r";
626629 case ZigLLVM_ARMSubArch_v8m_baseline:
627630 return "v8m_baseline";
628631 case ZigLLVM_ARMSubArch_v8m_mainline:
......@@ -704,14 +707,6 @@ LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMVa
704707 return wrap(unwrap(builder)->CreateShl(unwrap(LHS), unwrap(RHS), name, false, true));
705708}
706709
707LLVMValueRef ZigLLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS,
708 LLVMValueRef RHS, const char *Name)
709{
710 return wrap(unwrap(B)->CreateExactUDiv(unwrap(LHS), unwrap(RHS), Name));
711}
712
713
714
715710//------------------------------------
716711
717712#include "buffer.hpp"
src/zig_llvm.hpp+136-130
......@@ -47,17 +47,12 @@ LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMVa
4747 const char *name);
4848LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
4949 const char *name);
50LLVMValueRef ZigLLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS,
51 LLVMValueRef RHS, const char *Name);
52
53// 0 is return value, 1 is first arg
54void ZigLLVMAddNonNullAttr(LLVMValueRef fn, unsigned i);
5550
5651ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *pointee_type,
5752 uint64_t size_in_bits, uint64_t align_in_bits, const char *name);
5853
5954ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name,
60 uint64_t size_in_bits, uint64_t align_in_bits, unsigned encoding);
55 uint64_t size_in_bits, unsigned encoding);
6156
6257ZigLLVMDIType *ZigLLVMCreateDebugArrayType(ZigLLVMDIBuilder *dibuilder,
6358 uint64_t size_in_bits, uint64_t align_in_bits, ZigLLVMDIType *elem_type,
......@@ -128,7 +123,7 @@ ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
128123
129124ZigLLVMDIGlobalVariable *ZigLLVMCreateGlobalVariable(ZigLLVMDIBuilder *dbuilder,
130125 ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file,
131 unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit, LLVMValueRef constant_val);
126 unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit);
132127
133128ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilder,
134129 ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
......@@ -138,7 +133,7 @@ ZigLLVMDILexicalBlock *ZigLLVMCreateLexicalBlock(ZigLLVMDIBuilder *dbuilder, Zig
138133 ZigLLVMDIFile *file, unsigned line, unsigned col);
139134
140135ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder,
141 unsigned lang, const char *file, const char *dir, const char *producer,
136 unsigned lang, ZigLLVMDIFile *difile, const char *producer,
142137 bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
143138 uint64_t dwo_id, bool emit_debug_info);
144139
......@@ -173,55 +168,58 @@ unsigned ZigLLVMGetPrefTypeAlignment(LLVMTargetDataRef TD, LLVMTypeRef Ty);
173168// copied from include/llvm/ADT/Triple.h
174169
175170enum ZigLLVM_ArchType {
176 ZigLLVM_UnknownArch,
177
178 ZigLLVM_arm, // ARM (little endian): arm, armv.*, xscale
179 ZigLLVM_armeb, // ARM (big endian): armeb
180 ZigLLVM_aarch64, // AArch64 (little endian): aarch64
181 ZigLLVM_aarch64_be, // AArch64 (big endian): aarch64_be
182 ZigLLVM_avr, // AVR: Atmel AVR microcontroller
183 ZigLLVM_bpfel, // eBPF or extended BPF or 64-bit BPF (little endian)
184 ZigLLVM_bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian)
185 ZigLLVM_hexagon, // Hexagon: hexagon
186 ZigLLVM_mips, // MIPS: mips, mipsallegrex
187 ZigLLVM_mipsel, // MIPSEL: mipsel, mipsallegrexel
188 ZigLLVM_mips64, // MIPS64: mips64
189 ZigLLVM_mips64el, // MIPS64EL: mips64el
190 ZigLLVM_msp430, // MSP430: msp430
191 ZigLLVM_ppc, // PPC: powerpc
192 ZigLLVM_ppc64, // PPC64: powerpc64, ppu
193 ZigLLVM_ppc64le, // PPC64LE: powerpc64le
194 ZigLLVM_r600, // R600: AMD GPUs HD2XXX - HD6XXX
195 ZigLLVM_amdgcn, // AMDGCN: AMD GCN GPUs
196 ZigLLVM_sparc, // Sparc: sparc
197 ZigLLVM_sparcv9, // Sparcv9: Sparcv9
198 ZigLLVM_sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
199 ZigLLVM_systemz, // SystemZ: s390x
200 ZigLLVM_tce, // TCE (http://tce.cs.tut.fi/): tce
201 ZigLLVM_thumb, // Thumb (little endian): thumb, thumbv.*
202 ZigLLVM_thumbeb, // Thumb (big endian): thumbeb
203 ZigLLVM_x86, // X86: i[3-9]86
204 ZigLLVM_x86_64, // X86-64: amd64, x86_64
205 ZigLLVM_xcore, // XCore: xcore
206 ZigLLVM_nvptx, // NVPTX: 32-bit
207 ZigLLVM_nvptx64, // NVPTX: 64-bit
208 ZigLLVM_le32, // le32: generic little-endian 32-bit CPU (PNaCl)
209 ZigLLVM_le64, // le64: generic little-endian 64-bit CPU (PNaCl)
210 ZigLLVM_amdil, // AMDIL
211 ZigLLVM_amdil64, // AMDIL with 64-bit pointers
212 ZigLLVM_hsail, // AMD HSAIL
213 ZigLLVM_hsail64, // AMD HSAIL with 64-bit pointers
214 ZigLLVM_spir, // SPIR: standard portable IR for OpenCL 32-bit version
215 ZigLLVM_spir64, // SPIR: standard portable IR for OpenCL 64-bit version
216 ZigLLVM_kalimba, // Kalimba: generic kalimba
217 ZigLLVM_shave, // SHAVE: Movidius vector VLIW processors
218 ZigLLVM_lanai, // Lanai: Lanai 32-bit
219 ZigLLVM_wasm32, // WebAssembly with 32-bit pointers
220 ZigLLVM_wasm64, // WebAssembly with 64-bit pointers
221 ZigLLVM_renderscript32, // 32-bit RenderScript
222 ZigLLVM_renderscript64, // 64-bit RenderScript
223
224 ZigLLVM_LastArchType = ZigLLVM_renderscript64
171 ZigLLVM_UnknownArch,
172
173 ZigLLVM_arm, // ARM (little endian): arm, armv.*, xscale
174 ZigLLVM_armeb, // ARM (big endian): armeb
175 ZigLLVM_aarch64, // AArch64 (little endian): aarch64
176 ZigLLVM_aarch64_be, // AArch64 (big endian): aarch64_be
177 ZigLLVM_avr, // AVR: Atmel AVR microcontroller
178 ZigLLVM_bpfel, // eBPF or extended BPF or 64-bit BPF (little endian)
179 ZigLLVM_bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian)
180 ZigLLVM_hexagon, // Hexagon: hexagon
181 ZigLLVM_mips, // MIPS: mips, mipsallegrex
182 ZigLLVM_mipsel, // MIPSEL: mipsel, mipsallegrexel
183 ZigLLVM_mips64, // MIPS64: mips64
184 ZigLLVM_mips64el, // MIPS64EL: mips64el
185 ZigLLVM_msp430, // MSP430: msp430
186 ZigLLVM_ppc, // PPC: powerpc
187 ZigLLVM_ppc64, // PPC64: powerpc64, ppu
188 ZigLLVM_ppc64le, // PPC64LE: powerpc64le
189 ZigLLVM_r600, // R600: AMD GPUs HD2XXX - HD6XXX
190 ZigLLVM_amdgcn, // AMDGCN: AMD GCN GPUs
191 ZigLLVM_riscv32, // RISC-V (32-bit): riscv32
192 ZigLLVM_riscv64, // RISC-V (64-bit): riscv64
193 ZigLLVM_sparc, // Sparc: sparc
194 ZigLLVM_sparcv9, // Sparcv9: Sparcv9
195 ZigLLVM_sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
196 ZigLLVM_systemz, // SystemZ: s390x
197 ZigLLVM_tce, // TCE (http://tce.cs.tut.fi/): tce
198 ZigLLVM_tcele, // TCE little endian (http://tce.cs.tut.fi/): tcele
199 ZigLLVM_thumb, // Thumb (little endian): thumb, thumbv.*
200 ZigLLVM_thumbeb, // Thumb (big endian): thumbeb
201 ZigLLVM_x86, // X86: i[3-9]86
202 ZigLLVM_x86_64, // X86-64: amd64, x86_64
203 ZigLLVM_xcore, // XCore: xcore
204 ZigLLVM_nvptx, // NVPTX: 32-bit
205 ZigLLVM_nvptx64, // NVPTX: 64-bit
206 ZigLLVM_le32, // le32: generic little-endian 32-bit CPU (PNaCl)
207 ZigLLVM_le64, // le64: generic little-endian 64-bit CPU (PNaCl)
208 ZigLLVM_amdil, // AMDIL
209 ZigLLVM_amdil64, // AMDIL with 64-bit pointers
210 ZigLLVM_hsail, // AMD HSAIL
211 ZigLLVM_hsail64, // AMD HSAIL with 64-bit pointers
212 ZigLLVM_spir, // SPIR: standard portable IR for OpenCL 32-bit version
213 ZigLLVM_spir64, // SPIR: standard portable IR for OpenCL 64-bit version
214 ZigLLVM_kalimba, // Kalimba: generic kalimba
215 ZigLLVM_shave, // SHAVE: Movidius vector VLIW processors
216 ZigLLVM_lanai, // Lanai: Lanai 32-bit
217 ZigLLVM_wasm32, // WebAssembly with 32-bit pointers
218 ZigLLVM_wasm64, // WebAssembly with 64-bit pointers
219 ZigLLVM_renderscript32, // 32-bit RenderScript
220 ZigLLVM_renderscript64, // 64-bit RenderScript
221
222 ZigLLVM_LastArchType = ZigLLVM_renderscript64
225223};
226224
227225enum ZigLLVM_SubArchType {
......@@ -230,6 +228,7 @@ enum ZigLLVM_SubArchType {
230228 ZigLLVM_ARMSubArch_v8_2a,
231229 ZigLLVM_ARMSubArch_v8_1a,
232230 ZigLLVM_ARMSubArch_v8,
231 ZigLLVM_ARMSubArch_v8r,
233232 ZigLLVM_ARMSubArch_v8m_baseline,
234233 ZigLLVM_ARMSubArch_v8m_mainline,
235234 ZigLLVM_ARMSubArch_v7,
......@@ -247,86 +246,93 @@ enum ZigLLVM_SubArchType {
247246
248247 ZigLLVM_KalimbaSubArch_v3,
249248 ZigLLVM_KalimbaSubArch_v4,
250 ZigLLVM_KalimbaSubArch_v5
249 ZigLLVM_KalimbaSubArch_v5,
251250};
251
252252enum ZigLLVM_VendorType {
253 ZigLLVM_UnknownVendor,
254
255 ZigLLVM_Apple,
256 ZigLLVM_PC,
257 ZigLLVM_SCEI,
258 ZigLLVM_BGP,
259 ZigLLVM_BGQ,
260 ZigLLVM_Freescale,
261 ZigLLVM_IBM,
262 ZigLLVM_ImaginationTechnologies,
263 ZigLLVM_MipsTechnologies,
264 ZigLLVM_NVIDIA,
265 ZigLLVM_CSR,
266 ZigLLVM_Myriad,
267 ZigLLVM_AMD,
268 ZigLLVM_Mesa,
269
270 ZigLLVM_LastVendorType = ZigLLVM_Mesa
253 ZigLLVM_UnknownVendor,
254
255 ZigLLVM_Apple,
256 ZigLLVM_PC,
257 ZigLLVM_SCEI,
258 ZigLLVM_BGP,
259 ZigLLVM_BGQ,
260 ZigLLVM_Freescale,
261 ZigLLVM_IBM,
262 ZigLLVM_ImaginationTechnologies,
263 ZigLLVM_MipsTechnologies,
264 ZigLLVM_NVIDIA,
265 ZigLLVM_CSR,
266 ZigLLVM_Myriad,
267 ZigLLVM_AMD,
268 ZigLLVM_Mesa,
269
270 ZigLLVM_LastVendorType = ZigLLVM_Mesa
271271};
272
272273enum ZigLLVM_OSType {
273 ZigLLVM_UnknownOS,
274
275 ZigLLVM_CloudABI,
276 ZigLLVM_Darwin,
277 ZigLLVM_DragonFly,
278 ZigLLVM_FreeBSD,
279 ZigLLVM_IOS,
280 ZigLLVM_KFreeBSD,
281 ZigLLVM_Linux,
282 ZigLLVM_Lv2, // PS3
283 ZigLLVM_MacOSX,
284 ZigLLVM_NetBSD,
285 ZigLLVM_OpenBSD,
286 ZigLLVM_Solaris,
287 ZigLLVM_Win32,
288 ZigLLVM_Haiku,
289 ZigLLVM_Minix,
290 ZigLLVM_RTEMS,
291 ZigLLVM_NaCl, // Native Client
292 ZigLLVM_CNK, // BG/P Compute-Node Kernel
293 ZigLLVM_Bitrig,
294 ZigLLVM_AIX,
295 ZigLLVM_CUDA, // NVIDIA CUDA
296 ZigLLVM_NVCL, // NVIDIA OpenCL
297 ZigLLVM_AMDHSA, // AMD HSA Runtime
298 ZigLLVM_PS4,
299 ZigLLVM_ELFIAMCU,
300 ZigLLVM_TvOS, // Apple tvOS
301 ZigLLVM_WatchOS, // Apple watchOS
302 ZigLLVM_Mesa3D,
303
304 ZigLLVM_LastOSType = ZigLLVM_Mesa3D
274 ZigLLVM_UnknownOS,
275
276 ZigLLVM_CloudABI,
277 ZigLLVM_Darwin,
278 ZigLLVM_DragonFly,
279 ZigLLVM_FreeBSD,
280 ZigLLVM_Fuchsia,
281 ZigLLVM_IOS,
282 ZigLLVM_KFreeBSD,
283 ZigLLVM_Linux,
284 ZigLLVM_Lv2, // PS3
285 ZigLLVM_MacOSX,
286 ZigLLVM_NetBSD,
287 ZigLLVM_OpenBSD,
288 ZigLLVM_Solaris,
289 ZigLLVM_Win32,
290 ZigLLVM_Haiku,
291 ZigLLVM_Minix,
292 ZigLLVM_RTEMS,
293 ZigLLVM_NaCl, // Native Client
294 ZigLLVM_CNK, // BG/P Compute-Node Kernel
295 ZigLLVM_Bitrig,
296 ZigLLVM_AIX,
297 ZigLLVM_CUDA, // NVIDIA CUDA
298 ZigLLVM_NVCL, // NVIDIA OpenCL
299 ZigLLVM_AMDHSA, // AMD HSA Runtime
300 ZigLLVM_PS4,
301 ZigLLVM_ELFIAMCU,
302 ZigLLVM_TvOS, // Apple tvOS
303 ZigLLVM_WatchOS, // Apple watchOS
304 ZigLLVM_Mesa3D,
305 ZigLLVM_Contiki,
306
307 ZigLLVM_LastOSType = ZigLLVM_Contiki
305308};
309
306310enum ZigLLVM_EnvironmentType {
307 ZigLLVM_UnknownEnvironment,
308
309 ZigLLVM_GNU,
310 ZigLLVM_GNUABI64,
311 ZigLLVM_GNUEABI,
312 ZigLLVM_GNUEABIHF,
313 ZigLLVM_GNUX32,
314 ZigLLVM_CODE16,
315 ZigLLVM_EABI,
316 ZigLLVM_EABIHF,
317 ZigLLVM_Android,
318 ZigLLVM_Musl,
319 ZigLLVM_MuslEABI,
320 ZigLLVM_MuslEABIHF,
321
322 ZigLLVM_MSVC,
323 ZigLLVM_Itanium,
324 ZigLLVM_Cygnus,
325 ZigLLVM_AMDOpenCL,
326 ZigLLVM_CoreCLR,
327
328 ZigLLVM_LastEnvironmentType = ZigLLVM_CoreCLR
311 ZigLLVM_UnknownEnvironment,
312
313 ZigLLVM_GNU,
314 ZigLLVM_GNUABI64,
315 ZigLLVM_GNUEABI,
316 ZigLLVM_GNUEABIHF,
317 ZigLLVM_GNUX32,
318 ZigLLVM_CODE16,
319 ZigLLVM_EABI,
320 ZigLLVM_EABIHF,
321 ZigLLVM_Android,
322 ZigLLVM_Musl,
323 ZigLLVM_MuslEABI,
324 ZigLLVM_MuslEABIHF,
325
326 ZigLLVM_MSVC,
327 ZigLLVM_Itanium,
328 ZigLLVM_Cygnus,
329 ZigLLVM_AMDOpenCL,
330 ZigLLVM_CoreCLR,
331 ZigLLVM_OpenCL,
332
333 ZigLLVM_LastEnvironmentType = ZigLLVM_OpenCL
329334};
335
330336enum ZigLLVM_ObjectFormatType {
331337 ZigLLVM_UnknownObjectFormat,
332338