authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-08-01 18:16:52-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-08-01 18:16:52-07:00
log0f793840aebcc31a678e49b1e8b2ad0a0d8656f4
treeb0fd1ffda951d2289143c0ecc12177cd671d716f
parent70d39123908e29cde9fbfb540869e03ab86694e3

stage1: LLVM lowering to opaque pointers API

7 files changed, 517 insertions(+), 388 deletions(-)

CMakeLists.txt+1-1
......@@ -858,7 +858,7 @@ endif()
858858if(MSVC)
859859 set(EXE_CFLAGS "${EXE_CFLAGS}")
860860else()
861 set(EXE_CFLAGS "${EXE_CFLAGS} -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE -fvisibility-inlines-hidden -fno-exceptions -fno-rtti -Werror=type-limits -Wno-missing-braces -Wno-comment -Wno-deprecated-declarations")
861 set(EXE_CFLAGS "${EXE_CFLAGS} -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE -fvisibility-inlines-hidden -fno-exceptions -fno-rtti -Werror=type-limits -Wno-missing-braces -Wno-comment")
862862 if(MINGW)
863863 set(EXE_CFLAGS "${EXE_CFLAGS} -Wno-format")
864864 endif()
src/codegen/llvm/bindings.zig+13-19
......@@ -31,6 +31,9 @@ pub const Context = opaque {
3131 pub const createStringAttribute = LLVMCreateStringAttribute;
3232 extern fn LLVMCreateStringAttribute(*const Context, Key: [*]const u8, Key_Len: c_uint, Value: [*]const u8, Value_Len: c_uint) *const Attribute;
3333
34 pub const pointerType = LLVMPointerTypeInContext;
35 extern fn LLVMPointerTypeInContext(C: *const Context, AddressSpace: c_uint) *const Type;
36
3437 pub const intType = LLVMIntTypeInContext;
3538 extern fn LLVMIntTypeInContext(C: *const Context, NumBits: c_uint) *const Type;
3639
......@@ -138,8 +141,9 @@ pub const Value = opaque {
138141 pub const setAliasee = LLVMAliasSetAliasee;
139142 extern fn LLVMAliasSetAliasee(Alias: *const Value, Aliasee: *const Value) void;
140143
141 pub const constInBoundsGEP = LLVMConstInBoundsGEP;
142 extern fn LLVMConstInBoundsGEP(
144 pub const constInBoundsGEP = LLVMConstInBoundsGEP2;
145 extern fn LLVMConstInBoundsGEP2(
146 Ty: *const Type,
143147 ConstantVal: *const Value,
144148 ConstantIndices: [*]const *const Value,
145149 NumIndices: c_uint,
......@@ -276,9 +280,6 @@ pub const Type = opaque {
276280 pub const getUndef = LLVMGetUndef;
277281 extern fn LLVMGetUndef(Ty: *const Type) *const Value;
278282
279 pub const pointerType = LLVMPointerType;
280 extern fn LLVMPointerType(ElementType: *const Type, AddressSpace: c_uint) *const Type;
281
282283 pub const arrayType = LLVMArrayType;
283284 extern fn LLVMArrayType(ElementType: *const Type, ElementCount: c_uint) *const Type;
284285
......@@ -506,6 +507,7 @@ pub const Builder = opaque {
506507 pub const buildCall = ZigLLVMBuildCall;
507508 extern fn ZigLLVMBuildCall(
508509 *const Builder,
510 *const Type,
509511 Fn: *const Value,
510512 Args: [*]const *const Value,
511513 NumArgs: c_uint,
......@@ -529,8 +531,8 @@ pub const Builder = opaque {
529531 pub const buildStore = LLVMBuildStore;
530532 extern fn LLVMBuildStore(*const Builder, Val: *const Value, Ptr: *const Value) *const Value;
531533
532 pub const buildLoad = LLVMBuildLoad;
533 extern fn LLVMBuildLoad(*const Builder, PointerVal: *const Value, Name: [*:0]const u8) *const Value;
534 pub const buildLoad = LLVMBuildLoad2;
535 extern fn LLVMBuildLoad2(*const Builder, Ty: *const Type, PointerVal: *const Value, Name: [*:0]const u8) *const Value;
534536
535537 pub const buildNeg = LLVMBuildNeg;
536538 extern fn LLVMBuildNeg(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
......@@ -655,16 +657,7 @@ pub const Builder = opaque {
655657 pub const buildBitCast = LLVMBuildBitCast;
656658 extern fn LLVMBuildBitCast(*const Builder, Val: *const Value, DestTy: *const Type, Name: [*:0]const u8) *const Value;
657659
658 pub const buildInBoundsGEP = LLVMBuildInBoundsGEP;
659 extern fn LLVMBuildInBoundsGEP(
660 B: *const Builder,
661 Pointer: *const Value,
662 Indices: [*]const *const Value,
663 NumIndices: c_uint,
664 Name: [*:0]const u8,
665 ) *const Value;
666
667 pub const buildInBoundsGEP2 = LLVMBuildInBoundsGEP2;
660 pub const buildInBoundsGEP = LLVMBuildInBoundsGEP2;
668661 extern fn LLVMBuildInBoundsGEP2(
669662 B: *const Builder,
670663 Ty: *const Type,
......@@ -741,9 +734,10 @@ pub const Builder = opaque {
741734 Name: [*:0]const u8,
742735 ) *const Value;
743736
744 pub const buildStructGEP = LLVMBuildStructGEP;
745 extern fn LLVMBuildStructGEP(
737 pub const buildStructGEP = LLVMBuildStructGEP2;
738 extern fn LLVMBuildStructGEP2(
746739 B: *const Builder,
740 Ty: *const Type,
747741 Pointer: *const Value,
748742 Idx: c_uint,
749743 Name: [*:0]const u8,
src/stage1/all_types.hpp+1
......@@ -2043,6 +2043,7 @@ struct CodeGen {
20432043 LLVMValueRef wasm_memory_grow;
20442044 LLVMValueRef prefetch;
20452045 LLVMTypeRef anyframe_fn_type;
2046 LLVMTypeRef any_frame_header_llvm_ty;
20462047
20472048 // reminder: hash tables must be initialized before use
20482049 HashMap<Buf *, ZigType *, buf_hash, buf_eql_buf> import_table;
src/stage1/analyze.cpp+1
......@@ -9746,6 +9746,7 @@ static void resolve_llvm_types_any_frame(CodeGen *g, ZigType *any_frame_type, Re
97469746
97479747 Buf *name = buf_sprintf("(%s header)", buf_ptr(&any_frame_type->name));
97489748 LLVMTypeRef frame_header_type = LLVMStructCreateNamed(LLVMGetGlobalContext(), buf_ptr(name));
9749 g->any_frame_header_llvm_ty = frame_header_type;
97499750 any_frame_type->llvm_type = LLVMPointerType(frame_header_type, 0);
97509751
97519752 unsigned dwarf_kind = ZigLLVMTag_DW_structure_type();
src/stage1/codegen.cpp+491-360
......@@ -88,8 +88,8 @@ static bool value_is_all_undef(CodeGen *g, ZigValue *const_val);
8888static void gen_undef_init(CodeGen *g, ZigType *ptr_type, ZigType *value_type, LLVMValueRef ptr);
8989static LLVMValueRef build_alloca(CodeGen *g, ZigType *type_entry, const char *name, uint32_t alignment);
9090static LLVMValueRef gen_await_early_return(CodeGen *g, Stage1AirInst *source_instr,
91 LLVMValueRef target_frame_ptr, ZigType *result_type, ZigType *ptr_result_type,
92 LLVMValueRef result_loc, bool non_async);
91 LLVMTypeRef target_frame_struct_llvm_ty, LLVMValueRef target_frame_ptr,
92 ZigType *result_type, ZigType *ptr_result_type, LLVMValueRef result_loc, bool non_async);
9393
9494static void addLLVMAttr(LLVMValueRef val, LLVMAttributeIndex attr_index, const char *attr_name) {
9595 unsigned kind_id = LLVMGetEnumAttributeKindForName(attr_name, strlen(attr_name));
......@@ -911,10 +911,10 @@ static LLVMValueRef gen_store(CodeGen *g, LLVMValueRef value, LLVMValueRef ptr,
911911 return gen_store_untyped(g, value, ptr, alignment, ptr_type->data.pointer.is_volatile);
912912}
913913
914static LLVMValueRef gen_load_untyped(CodeGen *g, LLVMValueRef ptr, uint32_t alignment, bool is_volatile,
915 const char *name)
914static LLVMValueRef gen_load_untyped(CodeGen *g, LLVMTypeRef elem_llvm_ty, LLVMValueRef ptr,
915 uint32_t alignment, bool is_volatile, const char *name)
916916{
917 LLVMValueRef result = LLVMBuildLoad(g->builder, ptr, name);
917 LLVMValueRef result = LLVMBuildLoad2(g->builder, elem_llvm_ty, ptr, name);
918918 if (is_volatile) LLVMSetVolatile(result, true);
919919 if (alignment == 0) {
920920 LLVMSetAlignment(result, LLVMABIAlignmentOfType(g->target_data_ref, LLVMGetElementType(LLVMTypeOf(ptr))));
......@@ -927,7 +927,9 @@ static LLVMValueRef gen_load_untyped(CodeGen *g, LLVMValueRef ptr, uint32_t alig
927927static LLVMValueRef gen_load(CodeGen *g, LLVMValueRef ptr, ZigType *ptr_type, const char *name) {
928928 assert(ptr_type->id == ZigTypeIdPointer);
929929 uint32_t alignment = get_ptr_align(g, ptr_type);
930 return gen_load_untyped(g, ptr, alignment, ptr_type->data.pointer.is_volatile, name);
930 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, ptr_type->data.pointer.child_type);
931 bool is_volatile = ptr_type->data.pointer.is_volatile;
932 return gen_load_untyped(g, elem_llvm_ty, ptr, alignment, is_volatile, name);
931933}
932934
933935static LLVMValueRef get_handle_value(CodeGen *g, LLVMValueRef ptr, ZigType *type, ZigType *ptr_type) {
......@@ -1090,7 +1092,7 @@ static void gen_panic(CodeGen *g, LLVMValueRef msg_arg, LLVMValueRef stack_trace
10901092 msg_arg,
10911093 stack_trace_arg,
10921094 };
1093 ZigLLVMBuildCall(g->builder, fn_val, args, 2, llvm_cc, ZigLLVM_CallAttrAuto, "");
1095 ZigLLVMBuildCall(g->builder, LLVMTypeOf(fn_val), fn_val, args, 2, llvm_cc, ZigLLVM_CallAttrAuto, "");
10941096 if (!stack_trace_is_llvm_alloca) {
10951097 // The stack trace argument is not in the stack of the caller, so
10961098 // we'd like to set tail call here, but because slices (the type of msg_arg) are
......@@ -1265,26 +1267,37 @@ static LLVMValueRef get_add_error_return_trace_addr_fn(CodeGen *g) {
12651267 LLVMValueRef address_value = LLVMGetParam(fn_val, 1);
12661268
12671269 size_t index_field_index = g->stack_trace_type->data.structure.fields[0]->gen_index;
1268 LLVMValueRef index_field_ptr = LLVMBuildStructGEP(g->builder, err_ret_trace_ptr, (unsigned)index_field_index, "");
1270 LLVMValueRef index_field_ptr = LLVMBuildStructGEP2(g->builder,
1271 get_llvm_type(g, g->stack_trace_type),
1272 err_ret_trace_ptr, (unsigned)index_field_index, "");
12691273 size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1]->gen_index;
1270 LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP(g->builder, err_ret_trace_ptr, (unsigned)addresses_field_index, "");
1274 LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP2(g->builder,
1275 get_llvm_type(g, g->stack_trace_type),
1276 err_ret_trace_ptr, (unsigned)addresses_field_index, "");
12711277
12721278 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1]->type_entry;
12731279 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index]->gen_index;
1274 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)ptr_field_index, "");
1280 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP2(g->builder,
1281 LLVMGetGEPSourceElementType(addresses_field_ptr),
1282 addresses_field_ptr, (unsigned)ptr_field_index, "");
12751283 size_t len_field_index = slice_type->data.structure.fields[slice_len_index]->gen_index;
1276 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)len_field_index, "");
1277
1278 LLVMValueRef len_value = gen_load_untyped(g, len_field_ptr, 0, false, "");
1279 LLVMValueRef index_val = gen_load_untyped(g, index_field_ptr, 0, false, "");
1284 LLVMValueRef len_field_ptr = LLVMBuildStructGEP2(g->builder,
1285 LLVMGetGEPSourceElementType(addresses_field_ptr),
1286 addresses_field_ptr, (unsigned)len_field_index, "");
1287
1288 LLVMValueRef len_value = gen_load_untyped(g, LLVMGetGEPSourceElementType(len_field_ptr),
1289 len_field_ptr, 0, false, "");
1290 LLVMValueRef index_val = gen_load_untyped(g, LLVMGetGEPSourceElementType(index_field_ptr),
1291 index_field_ptr, 0, false, "");
12801292 LLVMValueRef len_val_minus_one = LLVMBuildSub(g->builder, len_value, LLVMConstInt(usize_type_ref, 1, false), "");
12811293 LLVMValueRef masked_val = LLVMBuildAnd(g->builder, index_val, len_val_minus_one, "");
12821294 LLVMValueRef address_indices[] = {
12831295 masked_val,
12841296 };
12851297
1286 LLVMValueRef ptr_value = gen_load_untyped(g, ptr_field_ptr, 0, false, "");
1287 LLVMValueRef address_slot = LLVMBuildInBoundsGEP(g->builder, ptr_value, address_indices, 1, "");
1298 LLVMValueRef ptr_value = gen_load_untyped(g, LLVMGetGEPSourceElementType(ptr_field_ptr),
1299 ptr_field_ptr, 0, false, "");
1300 LLVMValueRef address_slot = LLVMBuildInBoundsGEP2(g->builder, usize_type_ref, ptr_value, address_indices, 1, "");
12881301
12891302 gen_store_untyped(g, address_value, address_slot, 0, false);
12901303
......@@ -1340,7 +1353,8 @@ static LLVMValueRef get_return_err_fn(CodeGen *g) {
13401353
13411354 LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
13421355 LLVMValueRef zero = LLVMConstNull(get_llvm_type(g, g->builtin_types.entry_i32));
1343 LLVMValueRef return_address_ptr = LLVMBuildCall(g->builder, get_return_address_fn_val(g), &zero, 1, "");
1356 LLVMValueRef return_address_ptr = LLVMBuildCall2(g->builder,
1357 LLVMTypeOf(get_return_address_fn_val(g)), get_return_address_fn_val(g), &zero, 1, "");
13441358 LLVMValueRef return_address = LLVMBuildPtrToInt(g->builder, return_address_ptr, usize_type_ref, "");
13451359
13461360 LLVMBasicBlockRef return_block = LLVMAppendBasicBlock(fn_val, "Return");
......@@ -1355,7 +1369,8 @@ static LLVMValueRef get_return_err_fn(CodeGen *g) {
13551369
13561370 LLVMPositionBuilderAtEnd(g->builder, dest_non_null_block);
13571371 LLVMValueRef args[] = { err_ret_trace_ptr, return_address };
1358 ZigLLVMBuildCall(g->builder, add_error_return_trace_addr_fn_val, args, 2,
1372 ZigLLVMBuildCall(g->builder, LLVMTypeOf(add_error_return_trace_addr_fn_val),
1373 add_error_return_trace_addr_fn_val, args, 2,
13591374 get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAlwaysInline, "");
13601375 LLVMBuildRetVoid(g->builder);
13611376
......@@ -1446,25 +1461,32 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
14461461 LLVMConstNull(usize_ty->llvm_type),
14471462 err_val,
14481463 };
1449 LLVMValueRef err_name_val = LLVMBuildInBoundsGEP(g->builder, g->err_name_table, err_table_indices, 2, "");
1464 LLVMValueRef err_name_val = LLVMBuildInBoundsGEP2(g->builder,
1465 get_llvm_type(g, str_type),
1466 g->err_name_table, err_table_indices, 2, "");
14501467
1451 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, err_name_val, slice_ptr_index, "");
1452 LLVMValueRef err_name_ptr = gen_load_untyped(g, ptr_field_ptr, 0, false, "");
1468 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP2(g->builder,
1469 LLVMGetGEPSourceElementType(err_name_val), err_name_val, slice_ptr_index, "");
1470 LLVMValueRef err_name_ptr = gen_load_untyped(g, LLVMGetGEPSourceElementType(ptr_field_ptr),
1471 ptr_field_ptr, 0, false, "");
14531472
1454 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, err_name_val, slice_len_index, "");
1455 LLVMValueRef err_name_len = gen_load_untyped(g, len_field_ptr, 0, false, "");
1473 LLVMValueRef len_field_ptr = LLVMBuildStructGEP2(g->builder,
1474 LLVMGetGEPSourceElementType(err_name_val), err_name_val, slice_len_index, "");
1475 LLVMValueRef err_name_len = gen_load_untyped(g, LLVMGetGEPSourceElementType(len_field_ptr),
1476 len_field_ptr, 0, false, "");
14561477
14571478 LLVMValueRef msg_prefix_len = LLVMConstInt(usize_ty->llvm_type, strlen(unwrap_err_msg_text), false);
14581479 // Points to the beginning of msg_buffer
14591480 LLVMValueRef msg_buffer_ptr_indices[] = {
14601481 LLVMConstNull(usize_ty->llvm_type),
14611482 };
1462 LLVMValueRef msg_buffer_ptr = LLVMBuildInBoundsGEP(g->builder, msg_buffer, msg_buffer_ptr_indices, 1, "");
1483 LLVMValueRef msg_buffer_ptr = LLVMBuildInBoundsGEP2(g->builder, LLVMInt8Type(), msg_buffer,
1484 msg_buffer_ptr_indices, 1, "");
14631485 // Points to the beginning of the constant prefix message
14641486 LLVMValueRef msg_prefix_ptr_indices[] = {
14651487 LLVMConstNull(usize_ty->llvm_type),
14661488 };
1467 LLVMValueRef msg_prefix_ptr = LLVMConstInBoundsGEP(msg_prefix, msg_prefix_ptr_indices, 1);
1489 LLVMValueRef msg_prefix_ptr = LLVMConstInBoundsGEP2(LLVMInt8Type(), msg_prefix, msg_prefix_ptr_indices, 1);
14681490
14691491 // Build the message using the prefix...
14701492 ZigLLVMBuildMemCpy(g->builder, msg_buffer_ptr, 1, msg_prefix_ptr, 1, msg_prefix_len, false);
......@@ -1472,16 +1494,18 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
14721494 LLVMValueRef msg_buffer_ptr_after_indices[] = {
14731495 msg_prefix_len,
14741496 };
1475 LLVMValueRef msg_buffer_ptr_after = LLVMBuildInBoundsGEP(g->builder, msg_buffer, msg_buffer_ptr_after_indices, 1, "");
1497 LLVMValueRef msg_buffer_ptr_after = LLVMBuildInBoundsGEP2(g->builder, LLVMInt8Type(), msg_buffer, msg_buffer_ptr_after_indices, 1, "");
14761498 ZigLLVMBuildMemCpy(g->builder, msg_buffer_ptr_after, 1, err_name_ptr, 1, err_name_len, false);
14771499
14781500 // Set the slice pointer
1479 LLVMValueRef msg_slice_ptr_field_ptr = LLVMBuildStructGEP(g->builder, msg_slice, slice_ptr_index, "");
1501 LLVMValueRef msg_slice_ptr_field_ptr = LLVMBuildStructGEP2(g->builder,
1502 get_llvm_type(g, str_type), msg_slice, slice_ptr_index, "");
14801503 gen_store_untyped(g, msg_buffer_ptr, msg_slice_ptr_field_ptr, 0, false);
14811504
14821505 // Set the slice length
14831506 LLVMValueRef slice_len = LLVMBuildNUWAdd(g->builder, msg_prefix_len, err_name_len, "");
1484 LLVMValueRef msg_slice_len_field_ptr = LLVMBuildStructGEP(g->builder, msg_slice, slice_len_index, "");
1507 LLVMValueRef msg_slice_len_field_ptr = LLVMBuildStructGEP2(g->builder,
1508 get_llvm_type(g, str_type), msg_slice, slice_len_index, "");
14851509 gen_store_untyped(g, slice_len, msg_slice_len_field_ptr, 0, false);
14861510
14871511 // Call panic()
......@@ -1522,13 +1546,15 @@ static void gen_safety_crash_for_err(CodeGen *g, LLVMValueRef err_val, Scope *sc
15221546 err_ret_trace_val,
15231547 err_val,
15241548 };
1525 call_instruction = ZigLLVMBuildCall(g->builder, safety_crash_err_fn, args, 2,
1549 call_instruction = ZigLLVMBuildCall(g->builder, LLVMTypeOf(safety_crash_err_fn),
1550 safety_crash_err_fn, args, 2,
15261551 get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
15271552 } else {
15281553 LLVMValueRef args[] = {
15291554 err_val,
15301555 };
1531 call_instruction = ZigLLVMBuildCall(g->builder, safety_crash_err_fn, args, 1,
1556 call_instruction = ZigLLVMBuildCall(g->builder, LLVMTypeOf(safety_crash_err_fn),
1557 safety_crash_err_fn, args, 1,
15321558 get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
15331559 }
15341560 if (!is_llvm_alloca) {
......@@ -1573,7 +1599,7 @@ static void add_bounds_check(CodeGen *g, LLVMValueRef target_val,
15731599static void add_sentinel_check(CodeGen *g, LLVMValueRef sentinel_elem_ptr, ZigValue *sentinel) {
15741600 LLVMValueRef expected_sentinel = gen_const_val(g, sentinel, "");
15751601
1576 LLVMValueRef actual_sentinel = gen_load_untyped(g, sentinel_elem_ptr, 0, false, "");
1602 LLVMValueRef actual_sentinel = gen_load_untyped(g, LLVMTypeOf(expected_sentinel), sentinel_elem_ptr, 0, false, "");
15771603 LLVMValueRef ok_bit;
15781604 if (sentinel->type->id == ZigTypeIdFloat) {
15791605 ok_bit = LLVMBuildFCmp(g->builder, LLVMRealOEQ, actual_sentinel, expected_sentinel, "");
......@@ -1706,7 +1732,7 @@ static LLVMValueRef gen_soft_float_widen_or_shorten(CodeGen *g, ZigType *actual_
17061732 func_ref = LLVMAddFunction(g->module, fn_name, fn_type);
17071733 }
17081734
1709 result = LLVMBuildCall(g->builder, func_ref, &expr_val, 1, "");
1735 result = LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, &expr_val, 1, "");
17101736
17111737 // On non-Arm platforms we need to bitcast __trunc<>fhf2 result back to f16
17121738 if (castTruncatedToF16) {
......@@ -1852,7 +1878,7 @@ static LLVMValueRef gen_overflow_op(CodeGen *g, ZigType *operand_type, AddSubMul
18521878 val1,
18531879 val2,
18541880 };
1855 LLVMValueRef result_struct = LLVMBuildCall(g->builder, fn_val, params, 2, "");
1881 LLVMValueRef result_struct = LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, params, 2, "");
18561882 LLVMValueRef result = LLVMBuildExtractValue(g->builder, result_struct, 0, "");
18571883 LLVMValueRef overflow_bit = LLVMBuildExtractValue(g->builder, result_struct, 1, "");
18581884 if (operand_type->id == ZigTypeIdVector) {
......@@ -2272,9 +2298,8 @@ static bool iter_function_params_c_abi(CodeGen *g, ZigType *fn_type, FnWalk *fn_
22722298 fn_walk->data.attrs.gen_i += 1;
22732299 break;
22742300 case FnWalkIdCall: {
2275 LLVMTypeRef ptr_to_int_type_ref = LLVMPointerType(LLVMIntType((unsigned)ty_size * 8), 0);
2276 LLVMValueRef bitcasted = LLVMBuildBitCast(g->builder, val, ptr_to_int_type_ref, "");
2277 LLVMValueRef loaded = LLVMBuildLoad(g->builder, bitcasted, "");
2301 LLVMTypeRef ptr_elem_llvm_ty = LLVMIntType((unsigned)ty_size * 8);
2302 LLVMValueRef loaded = LLVMBuildLoad2(g->builder, ptr_elem_llvm_ty, val, "");
22782303 fn_walk->data.call.gen_param_values->append(loaded);
22792304 break;
22802305 }
......@@ -2342,18 +2367,17 @@ static bool iter_function_params_c_abi(CodeGen *g, ZigType *fn_type, FnWalk *fn_
23422367 break;
23432368 }
23442369 case FnWalkIdCall: {
2345 LLVMValueRef abi_ptr_to_struct = LLVMBuildBitCast(g->builder, val, LLVMPointerType(abi_type, 0), "");
23462370 if (number_of_regs == 1) {
2347 LLVMValueRef loaded = LLVMBuildLoad(g->builder, abi_ptr_to_struct, "");
2371 LLVMValueRef loaded = LLVMBuildLoad2(g->builder, abi_type, val, "");
23482372 fn_walk->data.call.gen_param_values->append(loaded);
23492373 break;
23502374 }
23512375 for (uint32_t i = 0; i < number_of_regs; i += 1) {
2352 LLVMValueRef zero = LLVMConstInt(LLVMInt32Type(), 0, false);
2353 LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, false);
2354 LLVMValueRef indices[] = { zero, index };
2355 LLVMValueRef adjusted_ptr_to_struct = LLVMBuildInBoundsGEP(g->builder, abi_ptr_to_struct, indices, 2, "");
2356 LLVMValueRef loaded = LLVMBuildLoad(g->builder, adjusted_ptr_to_struct, "");
2376 LLVMValueRef adjusted_ptr_to_struct = LLVMBuildStructGEP2(g->builder,
2377 abi_type, val, i, "");
2378 LLVMValueRef loaded = LLVMBuildLoad2(g->builder,
2379 LLVMGetGEPSourceElementType(adjusted_ptr_to_struct),
2380 adjusted_ptr_to_struct, "");
23572381 fn_walk->data.call.gen_param_values->append(loaded);
23582382 }
23592383 break;
......@@ -2388,13 +2412,13 @@ static bool iter_function_params_c_abi(CodeGen *g, ZigType *fn_type, FnWalk *fn_
23882412 LLVMValueRef bitcasted = LLVMBuildBitCast(g->builder, var->value_ref, ptr_to_int_type_ref, "");
23892413 gen_store_untyped(g, arg, bitcasted, var->align_bytes, false);
23902414 } else {
2391 LLVMValueRef abi_ptr_to_struct = LLVMBuildBitCast(g->builder, var->value_ref, LLVMPointerType(abi_type, 0), "");
23922415 for (uint32_t i = 0; i < number_of_regs; i += 1) {
23932416 LLVMValueRef arg = LLVMGetParam(llvm_fn, fn_walk->data.inits.gen_i + i);
23942417 LLVMValueRef zero = LLVMConstInt(LLVMInt32Type(), 0, false);
23952418 LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, false);
23962419 LLVMValueRef indices[] = { zero, index };
2397 LLVMValueRef adjusted_ptr_to_struct = LLVMBuildInBoundsGEP(g->builder, abi_ptr_to_struct, indices, 2, "");
2420 LLVMValueRef adjusted_ptr_to_struct = LLVMBuildInBoundsGEP2(g->builder,
2421 abi_type, var->value_ref, indices, 2, "");
23982422 LLVMBuildStore(g->builder, arg, adjusted_ptr_to_struct);
23992423 }
24002424 fn_walk->data.inits.gen_i += 1;
......@@ -2573,8 +2597,9 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
25732597 LLVMBasicBlockRef return_block = LLVMAppendBasicBlock(fn_val, "Return");
25742598 LLVMBasicBlockRef non_null_block = LLVMAppendBasicBlock(fn_val, "NonNull");
25752599
2576 LLVMValueRef frame_index_ptr = LLVMBuildAlloca(g->builder, g->builtin_types.entry_usize->llvm_type, "frame_index");
2577 LLVMValueRef frames_left_ptr = LLVMBuildAlloca(g->builder, g->builtin_types.entry_usize->llvm_type, "frames_left");
2600 LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
2601 LLVMValueRef frame_index_ptr = LLVMBuildAlloca(g->builder, usize_type_ref, "frame_index");
2602 LLVMValueRef frames_left_ptr = LLVMBuildAlloca(g->builder, usize_type_ref, "frames_left");
25782603
25792604 LLVMValueRef dest_stack_trace_ptr = LLVMGetParam(fn_val, 0);
25802605 LLVMValueRef src_stack_trace_ptr = LLVMGetParam(fn_val, 1);
......@@ -2589,18 +2614,27 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
25892614 LLVMPositionBuilderAtEnd(g->builder, non_null_block);
25902615 size_t src_index_field_index = g->stack_trace_type->data.structure.fields[0]->gen_index;
25912616 size_t src_addresses_field_index = g->stack_trace_type->data.structure.fields[1]->gen_index;
2592 LLVMValueRef src_index_field_ptr = LLVMBuildStructGEP(g->builder, src_stack_trace_ptr,
2617 LLVMValueRef src_index_field_ptr = LLVMBuildStructGEP2(g->builder,
2618 get_llvm_type(g, g->stack_trace_type), src_stack_trace_ptr,
25932619 (unsigned)src_index_field_index, "");
2594 LLVMValueRef src_addresses_field_ptr = LLVMBuildStructGEP(g->builder, src_stack_trace_ptr,
2620 LLVMValueRef src_addresses_field_ptr = LLVMBuildStructGEP2(g->builder,
2621 get_llvm_type(g, g->stack_trace_type), src_stack_trace_ptr,
25952622 (unsigned)src_addresses_field_index, "");
25962623 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1]->type_entry;
25972624 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index]->gen_index;
2598 LLVMValueRef src_ptr_field_ptr = LLVMBuildStructGEP(g->builder, src_addresses_field_ptr, (unsigned)ptr_field_index, "");
2625 LLVMValueRef src_ptr_field_ptr = LLVMBuildStructGEP2(g->builder,
2626 LLVMGetGEPSourceElementType(src_addresses_field_ptr),
2627 src_addresses_field_ptr, (unsigned)ptr_field_index, "");
25992628 size_t len_field_index = slice_type->data.structure.fields[slice_len_index]->gen_index;
2600 LLVMValueRef src_len_field_ptr = LLVMBuildStructGEP(g->builder, src_addresses_field_ptr, (unsigned)len_field_index, "");
2601 LLVMValueRef src_index_val = LLVMBuildLoad(g->builder, src_index_field_ptr, "");
2602 LLVMValueRef src_ptr_val = LLVMBuildLoad(g->builder, src_ptr_field_ptr, "");
2603 LLVMValueRef src_len_val = LLVMBuildLoad(g->builder, src_len_field_ptr, "");
2629 LLVMValueRef src_len_field_ptr = LLVMBuildStructGEP2(g->builder,
2630 LLVMGetGEPSourceElementType(src_addresses_field_ptr),
2631 src_addresses_field_ptr, (unsigned)len_field_index, "");
2632 LLVMValueRef src_index_val = LLVMBuildLoad2(g->builder,
2633 LLVMGetGEPSourceElementType(src_index_field_ptr), src_index_field_ptr, "");
2634 LLVMValueRef src_ptr_val = LLVMBuildLoad2(g->builder,
2635 LLVMGetGEPSourceElementType(src_ptr_field_ptr), src_ptr_field_ptr, "");
2636 LLVMValueRef src_len_val = LLVMBuildLoad2(g->builder,
2637 LLVMGetGEPSourceElementType(src_len_field_ptr), src_len_field_ptr, "");
26042638 LLVMValueRef no_wrap_bit = LLVMBuildICmp(g->builder, LLVMIntULT, src_index_val, src_len_val, "");
26052639 LLVMBasicBlockRef no_wrap_block = LLVMAppendBasicBlock(fn_val, "NoWrap");
26062640 LLVMBasicBlockRef yes_wrap_block = LLVMAppendBasicBlock(fn_val, "YesWrap");
......@@ -2608,14 +2642,14 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
26082642 LLVMBuildCondBr(g->builder, no_wrap_bit, no_wrap_block, yes_wrap_block);
26092643
26102644 LLVMPositionBuilderAtEnd(g->builder, no_wrap_block);
2611 LLVMValueRef usize_zero = LLVMConstNull(g->builtin_types.entry_usize->llvm_type);
2645 LLVMValueRef usize_zero = LLVMConstNull(usize_type_ref);
26122646 LLVMBuildStore(g->builder, usize_zero, frame_index_ptr);
26132647 LLVMBuildStore(g->builder, src_index_val, frames_left_ptr);
26142648 LLVMValueRef frames_left_eq_zero_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, src_index_val, usize_zero, "");
26152649 LLVMBuildCondBr(g->builder, frames_left_eq_zero_bit, return_block, loop_block);
26162650
26172651 LLVMPositionBuilderAtEnd(g->builder, yes_wrap_block);
2618 LLVMValueRef usize_one = LLVMConstInt(g->builtin_types.entry_usize->llvm_type, 1, false);
2652 LLVMValueRef usize_one = LLVMConstInt(usize_type_ref, 1, false);
26192653 LLVMValueRef plus_one = LLVMBuildNUWAdd(g->builder, src_index_val, usize_one, "");
26202654 LLVMValueRef mod_len = LLVMBuildURem(g->builder, plus_one, src_len_val, "");
26212655 LLVMBuildStore(g->builder, mod_len, frame_index_ptr);
......@@ -2623,12 +2657,15 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
26232657 LLVMBuildBr(g->builder, loop_block);
26242658
26252659 LLVMPositionBuilderAtEnd(g->builder, loop_block);
2626 LLVMValueRef ptr_index = LLVMBuildLoad(g->builder, frame_index_ptr, "");
2627 LLVMValueRef addr_ptr = LLVMBuildInBoundsGEP(g->builder, src_ptr_val, &ptr_index, 1, "");
2628 LLVMValueRef this_addr_val = LLVMBuildLoad(g->builder, addr_ptr, "");
2660 LLVMValueRef ptr_index = LLVMBuildLoad2(g->builder, usize_type_ref, frame_index_ptr, "");
2661 LLVMValueRef addr_ptr = LLVMBuildInBoundsGEP2(g->builder,
2662 usize_type_ref, src_ptr_val, &ptr_index, 1, "");
2663 LLVMValueRef this_addr_val = LLVMBuildLoad2(g->builder, LLVMGetGEPSourceElementType(addr_ptr),
2664 addr_ptr, "");
26292665 LLVMValueRef args[] = {dest_stack_trace_ptr, this_addr_val};
2630 ZigLLVMBuildCall(g->builder, add_error_return_trace_addr_fn_val, args, 2, get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAlwaysInline, "");
2631 LLVMValueRef prev_frames_left = LLVMBuildLoad(g->builder, frames_left_ptr, "");
2666 ZigLLVMBuildCall(g->builder, LLVMTypeOf(add_error_return_trace_addr_fn_val),
2667 add_error_return_trace_addr_fn_val, args, 2, get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAlwaysInline, "");
2668 LLVMValueRef prev_frames_left = LLVMBuildLoad2(g->builder, usize_type_ref, frames_left_ptr, "");
26322669 LLVMValueRef new_frames_left = LLVMBuildNUWSub(g->builder, prev_frames_left, usize_one, "");
26332670 LLVMValueRef done_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, new_frames_left, usize_zero, "");
26342671 LLVMBasicBlockRef continue_block = LLVMAppendBasicBlock(fn_val, "Continue");
......@@ -2639,7 +2676,7 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
26392676
26402677 LLVMPositionBuilderAtEnd(g->builder, continue_block);
26412678 LLVMBuildStore(g->builder, new_frames_left, frames_left_ptr);
2642 LLVMValueRef prev_index = LLVMBuildLoad(g->builder, frame_index_ptr, "");
2679 LLVMValueRef prev_index = LLVMBuildLoad2(g->builder, usize_type_ref, frame_index_ptr, "");
26432680 LLVMValueRef index_plus_one = LLVMBuildNUWAdd(g->builder, prev_index, usize_one, "");
26442681 LLVMValueRef index_mod_len = LLVMBuildURem(g->builder, index_plus_one, src_len_val, "");
26452682 LLVMBuildStore(g->builder, index_mod_len, frame_index_ptr);
......@@ -2666,13 +2703,14 @@ static LLVMValueRef ir_render_save_err_ret_addr(CodeGen *g, Stage1Air *executabl
26662703 bool is_llvm_alloca;
26672704 LLVMValueRef my_err_trace_val = get_cur_err_ret_trace_val(g, save_err_ret_addr_instruction->base.scope,
26682705 &is_llvm_alloca);
2669 ZigLLVMBuildCall(g->builder, return_err_fn, &my_err_trace_val, 1,
2706 ZigLLVMBuildCall(g->builder, LLVMTypeOf(return_err_fn), return_err_fn, &my_err_trace_val, 1,
26702707 get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
26712708
26722709 ZigType *ret_type = g->cur_fn->type_entry->data.fn.fn_type_id.return_type;
26732710 if (fn_is_async(g->cur_fn) && codegen_fn_has_err_ret_tracing_arg(g, ret_type)) {
2674 LLVMValueRef trace_ptr_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr,
2675 frame_index_trace_arg(g, ret_type), "");
2711 ZigType *frame_type = get_fn_frame_type(g, g->cur_fn);
2712 LLVMValueRef trace_ptr_ptr = LLVMBuildStructGEP2(g->builder, get_llvm_type(g, frame_type),
2713 g->cur_frame_ptr, frame_index_trace_arg(g, ret_type), "");
26762714 LLVMBuildStore(g->builder, my_err_trace_val, trace_ptr_ptr);
26772715 }
26782716
......@@ -2702,16 +2740,20 @@ static void gen_assert_resume_id(CodeGen *g, Stage1AirInst *source_instr, Resume
27022740 LLVMPositionBuilderAtEnd(g->builder, end_bb);
27032741}
27042742
2705static LLVMValueRef gen_resume(CodeGen *g, LLVMValueRef fn_val, LLVMValueRef target_frame_ptr, ResumeId resume_id) {
2743static LLVMValueRef gen_resume(CodeGen *g, LLVMValueRef fn_val, LLVMValueRef target_frame_ptr,
2744 ResumeId resume_id)
2745{
27062746 LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
27072747 if (fn_val == nullptr) {
2708 LLVMValueRef fn_ptr_ptr = LLVMBuildStructGEP(g->builder, target_frame_ptr, frame_fn_ptr_index, "");
2709 fn_val = LLVMBuildLoad(g->builder, fn_ptr_ptr, "");
2748 LLVMValueRef fn_ptr_ptr = LLVMBuildStructGEP2(g->builder, g->any_frame_header_llvm_ty,
2749 target_frame_ptr, frame_fn_ptr_index, "");
2750 fn_val = LLVMBuildLoad2(g->builder, LLVMPointerTypeInContext(LLVMGetGlobalContext(), 0),
2751 fn_ptr_ptr, "");
27102752 }
27112753 LLVMValueRef arg_val = LLVMConstSub(LLVMConstAllOnes(usize_type_ref),
27122754 LLVMConstInt(usize_type_ref, resume_id, false));
27132755 LLVMValueRef args[] = {target_frame_ptr, arg_val};
2714 return ZigLLVMBuildCall(g->builder, fn_val, args, 2, ZigLLVM_Fast, ZigLLVM_CallAttrAuto, "");
2756 return ZigLLVMBuildCall(g->builder, LLVMTypeOf(fn_val), fn_val, args, 2, ZigLLVM_Fast, ZigLLVM_CallAttrAuto, "");
27152757}
27162758
27172759static LLVMBasicBlockRef gen_suspend_begin(CodeGen *g, const char *name_hint) {
......@@ -2733,11 +2775,11 @@ static void set_tail_call_if_appropriate(CodeGen *g, LLVMValueRef call_inst) {
27332775 LLVMSetTailCall(call_inst, true);
27342776}
27352777
2736static LLVMValueRef gen_maybe_atomic_op(CodeGen *g, LLVMAtomicRMWBinOp op, LLVMValueRef ptr, LLVMValueRef val,
2737 LLVMAtomicOrdering order)
2778static LLVMValueRef gen_maybe_atomic_op(CodeGen *g, LLVMAtomicRMWBinOp op, LLVMValueRef ptr,
2779 LLVMValueRef val, LLVMAtomicOrdering order)
27382780{
27392781 if (g->is_single_threaded) {
2740 LLVMValueRef loaded = LLVMBuildLoad(g->builder, ptr, "");
2782 LLVMValueRef loaded = LLVMBuildLoad2(g->builder, LLVMTypeOf(val), ptr, "");
27412783 LLVMValueRef modified;
27422784 switch (op) {
27432785 case LLVMAtomicRMWBinOpXchg:
......@@ -2811,8 +2853,11 @@ static void gen_async_return(CodeGen *g, Stage1AirInstReturn *instruction) {
28112853 // If the awaiter result pointer is non-null, we need to copy the result to there.
28122854 LLVMBasicBlockRef copy_block = LLVMAppendBasicBlock(g->cur_fn_val, "CopyResult");
28132855 LLVMBasicBlockRef copy_end_block = LLVMAppendBasicBlock(g->cur_fn_val, "CopyResultEnd");
2814 LLVMValueRef awaiter_ret_ptr_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, frame_ret_start + 1, "");
2815 LLVMValueRef awaiter_ret_ptr = LLVMBuildLoad(g->builder, awaiter_ret_ptr_ptr, "");
2856 LLVMValueRef awaiter_ret_ptr_ptr = LLVMBuildStructGEP2(g->builder,
2857 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
2858 g->cur_frame_ptr, frame_ret_start + 1, "");
2859 LLVMValueRef awaiter_ret_ptr = LLVMBuildLoad2(g->builder,
2860 LLVMPointerTypeInContext(LLVMGetGlobalContext(), 0), awaiter_ret_ptr_ptr, "");
28162861 LLVMValueRef zero_ptr = LLVMConstNull(LLVMTypeOf(awaiter_ret_ptr));
28172862 LLVMValueRef need_copy_bit = LLVMBuildICmp(g->builder, LLVMIntNE, awaiter_ret_ptr, zero_ptr, "");
28182863 LLVMBuildCondBr(g->builder, need_copy_bit, copy_block, copy_end_block);
......@@ -2831,20 +2876,25 @@ static void gen_async_return(CodeGen *g, Stage1AirInstReturn *instruction) {
28312876
28322877 LLVMPositionBuilderAtEnd(g->builder, copy_end_block);
28332878 if (codegen_fn_has_err_ret_tracing_arg(g, ret_type)) {
2834 LLVMValueRef awaiter_trace_ptr_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr,
2835 frame_index_trace_arg(g, ret_type) + 1, "");
2836 LLVMValueRef dest_trace_ptr = LLVMBuildLoad(g->builder, awaiter_trace_ptr_ptr, "");
2879 LLVMValueRef awaiter_trace_ptr_ptr = LLVMBuildStructGEP2(g->builder,
2880 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
2881 g->cur_frame_ptr, frame_index_trace_arg(g, ret_type) + 1, "");
2882 LLVMValueRef dest_trace_ptr = LLVMBuildLoad2(g->builder,
2883 LLVMPointerTypeInContext(LLVMGetGlobalContext(), 0),
2884 awaiter_trace_ptr_ptr, "");
28372885 bool is_llvm_alloca;
28382886 LLVMValueRef my_err_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope, &is_llvm_alloca);
28392887 LLVMValueRef args[] = { dest_trace_ptr, my_err_trace_val };
2840 ZigLLVMBuildCall(g->builder, get_merge_err_ret_traces_fn_val(g), args, 2,
2888 ZigLLVMBuildCall(g->builder, LLVMTypeOf(get_merge_err_ret_traces_fn_val(g)),
2889 get_merge_err_ret_traces_fn_val(g), args, 2,
28412890 get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
28422891 }
28432892 }
28442893
28452894 // Resume the caller by tail calling them.
28462895 ZigType *any_frame_type = get_any_frame_type(g, ret_type);
2847 LLVMValueRef their_frame_ptr = LLVMBuildIntToPtr(g->builder, prev_val, get_llvm_type(g, any_frame_type), "");
2896 LLVMValueRef their_frame_ptr = LLVMBuildIntToPtr(g->builder, prev_val,
2897 get_llvm_type(g, any_frame_type), "");
28482898 LLVMValueRef call_inst = gen_resume(g, nullptr, their_frame_ptr, ResumeIdReturn);
28492899 set_tail_call_if_appropriate(g, call_inst);
28502900 LLVMBuildRetVoid(g->builder);
......@@ -2853,21 +2903,14 @@ static void gen_async_return(CodeGen *g, Stage1AirInstReturn *instruction) {
28532903static LLVMValueRef gen_convert_to_c_abi(CodeGen *g, LLVMValueRef location, LLVMValueRef value) {
28542904 ZigType *return_type = g->cur_fn->type_entry->data.fn.gen_return_type;
28552905 size_t size = type_size(g, return_type);
2856
28572906 LLVMTypeRef abi_return_type = get_llvm_c_abi_type(g, return_type);
2858 LLVMTypeRef abi_return_type_pointer = LLVMPointerType(abi_return_type, 0);
28592907
28602908 if (size < 8) {
2861 LLVMValueRef bitcast = LLVMBuildBitCast(g->builder, value, abi_return_type_pointer, "");
2862 return LLVMBuildLoad(g->builder, bitcast, "");
2909 return LLVMBuildLoad2(g->builder, abi_return_type, value, "");
28632910 } else {
2864 LLVMTypeRef i8ptr = LLVMPointerType(LLVMInt8Type(), 0);
2865 LLVMValueRef bc_location = LLVMBuildBitCast(g->builder, location, i8ptr, "");
2866 LLVMValueRef bc_value = LLVMBuildBitCast(g->builder, value, i8ptr, "");
2867
28682911 LLVMValueRef len = LLVMConstInt(LLVMInt64Type(), size, false);
2869 ZigLLVMBuildMemCpy(g->builder, bc_location, 8, bc_value, return_type->abi_align, len, false);
2870 return LLVMBuildLoad(g->builder, location, "");
2912 ZigLLVMBuildMemCpy(g->builder, location, 8, value, return_type->abi_align, len, false);
2913 return LLVMBuildLoad2(g->builder, abi_return_type, location, "");
28712914 }
28722915}
28732916
......@@ -2903,19 +2946,21 @@ static LLVMValueRef ir_render_return(CodeGen *g, Stage1Air *executable, Stage1Ai
29032946 } else if (g->cur_fn->type_entry->data.fn.fn_type_id.cc != CallingConventionAsync &&
29042947 handle_is_ptr(g, g->cur_fn->type_entry->data.fn.fn_type_id.return_type))
29052948 {
2949 LLVMTypeRef ret_llvm_ty = get_llvm_type(g, g->cur_fn->type_entry->data.fn.fn_type_id.return_type);
29062950 if (instruction->operand == nullptr) {
2907 LLVMValueRef by_val_value = gen_load_untyped(g, g->cur_ret_ptr, 0, false, "");
2951 LLVMValueRef by_val_value = gen_load_untyped(g, ret_llvm_ty, g->cur_ret_ptr, 0, false, "");
29082952 LLVMBuildRet(g->builder, by_val_value);
29092953 } else {
29102954 LLVMValueRef value = ir_llvm_value(g, instruction->operand);
2911 LLVMValueRef by_val_value = gen_load_untyped(g, value, 0, false, "");
2955 LLVMValueRef by_val_value = gen_load_untyped(g, ret_llvm_ty, value, 0, false, "");
29122956 LLVMBuildRet(g->builder, by_val_value);
29132957 }
29142958 } else if (instruction->operand == nullptr) {
29152959 if (g->cur_ret_ptr == nullptr) {
29162960 LLVMBuildRetVoid(g->builder);
29172961 } else {
2918 LLVMValueRef by_val_value = gen_load_untyped(g, g->cur_ret_ptr, 0, false, "");
2962 LLVMTypeRef ret_llvm_ty = get_llvm_type(g, g->cur_fn->type_entry->data.fn.fn_type_id.return_type);
2963 LLVMValueRef by_val_value = gen_load_untyped(g, ret_llvm_ty, g->cur_ret_ptr, 0, false, "");
29192964 LLVMBuildRet(g->builder, by_val_value);
29202965 }
29212966 } else {
......@@ -3011,20 +3056,18 @@ static LLVMValueRef gen_soft_float_un_op(CodeGen *g, LLVMValueRef op, ZigType *o
30113056 float_un_op_to_name(op_id), libc_float_suffix(g, scalar_type));
30123057 LLVMValueRef func_ref = get_soft_float_fn(g, fn_name, 1, scalar_type->llvm_type, scalar_type->llvm_type);
30133058
3014 LLVMValueRef result;
30153059 if (vector_len == 0) {
3016 return LLVMBuildCall(g->builder, func_ref, &op, 1, "");
3060 return LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, &op, 1, "");
30173061 } else {
3018 result = build_alloca(g, operand_type, "", 0);
3062 LLVMValueRef result = LLVMGetUndef(operand_type->llvm_type);
30193063 LLVMTypeRef usize_ref = g->builtin_types.entry_usize->llvm_type;
30203064 for (uint32_t i = 0; i < vector_len; i++) {
30213065 LLVMValueRef index_value = LLVMConstInt(usize_ref, i, false);
30223066 LLVMValueRef param = LLVMBuildExtractElement(g->builder, op, index_value, "");
3023 LLVMValueRef call_result = LLVMBuildCall(g->builder, func_ref, &param, 1, "");
3024 LLVMBuildInsertElement(g->builder, LLVMBuildLoad(g->builder, result, ""),
3025 call_result, index_value, "");
3067 LLVMValueRef call_result = LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, &param, 1, "");
3068 result = LLVMBuildInsertElement(g->builder, result, call_result, index_value, "");
30263069 }
3027 return LLVMBuildLoad(g->builder, result, "");
3070 return result;
30283071 }
30293072}
30303073
......@@ -3038,7 +3081,7 @@ static LLVMValueRef gen_float_un_op(CodeGen *g, LLVMValueRef operand, ZigType *o
30383081 return gen_soft_float_un_op(g, operand, operand_type, op);
30393082 }
30403083 LLVMValueRef float_op_fn = get_float_fn(g, operand_type, ZigLLVMFnIdFloatOp, op);
3041 return LLVMBuildCall(g->builder, float_op_fn, &operand, 1, "");
3084 return LLVMBuildCall2(g->builder, LLVMTypeOf(float_op_fn), float_op_fn, &operand, 1, "");
30423085}
30433086
30443087enum DivKind {
......@@ -3404,7 +3447,7 @@ static LLVMValueRef gen_soft_int_to_float_op(CodeGen *g, LLVMValueRef value_ref,
34043447 }
34053448
34063449 LLVMValueRef params[1] = {value_ref};
3407 return LLVMBuildCall(g->builder, func_ref, params, param_count, "");
3450 return LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, params, param_count, "");
34083451}
34093452
34103453static LLVMValueRef gen_soft_float_to_int_op(CodeGen *g, LLVMValueRef value_ref, ZigType *operand_type, ZigType *result_type) {
......@@ -3440,7 +3483,7 @@ static LLVMValueRef gen_soft_float_to_int_op(CodeGen *g, LLVMValueRef value_ref,
34403483 }
34413484
34423485 LLVMValueRef params[1] = {value_ref};
3443 LLVMValueRef result = LLVMBuildCall(g->builder, func_ref, params, param_count, "");
3486 LLVMValueRef result = LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, params, param_count, "");
34443487
34453488 if ((wider_type->data.integral.bit_count == 128) && (g->zig_target->os == OsWindows) && (g->zig_target->arch == ZigLLVM_x86_64)) {
34463489 result = LLVMBuildBitCast(g->builder, result, wider_type->llvm_type, "");
......@@ -3553,12 +3596,12 @@ static LLVMValueRef gen_soft_float_bin_op(CodeGen *g, LLVMValueRef op1_value, LL
35533596 LLVMValueRef result;
35543597 if (vector_len == 0) {
35553598 LLVMValueRef params[2] = {op1_value, op2_value};
3556 result = LLVMBuildCall(g->builder, func_ref, params, param_count, "");
3599 result = LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, params, param_count, "");
35573600 result = add_icmp(g, result, res_icmp);
35583601 } else {
35593602 ZigType *alloca_ty = operand_type;
35603603 if (res_icmp != NONE) alloca_ty = get_vector_type(g, vector_len, g->builtin_types.entry_bool);
3561 result = build_alloca(g, alloca_ty, "", 0);
3604 result = LLVMGetUndef(alloca_ty->llvm_type);
35623605
35633606 LLVMTypeRef usize_ref = g->builtin_types.entry_usize->llvm_type;
35643607 for (uint32_t i = 0; i < vector_len; i++) {
......@@ -3567,13 +3610,10 @@ static LLVMValueRef gen_soft_float_bin_op(CodeGen *g, LLVMValueRef op1_value, LL
35673610 LLVMBuildExtractElement(g->builder, op1_value, index_value, ""),
35683611 LLVMBuildExtractElement(g->builder, op2_value, index_value, ""),
35693612 };
3570 LLVMValueRef call_result = LLVMBuildCall(g->builder, func_ref, params, param_count, "");
3613 LLVMValueRef call_result = LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, params, param_count, "");
35713614 call_result = add_icmp(g, call_result, res_icmp);
3572 LLVMBuildInsertElement(g->builder, LLVMBuildLoad(g->builder, result, ""),
3573 call_result, index_value, "");
3615 result = LLVMBuildInsertElement(g->builder, result, call_result, index_value, "");
35743616 }
3575
3576 result = LLVMBuildLoad(g->builder, result, "");
35773617 }
35783618
35793619 // Some operations are implemented as compound ops and require us to perform some
......@@ -3703,7 +3743,9 @@ static LLVMValueRef ir_render_bin_op(CodeGen *g, Stage1Air *executable,
37033743 }
37043744
37053745 // TODO runtime safety
3706 return LLVMBuildInBoundsGEP(g->builder, op1_value, &subscript_value, 1, "");
3746 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, scalar_type->data.pointer.child_type);
3747 return LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, op1_value,
3748 &subscript_value, 1, "");
37073749 } else if (scalar_type->id == ZigTypeIdFloat) {
37083750 ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
37093751 return float_op[add_sub_mul](g->builder, op1_value, op2_value, "");
......@@ -4044,20 +4086,23 @@ static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen *g, Stage1Air *execu
40444086 assert(array_type->id == ZigTypeIdArray);
40454087
40464088 if (type_has_bits(g, actual_type)) {
4047 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, result_loc, ptr_index, "");
4089 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP2(g->builder, get_llvm_type(g, slice_type),
4090 result_loc, ptr_index, "");
40484091 LLVMValueRef indices[] = {
40494092 LLVMConstNull(g->builtin_types.entry_usize->llvm_type),
40504093 LLVMConstInt(g->builtin_types.entry_usize->llvm_type, 0, false),
40514094 };
40524095 LLVMValueRef expr_val = ir_llvm_value(g, instruction->operand);
4053 LLVMValueRef slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, expr_val, indices, 2, "");
4096 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, array_type->data.array.child_type);
4097 LLVMValueRef slice_start_ptr = LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, expr_val,
4098 indices, 2, "");
40544099 gen_store_untyped(g, slice_start_ptr, ptr_field_ptr, 0, false);
40554100 } else if (ir_want_runtime_safety(g, &instruction->base) && ptr_index != SIZE_MAX) {
4056 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, result_loc, ptr_index, "");
4101 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP2(g->builder, get_llvm_type(g, slice_type), result_loc, ptr_index, "");
40574102 gen_undef_init(g, slice_ptr_type, slice_ptr_type, ptr_field_ptr);
40584103 }
40594104
4060 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, result_loc, len_index, "");
4105 LLVMValueRef len_field_ptr = LLVMBuildStructGEP2(g->builder, get_llvm_type(g, slice_type), result_loc, len_index, "");
40614106 LLVMValueRef len_value = LLVMConstInt(g->builtin_types.entry_usize->llvm_type,
40624107 array_type->data.array.len, false);
40634108 gen_store_untyped(g, len_value, len_field_ptr, 0, false);
......@@ -4102,20 +4147,20 @@ static LLVMValueRef ir_render_bit_cast(CodeGen *g, Stage1Air *executable,
41024147 bool actual_is_ptr = handle_is_ptr(g, actual_type);
41034148 if (wanted_is_ptr == actual_is_ptr) {
41044149 // We either bitcast the value directly or bitcast the pointer which does a pointer cast
4105 LLVMTypeRef wanted_type_ref = wanted_is_ptr ?
4106 LLVMPointerType(get_llvm_type(g, wanted_type), 0) : get_llvm_type(g, wanted_type);
4107 return LLVMBuildBitCast(g->builder, value, wanted_type_ref, "");
4150 if (wanted_is_ptr) {
4151 return value;
4152 } else {
4153 LLVMTypeRef wanted_type_ref = get_llvm_type(g, wanted_type);
4154 return LLVMBuildBitCast(g->builder, value, wanted_type_ref, "");
4155 }
41084156 } else if (actual_is_ptr) {
41094157 // A scalar is wanted but we got a pointer
4110 LLVMTypeRef wanted_ptr_type_ref = LLVMPointerType(get_llvm_type(g, wanted_type), 0);
4111 LLVMValueRef bitcasted_ptr = LLVMBuildBitCast(g->builder, value, wanted_ptr_type_ref, "");
41124158 uint32_t alignment = get_abi_alignment(g, actual_type);
4113 return gen_load_untyped(g, bitcasted_ptr, alignment, false, "");
4159 return gen_load_untyped(g, get_llvm_type(g, wanted_type), value, alignment, false, "");
41144160 } else {
41154161 // A pointer is wanted but we got a scalar
41164162 assert(actual_type->id == ZigTypeIdPointer);
4117 LLVMTypeRef wanted_ptr_type_ref = LLVMPointerType(get_llvm_type(g, wanted_type), 0);
4118 return LLVMBuildBitCast(g->builder, value, wanted_ptr_type_ref, "");
4163 return value;
41194164 }
41204165}
41214166
......@@ -4298,32 +4343,26 @@ static LLVMValueRef ir_render_binary_not(CodeGen *g, Stage1Air *executable,
42984343
42994344static LLVMValueRef gen_soft_float_neg(CodeGen *g, ZigType *operand_type, LLVMValueRef operand) {
43004345 uint32_t vector_len = operand_type->id == ZigTypeIdVector ? operand_type->data.vector.len : 0;
4301 uint16_t num_bits = operand_type->data.floating.bit_count;
4346 uint16_t num_bits = operand_type->id == ZigTypeIdVector ?
4347 operand_type->data.vector.elem_type->data.floating.bit_count :
4348 operand_type->data.floating.bit_count;
43024349
43034350 ZigType *iX_type = get_int_type(g, true, num_bits);
4304 LLVMValueRef sign_mask = LLVMConstInt(iX_type->llvm_type, 1, false);
4305 sign_mask = LLVMConstShl(sign_mask, LLVMConstInt(iX_type->llvm_type, num_bits - 1, false));
4351 LLVMValueRef sign_mask = LLVMConstShl(
4352 LLVMConstInt(iX_type->llvm_type, 1, false),
4353 LLVMConstInt(iX_type->llvm_type, num_bits - 1, false));
43064354
4307 if (vector_len == 0) {
4308 LLVMValueRef bitcasted_operand = LLVMBuildBitCast(g->builder, operand, iX_type->llvm_type, "");
4309 LLVMValueRef result = LLVMBuildXor(g->builder, bitcasted_operand, sign_mask, "");
4355 LLVMValueRef sign_mask_splat = (vector_len == 0) ? sign_mask :
4356 LLVMBuildVectorSplat(g->builder, vector_len, sign_mask, "");
43104357
4311 return LLVMBuildBitCast(g->builder, result, operand_type->llvm_type, "");
4312 } else {
4313 LLVMTypeRef usize_ref = g->builtin_types.entry_usize->llvm_type;
4314 ZigType *iX_vector_type = get_vector_type(g, vector_len, iX_type);
4358 LLVMValueRef bitcasted_operand = LLVMBuildBitCast(g->builder, operand,
4359 (vector_len == 0) ?
4360 iX_type->llvm_type :
4361 get_vector_type(g, vector_len, iX_type)->llvm_type,
4362 "");
43154363
4316 LLVMValueRef result = build_alloca(g, iX_vector_type, "", 0);
4317 LLVMValueRef bitcasted_operand = LLVMBuildBitCast(g->builder, operand, iX_vector_type->llvm_type, "");
4318 for (uint32_t i = 0; i < vector_len; i++) {
4319 LLVMValueRef index_value = LLVMConstInt(usize_ref, i, false);
4320 LLVMValueRef elem = LLVMBuildExtractElement(g->builder, bitcasted_operand, index_value, "");
4321 LLVMValueRef result_elem = LLVMBuildXor(g->builder, elem, sign_mask, "");
4322 LLVMBuildInsertElement(g->builder, LLVMBuildLoad(g->builder, result, ""),
4323 result_elem, index_value, "");
4324 }
4325 return LLVMBuildBitCast(g->builder, LLVMBuildLoad(g->builder, result, ""), operand_type->llvm_type, "");
4326 }
4364 LLVMValueRef result = LLVMBuildXor(g->builder, bitcasted_operand, sign_mask_splat, "");
4365 return LLVMBuildBitCast(g->builder, result, operand_type->llvm_type, "");
43274366}
43284367
43294368static LLVMValueRef gen_negation(CodeGen *g, Stage1AirInst *inst, Stage1AirInst *operand, bool wrapping) {
......@@ -4398,7 +4437,7 @@ static LLVMValueRef ir_render_load_ptr(CodeGen *g, Stage1Air *executable,
43984437 if (ptr_type->data.pointer.vector_index != VECTOR_INDEX_NONE) {
43994438 LLVMValueRef index_val = LLVMConstInt(LLVMInt32Type(),
44004439 ptr_type->data.pointer.vector_index, false);
4401 LLVMValueRef loaded_vector = LLVMBuildLoad(g->builder, ptr, "");
4440 LLVMValueRef loaded_vector = LLVMBuildLoad2(g->builder, get_llvm_type(g, child_type), ptr, "");
44024441 return LLVMBuildExtractElement(g->builder, loaded_vector, index_val, "");
44034442 }
44044443
......@@ -4524,7 +4563,8 @@ static LLVMValueRef gen_valgrind_client_request(CodeGen *g, LLVMValueRef default
45244563 zero,
45254564 LLVMConstInt(usize_type_ref, i, false),
45264565 };
4527 LLVMValueRef elem_ptr = LLVMBuildInBoundsGEP(g->builder, array_ptr, indexes, 2, "");
4566 LLVMValueRef elem_ptr = LLVMBuildInBoundsGEP2(g->builder, usize_type_ref,
4567 array_ptr, indexes, 2, "");
45284568 LLVMBuildStore(g->builder, array_elements[i], elem_ptr);
45294569 }
45304570
......@@ -4545,7 +4585,7 @@ static LLVMValueRef gen_valgrind_client_request(CodeGen *g, LLVMValueRef default
45454585 LLVMValueRef asm_fn = LLVMGetInlineAsm(function_type, buf_ptr(asm_template), buf_len(asm_template),
45464586 buf_ptr(asm_constraints), buf_len(asm_constraints), asm_has_side_effects, asm_is_alignstack,
45474587 LLVMInlineAsmDialectATT, false);
4548 return LLVMBuildCall(g->builder, asm_fn, param_values, input_and_output_count, "");
4588 return LLVMBuildCall2(g->builder, LLVMTypeOf(asm_fn), asm_fn, param_values, input_and_output_count, "");
45494589 }
45504590 }
45514591 zig_unreachable();
......@@ -4713,16 +4753,13 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, Stage1Air *executable, Stage1
47134753 size_t host_int_bytes = ptr_type->data.pointer.host_int_bytes;
47144754 if (host_int_bytes != 0) {
47154755 uint32_t size_in_bits = type_size_bits(g, ptr_type->data.pointer.child_type);
4716 LLVMTypeRef ptr_u8_type_ref = LLVMPointerType(LLVMInt8Type(), 0);
4717 LLVMValueRef u8_array_ptr = LLVMBuildBitCast(g->builder, array_ptr, ptr_u8_type_ref, "");
47184756 assert(size_in_bits % 8 == 0);
47194757 LLVMValueRef elem_size_bytes = LLVMConstInt(g->builtin_types.entry_usize->llvm_type,
47204758 size_in_bits / 8, false);
47214759 LLVMValueRef byte_offset = LLVMBuildNUWMul(g->builder, subscript_value, elem_size_bytes, "");
4722 LLVMValueRef indices[] = {
4723 byte_offset
4724 };
4725 LLVMValueRef elem_byte_ptr = LLVMBuildInBoundsGEP(g->builder, u8_array_ptr, indices, 1, "");
4760 LLVMValueRef indices[] = { byte_offset };
4761 LLVMValueRef elem_byte_ptr = LLVMBuildInBoundsGEP2(g->builder, LLVMInt8Type(),
4762 array_ptr, indices, 1, "");
47264763 return LLVMBuildBitCast(g->builder, elem_byte_ptr, LLVMPointerType(get_llvm_type(g, child_type), 0), "");
47274764 }
47284765 }
......@@ -4730,14 +4767,14 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, Stage1Air *executable, Stage1
47304767 LLVMConstNull(g->builtin_types.entry_usize->llvm_type),
47314768 subscript_value
47324769 };
4733 return LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 2, "");
4770 return LLVMBuildInBoundsGEP2(g->builder, get_llvm_type(g, child_type), array_ptr,
4771 indices, 2, "");
47344772 } else if (array_type->id == ZigTypeIdPointer) {
47354773 LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
47364774 assert(LLVMGetTypeKind(LLVMTypeOf(array_ptr)) == LLVMPointerTypeKind);
4737 LLVMValueRef indices[] = {
4738 subscript_value
4739 };
4740 return LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 1, "");
4775 LLVMValueRef indices[] = { subscript_value };
4776 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, array_type->data.pointer.child_type);
4777 return LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, array_ptr, indices, 1, "");
47414778 } else if (array_type->id == ZigTypeIdStruct) {
47424779 LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
47434780 assert(array_type->data.structure.special == StructSpecialSlice);
......@@ -4752,22 +4789,26 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, Stage1Air *executable, Stage1
47524789 }
47534790
47544791 assert(LLVMGetTypeKind(LLVMTypeOf(array_ptr)) == LLVMPointerTypeKind);
4755 assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(array_ptr))) == LLVMStructTypeKind);
47564792
47574793 if (safety_check_on) {
47584794 size_t len_index = array_type->data.structure.fields[slice_len_index]->gen_index;
47594795 assert(len_index != SIZE_MAX);
4760 LLVMValueRef len_ptr = LLVMBuildStructGEP(g->builder, array_ptr, (unsigned)len_index, "");
4761 LLVMValueRef len = gen_load_untyped(g, len_ptr, 0, false, "");
4796 LLVMValueRef len_ptr = LLVMBuildStructGEP2(g->builder, get_llvm_type(g, array_type),
4797 array_ptr, (unsigned)len_index, "");
4798 LLVMValueRef len = gen_load_untyped(g, LLVMGetGEPSourceElementType(len_ptr), len_ptr,
4799 0, false, "");
47624800 LLVMIntPredicate upper_op = (ptr_type->data.pointer.sentinel != nullptr) ? LLVMIntULE : LLVMIntULT;
47634801 add_bounds_check(g, subscript_value, LLVMIntEQ, nullptr, upper_op, len);
47644802 }
47654803
47664804 size_t ptr_index = array_type->data.structure.fields[slice_ptr_index]->gen_index;
47674805 assert(ptr_index != SIZE_MAX);
4768 LLVMValueRef ptr_ptr = LLVMBuildStructGEP(g->builder, array_ptr, (unsigned)ptr_index, "");
4769 LLVMValueRef ptr = gen_load_untyped(g, ptr_ptr, 0, false, "");
4770 return LLVMBuildInBoundsGEP(g->builder, ptr, &subscript_value, 1, "");
4806 LLVMValueRef ptr_ptr = LLVMBuildStructGEP2(g->builder, get_llvm_type(g, array_type),
4807 array_ptr, (unsigned)ptr_index, "");
4808 LLVMValueRef ptr = gen_load_untyped(g, LLVMGetGEPSourceElementType(ptr_ptr), ptr_ptr, 0,
4809 false, "");
4810 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, ptr_type->data.pointer.child_type);
4811 return LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, ptr, &subscript_value, 1, "");
47714812 } else if (array_type->id == ZigTypeIdVector) {
47724813 return array_ptr_ptr;
47734814 } else {
......@@ -4775,12 +4816,16 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, Stage1Air *executable, Stage1
47754816 }
47764817}
47774818
4778static LLVMValueRef get_new_stack_addr(CodeGen *g, LLVMValueRef new_stack) {
4779 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, new_stack, (unsigned)slice_ptr_index, "");
4780 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, new_stack, (unsigned)slice_len_index, "");
4819static LLVMValueRef get_new_stack_addr(CodeGen *g, LLVMTypeRef new_stack_llvm_ty,
4820 LLVMValueRef new_stack)
4821{
4822 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP2(g->builder, new_stack_llvm_ty, new_stack, (unsigned)slice_ptr_index, "");
4823 LLVMValueRef len_field_ptr = LLVMBuildStructGEP2(g->builder, new_stack_llvm_ty, new_stack, (unsigned)slice_len_index, "");
47814824
4782 LLVMValueRef ptr_value = gen_load_untyped(g, ptr_field_ptr, 0, false, "");
4783 LLVMValueRef len_value = gen_load_untyped(g, len_field_ptr, 0, false, "");
4825 LLVMValueRef ptr_value = gen_load_untyped(g, LLVMGetGEPSourceElementType(ptr_field_ptr),
4826 ptr_field_ptr, 0, false, "");
4827 LLVMValueRef len_value = gen_load_untyped(g, LLVMGetGEPSourceElementType(len_field_ptr),
4828 len_field_ptr, 0, false, "");
47844829
47854830 LLVMValueRef ptr_addr = LLVMBuildPtrToInt(g->builder, ptr_value, LLVMTypeOf(len_value), "");
47864831 LLVMValueRef end_addr = LLVMBuildNUWAdd(g->builder, ptr_addr, len_value, "");
......@@ -4804,7 +4849,7 @@ static void gen_set_stack_pointer(CodeGen *g, LLVMValueRef aligned_end_addr) {
48044849 aligned_end_addr,
48054850 };
48064851
4807 LLVMBuildCall(g->builder, write_register_fn_val, params, 2, "");
4852 LLVMBuildCall2(g->builder, LLVMTypeOf(write_register_fn_val), write_register_fn_val, params, 2, "");
48084853}
48094854
48104855static void render_async_spills(CodeGen *g) {
......@@ -4834,7 +4879,9 @@ static void render_async_spills(CodeGen *g) {
48344879 }
48354880
48364881 calc_llvm_field_index_add(g, &arg_calc, var->var_type);
4837 var->value_ref = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, arg_calc.field_index - 1, var->name);
4882 var->value_ref = LLVMBuildStructGEP2(g->builder,
4883 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
4884 g->cur_frame_ptr, arg_calc.field_index - 1, var->name);
48384885 if (var->decl_node) {
48394886 var->di_loc_var = ZigLLVMCreateAutoVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
48404887 var->name, import->data.structure.root_struct->di_file,
......@@ -4852,7 +4899,9 @@ static void render_async_spills(CodeGen *g) {
48524899 continue;
48534900
48544901 size_t gen_index = frame_type->data.structure.fields[instruction->field_index]->gen_index;
4855 instruction->base.llvm_value = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, gen_index,
4902 instruction->base.llvm_value = LLVMBuildStructGEP2(g->builder,
4903 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
4904 g->cur_frame_ptr, gen_index,
48564905 instruction->name_hint);
48574906 }
48584907}
......@@ -4892,11 +4941,9 @@ static void render_async_var_decls(CodeGen *g, Scope *scope) {
48924941static LLVMValueRef gen_frame_size(CodeGen *g, LLVMValueRef fn_val) {
48934942 assert(g->need_frame_size_prefix_data);
48944943 LLVMTypeRef usize_llvm_type = g->builtin_types.entry_usize->llvm_type;
4895 LLVMTypeRef ptr_usize_llvm_type = LLVMPointerType(usize_llvm_type, 0);
4896 LLVMValueRef casted_fn_val = LLVMBuildBitCast(g->builder, fn_val, ptr_usize_llvm_type, "");
48974944 LLVMValueRef negative_one = LLVMConstInt(LLVMInt32Type(), -1, true);
4898 LLVMValueRef prefix_ptr = LLVMBuildInBoundsGEP(g->builder, casted_fn_val, &negative_one, 1, "");
4899 LLVMValueRef load_inst = LLVMBuildLoad(g->builder, prefix_ptr, "");
4945 LLVMValueRef prefix_ptr = LLVMBuildInBoundsGEP2(g->builder, usize_llvm_type, fn_val, &negative_one, 1, "");
4946 LLVMValueRef load_inst = LLVMBuildLoad2(g->builder, usize_llvm_type, prefix_ptr, "");
49004947
49014948 // Some architectures (e.g SPARCv9) has different alignment requirements between a
49024949 // function/usize pointer and also require all loads to be aligned.
......@@ -4910,17 +4957,23 @@ static LLVMValueRef gen_frame_size(CodeGen *g, LLVMValueRef fn_val) {
49104957static void gen_init_stack_trace(CodeGen *g, LLVMValueRef trace_field_ptr, LLVMValueRef addrs_field_ptr) {
49114958 LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
49124959 LLVMValueRef zero = LLVMConstNull(usize_type_ref);
4960 LLVMTypeRef stack_trace_llvm_ty = get_llvm_type(g, get_stack_trace_type(g));
49134961
4914 LLVMValueRef index_ptr = LLVMBuildStructGEP(g->builder, trace_field_ptr, 0, "");
4962 LLVMValueRef index_ptr = LLVMBuildStructGEP2(g->builder, stack_trace_llvm_ty, trace_field_ptr, 0, "");
49154963 LLVMBuildStore(g->builder, zero, index_ptr);
49164964
4917 LLVMValueRef addrs_slice_ptr = LLVMBuildStructGEP(g->builder, trace_field_ptr, 1, "");
4918 LLVMValueRef addrs_ptr_ptr = LLVMBuildStructGEP(g->builder, addrs_slice_ptr, slice_ptr_index, "");
4965 LLVMValueRef addrs_slice_ptr = LLVMBuildStructGEP2(g->builder, stack_trace_llvm_ty, trace_field_ptr, 1, "");
4966 LLVMValueRef addrs_ptr_ptr = LLVMBuildStructGEP2(g->builder,
4967 LLVMGetGEPSourceElementType(addrs_slice_ptr),
4968 addrs_slice_ptr, slice_ptr_index, "");
49194969 LLVMValueRef indices[] = { LLVMConstNull(usize_type_ref), LLVMConstNull(usize_type_ref) };
4920 LLVMValueRef trace_field_addrs_as_ptr = LLVMBuildInBoundsGEP(g->builder, addrs_field_ptr, indices, 2, "");
4970 LLVMValueRef trace_field_addrs_as_ptr = LLVMBuildInBoundsGEP2(g->builder,
4971 usize_type_ref, addrs_field_ptr, indices, 2, "");
49214972 LLVMBuildStore(g->builder, trace_field_addrs_as_ptr, addrs_ptr_ptr);
49224973
4923 LLVMValueRef addrs_len_ptr = LLVMBuildStructGEP(g->builder, addrs_slice_ptr, slice_len_index, "");
4974 LLVMValueRef addrs_len_ptr = LLVMBuildStructGEP2(g->builder,
4975 LLVMGetGEPSourceElementType(addrs_slice_ptr),
4976 addrs_slice_ptr, slice_len_index, "");
49244977 LLVMBuildStore(g->builder, LLVMConstInt(usize_type_ref, stack_trace_ptr_count, false), addrs_len_ptr);
49254978}
49264979
......@@ -4943,6 +4996,10 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
49434996 callee_is_async = fn_type->data.fn.fn_type_id.cc == CallingConventionAsync;
49444997 }
49454998
4999 LLVMTypeRef frame_struct_llvm_ty = (instruction->fn_entry != nullptr) ?
5000 get_llvm_type(g, get_fn_frame_type(g, instruction->fn_entry)) :
5001 g->any_frame_header_llvm_ty;
5002
49465003 FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
49475004
49485005 ZigType *src_return_type = fn_type_id->return_type;
......@@ -4971,8 +5028,7 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
49715028 ir_assert(instruction->frame_result_loc != nullptr, &instruction->base);
49725029 frame_result_loc_uncasted = ir_llvm_value(g, instruction->frame_result_loc);
49735030 ir_assert(instruction->fn_entry != nullptr, &instruction->base);
4974 frame_result_loc = LLVMBuildBitCast(g->builder, frame_result_loc_uncasted,
4975 LLVMPointerType(get_llvm_type(g, instruction->fn_entry->frame_type), 0), "");
5031 frame_result_loc = frame_result_loc_uncasted;
49765032 }
49775033 } else {
49785034 if (instruction->new_stack->value->type->id == ZigTypeIdPointer &&
......@@ -4981,9 +5037,12 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
49815037 frame_result_loc = ir_llvm_value(g, instruction->new_stack);
49825038 } else {
49835039 LLVMValueRef frame_slice_ptr = ir_llvm_value(g, instruction->new_stack);
5040 LLVMTypeRef frame_slice_llvm_ty =
5041 get_llvm_type(g, instruction->new_stack->value->type->data.pointer.child_type);
49845042 if (ir_want_runtime_safety(g, &instruction->base)) {
4985 LLVMValueRef given_len_ptr = LLVMBuildStructGEP(g->builder, frame_slice_ptr, slice_len_index, "");
4986 LLVMValueRef given_frame_len = LLVMBuildLoad(g->builder, given_len_ptr, "");
5043 LLVMValueRef given_len_ptr = LLVMBuildStructGEP2(g->builder,
5044 frame_slice_llvm_ty, frame_slice_ptr, slice_len_index, "");
5045 LLVMValueRef given_frame_len = LLVMBuildLoad2(g->builder, usize_type_ref, given_len_ptr, "");
49875046 LLVMValueRef actual_frame_len = gen_frame_size(g, fn_val);
49885047
49895048 LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "FrameSizeCheckFail");
......@@ -4998,18 +5057,18 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
49985057 LLVMPositionBuilderAtEnd(g->builder, ok_block);
49995058 }
50005059 need_frame_ptr_ptr_spill = true;
5001 LLVMValueRef frame_ptr_ptr = LLVMBuildStructGEP(g->builder, frame_slice_ptr, slice_ptr_index, "");
5002 LLVMValueRef frame_ptr = LLVMBuildLoad(g->builder, frame_ptr_ptr, "");
5060 LLVMValueRef frame_ptr_ptr = LLVMBuildStructGEP2(g->builder, frame_slice_llvm_ty,
5061 frame_slice_ptr, slice_ptr_index, "");
5062 LLVMValueRef frame_ptr = LLVMBuildLoad2(g->builder,
5063 LLVMGetGEPSourceElementType(frame_ptr_ptr), frame_ptr_ptr, "");
50035064 if (instruction->fn_entry == nullptr) {
50045065 anyframe_type = get_any_frame_type(g, src_return_type);
5005 frame_result_loc = LLVMBuildBitCast(g->builder, frame_ptr, get_llvm_type(g, anyframe_type), "");
5066 frame_result_loc = frame_ptr;
50065067 } else {
50075068 ZigType *frame_type = get_fn_frame_type(g, instruction->fn_entry);
50085069 if ((err = type_resolve(g, frame_type, ResolveStatusLLVMFull)))
50095070 codegen_report_errors_and_exit(g);
5010 ZigType *ptr_frame_type = get_pointer_to_type(g, frame_type, false);
5011 frame_result_loc = LLVMBuildBitCast(g->builder, frame_ptr,
5012 get_llvm_type(g, ptr_frame_type), "");
5071 frame_result_loc = frame_ptr;
50135072 }
50145073 }
50155074 }
......@@ -5019,7 +5078,8 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
50195078
50205079 if (ret_has_bits) {
50215080 // Use the result location which is inside the frame if this is an async call.
5022 ret_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start + 2, "");
5081 ret_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty,
5082 frame_result_loc, frame_ret_start + 2, "");
50235083 }
50245084 } else {
50255085 awaiter_init_val = zero;
......@@ -5030,7 +5090,8 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
50305090 ret_ptr = result_loc;
50315091 } else {
50325092 // no result location provided to @asyncCall - use the one inside the frame.
5033 ret_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start + 2, "");
5093 ret_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty,
5094 frame_result_loc, frame_ret_start + 2, "");
50345095 }
50355096 }
50365097 }
......@@ -5050,20 +5111,20 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
50505111 if (ret_has_bits) {
50515112 if (result_loc == nullptr) {
50525113 // return type is a scalar, but we still need a pointer to it. Use the async fn frame.
5053 ret_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start + 2, "");
5114 ret_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_ret_start + 2, "");
50545115 } else {
50555116 // Use the call instruction's result location.
50565117 ret_ptr = result_loc;
50575118 }
50585119
50595120 // Store a zero in the awaiter's result ptr to indicate we do not need a copy made.
5060 LLVMValueRef awaiter_ret_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start + 1, "");
5121 LLVMValueRef awaiter_ret_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_ret_start + 1, "");
50615122 LLVMValueRef zero_ptr = LLVMConstNull(LLVMGetElementType(LLVMTypeOf(awaiter_ret_ptr)));
50625123 LLVMBuildStore(g->builder, zero_ptr, awaiter_ret_ptr);
50635124 }
50645125
50655126 if (prefix_arg_err_ret_stack) {
5066 LLVMValueRef err_ret_trace_ptr_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc,
5127 LLVMValueRef err_ret_trace_ptr_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc,
50675128 frame_index_trace_arg(g, src_return_type) + 1, "");
50685129 bool is_llvm_alloca;
50695130 LLVMValueRef my_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope,
......@@ -5074,19 +5135,19 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
50745135
50755136 assert(frame_result_loc != nullptr);
50765137
5077 LLVMValueRef fn_ptr_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_fn_ptr_index, "");
5138 LLVMValueRef fn_ptr_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_fn_ptr_index, "");
50785139 LLVMValueRef bitcasted_fn_val = LLVMBuildBitCast(g->builder, fn_val,
50795140 LLVMGetElementType(LLVMTypeOf(fn_ptr_ptr)), "");
50805141 LLVMBuildStore(g->builder, bitcasted_fn_val, fn_ptr_ptr);
50815142
5082 LLVMValueRef resume_index_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_resume_index, "");
5143 LLVMValueRef resume_index_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_resume_index, "");
50835144 LLVMBuildStore(g->builder, zero, resume_index_ptr);
50845145
5085 LLVMValueRef awaiter_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_awaiter_index, "");
5146 LLVMValueRef awaiter_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_awaiter_index, "");
50865147 LLVMBuildStore(g->builder, awaiter_init_val, awaiter_ptr);
50875148
50885149 if (ret_has_bits) {
5089 LLVMValueRef ret_ptr_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start, "");
5150 LLVMValueRef ret_ptr_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_ret_start, "");
50905151 LLVMBuildStore(g->builder, ret_ptr, ret_ptr_ptr);
50915152 }
50925153 } else if (instruction->modifier == CallModifierAsync) {
......@@ -5097,12 +5158,12 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
50975158 frame_result_loc = result_loc;
50985159 awaiter_init_val = LLVMConstAllOnes(usize_type_ref);
50995160
5100 LLVMValueRef awaiter_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_awaiter_index, "");
5161 LLVMValueRef awaiter_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_awaiter_index, "");
51015162 LLVMBuildStore(g->builder, awaiter_init_val, awaiter_ptr);
51025163
51035164 if (ret_has_bits) {
5104 ret_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start + 2, "");
5105 LLVMValueRef ret_ptr_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start, "");
5165 ret_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_ret_start + 2, "");
5166 LLVMValueRef ret_ptr_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc, frame_ret_start, "");
51065167 LLVMBuildStore(g->builder, ret_ptr, ret_ptr_ptr);
51075168
51085169 if (first_arg_ret) {
......@@ -5113,11 +5174,11 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
51135174 // Then we have to wire up the StackTrace pointers.
51145175 // Await is responsible for merging error return traces.
51155176 uint32_t trace_field_index_start = frame_index_trace_arg(g, src_return_type);
5116 LLVMValueRef callee_trace_ptr_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc,
5177 LLVMValueRef callee_trace_ptr_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc,
51175178 trace_field_index_start, "");
5118 LLVMValueRef trace_field_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc,
5179 LLVMValueRef trace_field_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc,
51195180 trace_field_index_start + 2, "");
5120 LLVMValueRef addrs_field_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc,
5181 LLVMValueRef addrs_field_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty, frame_result_loc,
51215182 trace_field_index_start + 3, "");
51225183
51235184 LLVMBuildStore(g->builder, trace_field_ptr, callee_trace_ptr_ptr);
......@@ -5177,7 +5238,7 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
51775238 CalcLLVMFieldIndex arg_calc_start = {0};
51785239 frame_index_arg_calc(g, &arg_calc_start, fn_type->data.fn.fn_type_id.return_type);
51795240
5180 LLVMValueRef casted_frame;
5241 LLVMTypeRef casted_frame_llvm_ty;
51815242 if (instruction->new_stack != nullptr && instruction->fn_entry == nullptr) {
51825243 // We need the frame type to be a pointer to a struct that includes the args
51835244
......@@ -5208,17 +5269,15 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
52085269 }
52095270 LLVMTypeRef frame_with_args_type = LLVMStructType(field_types, field_count, false);
52105271 heap::c_allocator.deallocate(field_types, field_count);
5211 LLVMTypeRef ptr_frame_with_args_type = LLVMPointerType(frame_with_args_type, 0);
5212
5213 casted_frame = LLVMBuildBitCast(g->builder, frame_result_loc, ptr_frame_with_args_type, "");
5272 casted_frame_llvm_ty = frame_with_args_type;
52145273 } else {
5215 casted_frame = frame_result_loc;
5274 casted_frame_llvm_ty = frame_struct_llvm_ty;
52165275 }
52175276
52185277 CalcLLVMFieldIndex arg_calc = arg_calc_start;
52195278 for (size_t arg_i = 0; arg_i < gen_param_values.length; arg_i += 1) {
52205279 calc_llvm_field_index_add(g, &arg_calc, gen_param_types.at(arg_i));
5221 LLVMValueRef arg_ptr = LLVMBuildStructGEP(g->builder, casted_frame, arg_calc.field_index - 1, "");
5280 LLVMValueRef arg_ptr = LLVMBuildStructGEP2(g->builder, casted_frame_llvm_ty, frame_result_loc, arg_calc.field_index - 1, "");
52225281 gen_assign_raw(g, arg_ptr, get_pointer_to_type(g, gen_param_types.at(arg_i), true),
52235282 gen_param_values.at(arg_i));
52245283 }
......@@ -5235,8 +5294,8 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
52355294 gen_resume(g, fn_val, frame_result_loc, ResumeIdCall);
52365295
52375296 if (ir_want_runtime_safety(g, &instruction->base)) {
5238 LLVMValueRef awaiter_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc,
5239 frame_awaiter_index, "");
5297 LLVMValueRef awaiter_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty,
5298 frame_result_loc, frame_awaiter_index, "");
52405299 LLVMValueRef all_ones = LLVMConstAllOnes(usize_type_ref);
52415300 LLVMValueRef prev_val = gen_maybe_atomic_op(g, LLVMAtomicRMWBinOpXchg, awaiter_ptr,
52425301 all_ones, LLVMAtomicOrderingRelease);
......@@ -5255,7 +5314,8 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
52555314
52565315 ZigType *result_type = instruction->base.value->type;
52575316 ZigType *ptr_result_type = get_pointer_to_type(g, result_type, true);
5258 return gen_await_early_return(g, &instruction->base, frame_result_loc,
5317 return gen_await_early_return(g, &instruction->base,
5318 frame_struct_llvm_ty, frame_result_loc,
52595319 result_type, ptr_result_type, result_loc, true);
52605320 } else {
52615321 ZigType *ptr_result_type = get_pointer_to_type(g, src_return_type, true);
......@@ -5284,8 +5344,11 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
52845344
52855345 if (need_frame_ptr_ptr_spill) {
52865346 LLVMValueRef frame_slice_ptr = ir_llvm_value(g, instruction->new_stack);
5287 LLVMValueRef frame_ptr_ptr = LLVMBuildStructGEP(g->builder, frame_slice_ptr, slice_ptr_index, "");
5288 frame_result_loc_uncasted = LLVMBuildLoad(g->builder, frame_ptr_ptr, "");
5347 LLVMValueRef frame_ptr_ptr = LLVMBuildStructGEP2(g->builder,
5348 get_llvm_type(g, instruction->new_stack->value->type->data.pointer.child_type),
5349 frame_slice_ptr, slice_ptr_index, "");
5350 frame_result_loc_uncasted = LLVMBuildLoad2(g->builder,
5351 LLVMGetGEPSourceElementType(frame_ptr_ptr), frame_ptr_ptr, "");
52895352 }
52905353 if (frame_result_loc_uncasted != nullptr) {
52915354 if (instruction->fn_entry != nullptr) {
......@@ -5297,31 +5360,34 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
52975360 }
52985361 }
52995362
5300 LLVMValueRef result_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start + 2, "");
5301 return LLVMBuildLoad(g->builder, result_ptr, "");
5363 LLVMValueRef result_ptr = LLVMBuildStructGEP2(g->builder, frame_struct_llvm_ty,
5364 frame_result_loc, frame_ret_start + 2, "");
5365 return LLVMBuildLoad2(g->builder, get_llvm_type(g, src_return_type), result_ptr, "");
53025366 }
53035367 } else {
53045368 gen_param_types.deinit();
53055369 }
53065370
53075371 if (instruction->new_stack == nullptr || instruction->is_async_call_builtin) {
5308 result = ZigLLVMBuildCall(g->builder, fn_val,
5372 result = ZigLLVMBuildCall(g->builder, LLVMTypeOf(fn_val), fn_val,
53095373 gen_param_values.items, (unsigned)gen_param_values.length, llvm_cc, call_attr, "");
53105374 } else if (instruction->modifier == CallModifierAsync) {
53115375 zig_panic("TODO @asyncCall of non-async function");
53125376 } else {
5313 LLVMValueRef new_stack_addr = get_new_stack_addr(g, ir_llvm_value(g, instruction->new_stack));
5377 LLVMValueRef new_stack_addr = get_new_stack_addr(g,
5378 get_llvm_type(g, instruction->new_stack->value->type),
5379 ir_llvm_value(g, instruction->new_stack));
53145380 LLVMValueRef old_stack_ref;
53155381 if (src_return_type->id != ZigTypeIdUnreachable) {
53165382 LLVMValueRef stacksave_fn_val = get_stacksave_fn_val(g);
5317 old_stack_ref = LLVMBuildCall(g->builder, stacksave_fn_val, nullptr, 0, "");
5383 old_stack_ref = LLVMBuildCall2(g->builder, LLVMTypeOf(stacksave_fn_val), stacksave_fn_val, nullptr, 0, "");
53185384 }
53195385 gen_set_stack_pointer(g, new_stack_addr);
5320 result = ZigLLVMBuildCall(g->builder, fn_val,
5386 result = ZigLLVMBuildCall(g->builder, LLVMTypeOf(fn_val), fn_val,
53215387 gen_param_values.items, (unsigned)gen_param_values.length, llvm_cc, call_attr, "");
53225388 if (src_return_type->id != ZigTypeIdUnreachable) {
53235389 LLVMValueRef stackrestore_fn_val = get_stackrestore_fn_val(g);
5324 LLVMBuildCall(g->builder, stackrestore_fn_val, &old_stack_ref, 1, "");
5390 LLVMBuildCall2(g->builder, LLVMTypeOf(stackrestore_fn_val), stackrestore_fn_val, &old_stack_ref, 1, "");
53255391 }
53265392 }
53275393
......@@ -5361,6 +5427,8 @@ static LLVMValueRef ir_render_struct_field_ptr(CodeGen *g, Stage1Air *executable
53615427 LLVMValueRef struct_ptr = ir_llvm_value(g, instruction->struct_ptr);
53625428 // not necessarily a pointer. could be ZigTypeIdStruct
53635429 ZigType *struct_ptr_type = instruction->struct_ptr->value->type;
5430 ZigType *struct_ty = (struct_ptr_type->id == ZigTypeIdPointer) ?
5431 struct_ptr_type->data.pointer.child_type : struct_ptr_type;
53645432 TypeStructField *field = instruction->field;
53655433
53665434 if (!type_has_bits(g, field->type_entry))
......@@ -5387,7 +5455,8 @@ static LLVMValueRef ir_render_struct_field_ptr(CodeGen *g, Stage1Air *executable
53875455 codegen_report_errors_and_exit(g);
53885456
53895457 ir_assert(field->gen_index != SIZE_MAX, &instruction->base);
5390 LLVMValueRef field_ptr_val = LLVMBuildStructGEP(g->builder, struct_ptr, (unsigned)field->gen_index, "");
5458 LLVMValueRef field_ptr_val = LLVMBuildStructGEP2(g->builder,
5459 get_llvm_type(g, struct_ty), struct_ptr, (unsigned)field->gen_index, "");
53915460 ZigType *res_type = instruction->base.value->type;
53925461 ir_assert(res_type->id == ZigTypeIdPointer, &instruction->base);
53935462 if (res_type->data.pointer.host_int_bytes != 0) {
......@@ -5432,8 +5501,9 @@ static LLVMValueRef ir_render_union_field_ptr(CodeGen *g, Stage1Air *executable,
54325501 LLVMPointerType(tag_type_ref, 0), "");
54335502 } else {
54345503 assert(union_type->data.unionation.gen_tag_index != SIZE_MAX);
5435 tag_field_ptr = LLVMBuildStructGEP(g->builder, union_ptr,
5436 union_type->data.unionation.gen_tag_index, "");
5504 tag_field_ptr = LLVMBuildStructGEP2(g->builder,
5505 get_llvm_type(g, union_type),
5506 union_ptr, union_type->data.unionation.gen_tag_index, "");
54375507 }
54385508
54395509 LLVMValueRef tag_value = bigint_to_llvm_const(tag_type_ref,
......@@ -5448,19 +5518,25 @@ static LLVMValueRef ir_render_union_field_ptr(CodeGen *g, Stage1Air *executable,
54485518 LLVMTypeRef field_type_ref = LLVMPointerType(get_llvm_type(g, field->type_entry), 0);
54495519
54505520 if (union_type->data.unionation.gen_tag_index == SIZE_MAX) {
5451 LLVMValueRef union_field_ptr = LLVMBuildStructGEP(g->builder, union_ptr, 0, "");
5521 LLVMValueRef union_field_ptr = LLVMBuildStructGEP2(g->builder,
5522 get_llvm_type(g, union_type), union_ptr, 0, "");
54525523 LLVMValueRef bitcasted_union_field_ptr = LLVMBuildBitCast(g->builder, union_field_ptr, field_type_ref, "");
54535524 return bitcasted_union_field_ptr;
54545525 }
54555526
54565527 if (instruction->initializing) {
5457 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP(g->builder, union_ptr, union_type->data.unionation.gen_tag_index, "");
5528 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP2(g->builder,
5529 get_llvm_type(g, union_type),
5530 union_ptr, union_type->data.unionation.gen_tag_index, "");
54585531 LLVMValueRef tag_value = bigint_to_llvm_const(get_llvm_type(g, union_type->data.unionation.tag_type),
54595532 &field->enum_field->value);
54605533 gen_store_untyped(g, tag_value, tag_field_ptr, 0, false);
54615534 } else if (instruction->safety_check_on && ir_want_runtime_safety(g, &instruction->base)) {
5462 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP(g->builder, union_ptr, union_type->data.unionation.gen_tag_index, "");
5463 LLVMValueRef tag_value = gen_load_untyped(g, tag_field_ptr, 0, false, "");
5535 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP2(g->builder,
5536 get_llvm_type(g, union_type),
5537 union_ptr, union_type->data.unionation.gen_tag_index, "");
5538 LLVMValueRef tag_value = gen_load_untyped(g, LLVMGetGEPSourceElementType(tag_field_ptr),
5539 tag_field_ptr, 0, false, "");
54645540
54655541
54665542 LLVMValueRef expected_tag_value = bigint_to_llvm_const(get_llvm_type(g, union_type->data.unionation.tag_type),
......@@ -5476,10 +5552,9 @@ static LLVMValueRef ir_render_union_field_ptr(CodeGen *g, Stage1Air *executable,
54765552 LLVMPositionBuilderAtEnd(g->builder, ok_block);
54775553 }
54785554
5479 LLVMValueRef union_field_ptr = LLVMBuildStructGEP(g->builder, union_ptr,
5480 union_type->data.unionation.gen_union_index, "");
5481 LLVMValueRef bitcasted_union_field_ptr = LLVMBuildBitCast(g->builder, union_field_ptr, field_type_ref, "");
5482 return bitcasted_union_field_ptr;
5555 LLVMValueRef union_field_ptr = LLVMBuildStructGEP2(g->builder, get_llvm_type(g, union_type),
5556 union_ptr, union_type->data.unionation.gen_union_index, "");
5557 return union_field_ptr;
54835558}
54845559
54855560static size_t find_asm_index(CodeGen *g, AstNode *node, AsmToken *tok, Buf *src_template) {
......@@ -5660,7 +5735,7 @@ static LLVMValueRef ir_render_asm_gen(CodeGen *g, Stage1Air *executable, Stage1A
56605735 LLVMValueRef asm_fn = LLVMGetInlineAsm(function_type, buf_ptr(&llvm_template), buf_len(&llvm_template),
56615736 buf_ptr(&constraint_buf), buf_len(&constraint_buf), is_volatile, false, LLVMInlineAsmDialectATT, false);
56625737
5663 LLVMValueRef built_call = LLVMBuildCall(g->builder, asm_fn, param_values, (unsigned)input_and_output_count, "");
5738 LLVMValueRef built_call = LLVMBuildCall2(g->builder, LLVMTypeOf(asm_fn), asm_fn, param_values, (unsigned)input_and_output_count, "");
56645739
56655740 for (size_t i = 0; i < input_and_output_count; i += 1) {
56665741 if (param_needs_attr[i]) {
......@@ -5689,8 +5764,9 @@ static LLVMValueRef gen_non_null_bit(CodeGen *g, ZigType *maybe_type, LLVMValueR
56895764 if (is_scalar)
56905765 return LLVMBuildICmp(g->builder, LLVMIntNE, maybe_handle, LLVMConstNull(get_llvm_type(g, maybe_type)), "");
56915766
5692 LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP(g->builder, maybe_handle, maybe_null_index, "");
5693 return gen_load_untyped(g, maybe_field_ptr, 0, false, "");
5767 LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP2(g->builder,
5768 get_llvm_type(g, maybe_type), maybe_handle, maybe_null_index, "");
5769 return gen_load_untyped(g, LLVMGetGEPSourceElementType(maybe_field_ptr), maybe_field_ptr, 0, false, "");
56945770}
56955771
56965772static LLVMValueRef ir_render_test_non_null(CodeGen *g, Stage1Air *executable,
......@@ -5736,12 +5812,13 @@ static LLVMValueRef ir_render_optional_unwrap_ptr(CodeGen *g, Stage1Air *executa
57365812 } else {
57375813 LLVMValueRef optional_struct_ref = get_handle_value(g, base_ptr, maybe_type, ptr_type);
57385814 if (instruction->initializing) {
5739 LLVMValueRef non_null_bit_ptr = LLVMBuildStructGEP(g->builder, optional_struct_ref,
5740 maybe_null_index, "");
5815 LLVMValueRef non_null_bit_ptr = LLVMBuildStructGEP2(g->builder,
5816 get_llvm_type(g, maybe_type), optional_struct_ref, maybe_null_index, "");
57415817 LLVMValueRef non_null_bit = LLVMConstInt(LLVMInt1Type(), 1, false);
57425818 gen_store_untyped(g, non_null_bit, non_null_bit_ptr, 0, false);
57435819 }
5744 return LLVMBuildStructGEP(g->builder, optional_struct_ref, maybe_child_index, "");
5820 return LLVMBuildStructGEP2(g->builder,
5821 get_llvm_type(g, maybe_type), optional_struct_ref, maybe_child_index, "");
57455822 }
57465823 }
57475824}
......@@ -5818,7 +5895,7 @@ static LLVMValueRef ir_render_clz(CodeGen *g, Stage1Air *executable, Stage1AirIn
58185895 operand,
58195896 LLVMConstNull(LLVMInt1Type()),
58205897 };
5821 LLVMValueRef wrong_size_int = LLVMBuildCall(g->builder, fn_val, params, 2, "");
5898 LLVMValueRef wrong_size_int = LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, params, 2, "");
58225899 return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
58235900}
58245901
......@@ -5830,7 +5907,7 @@ static LLVMValueRef ir_render_ctz(CodeGen *g, Stage1Air *executable, Stage1AirIn
58305907 operand,
58315908 LLVMConstNull(LLVMInt1Type()),
58325909 };
5833 LLVMValueRef wrong_size_int = LLVMBuildCall(g->builder, fn_val, params, 2, "");
5910 LLVMValueRef wrong_size_int = LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, params, 2, "");
58345911 return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
58355912}
58365913
......@@ -5887,7 +5964,7 @@ static LLVMValueRef ir_render_pop_count(CodeGen *g, Stage1Air *executable, Stage
58875964 ZigType *int_type = instruction->op->value->type;
58885965 LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdPopCount);
58895966 LLVMValueRef operand = ir_llvm_value(g, instruction->op);
5890 LLVMValueRef wrong_size_int = LLVMBuildCall(g->builder, fn_val, &operand, 1, "");
5967 LLVMValueRef wrong_size_int = LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, &operand, 1, "");
58915968 return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
58925969}
58935970
......@@ -5978,7 +6055,11 @@ static LLVMValueRef ir_render_err_name(CodeGen *g, Stage1Air *executable, Stage1
59786055 LLVMConstNull(g->builtin_types.entry_usize->llvm_type),
59796056 err_val,
59806057 };
5981 return LLVMBuildInBoundsGEP(g->builder, g->err_name_table, indices, 2, "");
6058 ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
6059 PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0, false);
6060 ZigType *str_type = get_slice_type(g, u8_ptr_type);
6061 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, str_type);
6062 return LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, g->err_name_table, indices, 2, "");
59826063}
59836064
59846065static LLVMValueRef get_enum_tag_name_function(CodeGen *g, ZigType *enum_type) {
......@@ -6050,7 +6131,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen *g, ZigType *enum_type) {
60506131 LLVMSetAlignment(str_global, LLVMABIAlignmentOfType(g->target_data_ref, LLVMTypeOf(str_init)));
60516132
60526133 LLVMValueRef fields[] = {
6053 LLVMConstGEP(str_global, array_ptr_indices, 2),
6134 LLVMConstInBoundsGEP2(LLVMInt8Type(), str_global, array_ptr_indices, 2),
60546135 LLVMConstInt(g->builtin_types.entry_usize->llvm_type, buf_len(name), false),
60556136 };
60566137 LLVMValueRef slice_init_value = LLVMConstNamedStruct(get_llvm_type(g, u8_slice_type), fields, 2);
......@@ -6099,7 +6180,8 @@ static LLVMValueRef ir_render_enum_tag_name(CodeGen *g, Stage1Air *executable,
60996180 LLVMValueRef enum_name_function = get_enum_tag_name_function(g, enum_type);
61006181
61016182 LLVMValueRef enum_tag_value = ir_llvm_value(g, instruction->target);
6102 return ZigLLVMBuildCall(g->builder, enum_name_function, &enum_tag_value, 1,
6183 return ZigLLVMBuildCall(g->builder, LLVMTypeOf(enum_name_function), enum_name_function,
6184 &enum_tag_value, 1,
61036185 get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
61046186}
61056187
......@@ -6166,8 +6248,10 @@ static LLVMValueRef ir_render_align_cast(CodeGen *g, Stage1Air *executable, Stag
61666248 align_bytes = get_ptr_align(g, slice_ptr_type);
61676249
61686250 size_t ptr_index = target_type->data.structure.fields[slice_ptr_index]->gen_index;
6169 LLVMValueRef ptr_val_ptr = LLVMBuildStructGEP(g->builder, target_val, (unsigned)ptr_index, "");
6170 ptr_val = gen_load_untyped(g, ptr_val_ptr, 0, false, "");
6251 LLVMValueRef ptr_val_ptr = LLVMBuildStructGEP2(g->builder,
6252 get_llvm_type(g, instruction->target->value->type->data.pointer.child_type),
6253 target_val, (unsigned)ptr_index, "");
6254 ptr_val = gen_load_untyped(g, LLVMGetGEPSourceElementType(ptr_val_ptr), ptr_val_ptr, 0, false, "");
61716255 } else {
61726256 zig_unreachable();
61736257 }
......@@ -6319,12 +6403,16 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen *g, Stage1Air *executable, Stage1A
63196403 if (actual_abi_type != nullptr) {
63206404 payload_val = LLVMBuildTrunc(g->builder, payload_val, get_llvm_type(g, operand_type), "");
63216405 }
6322 LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, result_loc, maybe_child_index, "");
6406 LLVMTypeRef result_loc_struct_llvm_ty = get_llvm_type(g,
6407 instruction->result_loc->value->type->data.pointer.child_type);
6408 LLVMValueRef val_ptr = LLVMBuildStructGEP2(g->builder,
6409 result_loc_struct_llvm_ty, result_loc, maybe_child_index, "");
63236410 gen_assign_raw(g, val_ptr, get_pointer_to_type(g, child_type, false), payload_val);
63246411
63256412 LLVMValueRef success_bit = LLVMBuildExtractValue(g->builder, result_val, 1, "");
63266413 LLVMValueRef nonnull_bit = LLVMBuildNot(g->builder, success_bit, "");
6327 LLVMValueRef maybe_ptr = LLVMBuildStructGEP(g->builder, result_loc, maybe_null_index, "");
6414 LLVMValueRef maybe_ptr = LLVMBuildStructGEP2(g->builder, result_loc_struct_llvm_ty, result_loc,
6415 maybe_null_index, "");
63286416 gen_store_untyped(g, nonnull_bit, maybe_ptr, 0, false);
63296417 return result_loc;
63306418}
......@@ -6469,7 +6557,7 @@ static LLVMValueRef ir_render_memcpy(CodeGen *g, Stage1Air *executable, Stage1Ai
64696557static LLVMValueRef ir_render_wasm_memory_size(CodeGen *g, Stage1Air *executable, Stage1AirInstWasmMemorySize *instruction) {
64706558 // TODO adjust for wasm64
64716559 LLVMValueRef param = ir_llvm_value(g, instruction->index);
6472 LLVMValueRef val = LLVMBuildCall(g->builder, gen_wasm_memory_size(g), &param, 1, "");
6560 LLVMValueRef val = LLVMBuildCall2(g->builder, LLVMTypeOf(gen_wasm_memory_size(g)), gen_wasm_memory_size(g), &param, 1, "");
64736561 return val;
64746562}
64756563
......@@ -6479,7 +6567,7 @@ static LLVMValueRef ir_render_wasm_memory_grow(CodeGen *g, Stage1Air *executable
64796567 ir_llvm_value(g, instruction->index),
64806568 ir_llvm_value(g, instruction->delta),
64816569 };
6482 LLVMValueRef val = LLVMBuildCall(g->builder, gen_wasm_memory_grow(g), params, 2, "");
6570 LLVMValueRef val = LLVMBuildCall2(g->builder, LLVMTypeOf(gen_wasm_memory_grow(g)), gen_wasm_memory_grow(g), params, 2, "");
64836571 return val;
64846572}
64856573
......@@ -6525,7 +6613,7 @@ static LLVMValueRef ir_render_prefetch(CodeGen *g, Stage1Air *executable, Stage1
65256613 LLVMConstInt(LLVMInt32Type(), instruction->locality, false),
65266614 LLVMConstInt(LLVMInt32Type(), instruction->cache, false),
65276615 };
6528 LLVMValueRef val = LLVMBuildCall(g->builder, gen_prefetch(g), params, 4, "");
6616 LLVMValueRef val = LLVMBuildCall2(g->builder, LLVMTypeOf(gen_prefetch(g)), gen_prefetch(g), params, 4, "");
65296617 return val;
65306618}
65316619
......@@ -6591,12 +6679,15 @@ static LLVMValueRef ir_render_slice(CodeGen *g, Stage1Air *executable, Stage1Air
65916679 codegen_report_errors_and_exit(g);
65926680
65936681 if (value_has_bits) {
6682 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, array_type->data.array.child_type);
6683
65946684 if (want_runtime_safety && sentinel != nullptr) {
65956685 LLVMValueRef indices[] = {
65966686 LLVMConstNull(g->builtin_types.entry_usize->llvm_type),
65976687 end_val,
65986688 };
6599 LLVMValueRef sentinel_elem_ptr = LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 2, "");
6689 LLVMValueRef sentinel_elem_ptr = LLVMBuildInBoundsGEP2(g->builder,
6690 elem_llvm_ty, array_ptr, indices, 2, "");
66006691 add_sentinel_check(g, sentinel_elem_ptr, sentinel);
66016692 }
66026693
......@@ -6604,7 +6695,7 @@ static LLVMValueRef ir_render_slice(CodeGen *g, Stage1Air *executable, Stage1Air
66046695 LLVMConstNull(g->builtin_types.entry_usize->llvm_type),
66056696 start_val,
66066697 };
6607 slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 2, "");
6698 slice_start_ptr = LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, array_ptr, indices, 2, "");
66086699 }
66096700
66106701 len_value = LLVMBuildNUWSub(g->builder, end_val, start_val, "");
......@@ -6623,27 +6714,31 @@ static LLVMValueRef ir_render_slice(CodeGen *g, Stage1Air *executable, Stage1Air
66236714 codegen_report_errors_and_exit(g);
66246715
66256716 if (value_has_bits) {
6717 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, array_type->data.pointer.child_type);
6718
66266719 if (want_runtime_safety && sentinel != nullptr) {
6627 LLVMValueRef sentinel_elem_ptr = LLVMBuildInBoundsGEP(g->builder, array_ptr, &end_val, 1, "");
6720 LLVMValueRef sentinel_elem_ptr = LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty,
6721 array_ptr, &end_val, 1, "");
66286722 add_sentinel_check(g, sentinel_elem_ptr, sentinel);
66296723 }
66306724
6631 slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, array_ptr, &start_val, 1, "");
6725 slice_start_ptr = LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, array_ptr,
6726 &start_val, 1, "");
66326727 }
66336728
66346729 len_value = LLVMBuildNUWSub(g->builder, end_val, start_val, "");
66356730 } else if (array_type->id == ZigTypeIdStruct) {
66366731 assert(array_type->data.structure.special == StructSpecialSlice);
66376732 assert(LLVMGetTypeKind(LLVMTypeOf(array_ptr)) == LLVMPointerTypeKind);
6638 assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(array_ptr))) == LLVMStructTypeKind);
66396733
66406734 const size_t gen_len_index = array_type->data.structure.fields[slice_len_index]->gen_index;
66416735 assert(gen_len_index != SIZE_MAX);
66426736
66436737 LLVMValueRef prev_end = nullptr;
66446738 if (!instruction->end || want_runtime_safety) {
6645 LLVMValueRef src_len_ptr = LLVMBuildStructGEP(g->builder, array_ptr, gen_len_index, "");
6646 prev_end = gen_load_untyped(g, src_len_ptr, 0, false, "");
6739 LLVMValueRef src_len_ptr = LLVMBuildStructGEP2(g->builder,
6740 get_llvm_type(g, array_type), array_ptr, gen_len_index, "");
6741 prev_end = gen_load_untyped(g, LLVMGetGEPSourceElementType(src_len_ptr), src_len_ptr, 0, false, "");
66476742 }
66486743
66496744 LLVMValueRef start_val = ir_llvm_value(g, instruction->start);
......@@ -6682,18 +6777,22 @@ static LLVMValueRef ir_render_slice(CodeGen *g, Stage1Air *executable, Stage1Air
66826777 codegen_report_errors_and_exit(g);
66836778
66846779 if (ptr_has_bits) {
6780 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, ptr_field_type->data.pointer.child_type);
66856781 const size_t gen_ptr_index = array_type->data.structure.fields[slice_ptr_index]->gen_index;
66866782 assert(gen_ptr_index != SIZE_MAX);
66876783
6688 LLVMValueRef src_ptr_ptr = LLVMBuildStructGEP(g->builder, array_ptr, gen_ptr_index, "");
6689 LLVMValueRef src_ptr = gen_load_untyped(g, src_ptr_ptr, 0, false, "");
6784 LLVMValueRef src_ptr_ptr = LLVMBuildStructGEP2(g->builder,
6785 get_llvm_type(g, array_type), array_ptr, gen_ptr_index, "");
6786 LLVMValueRef src_ptr = gen_load_untyped(g, LLVMGetGEPSourceElementType(src_ptr_ptr),
6787 src_ptr_ptr, 0, false, "");
66906788
66916789 if (sentinel != nullptr) {
6692 LLVMValueRef sentinel_elem_ptr = LLVMBuildInBoundsGEP(g->builder, src_ptr, &end_val, 1, "");
6790 LLVMValueRef sentinel_elem_ptr = LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty,
6791 src_ptr, &end_val, 1, "");
66936792 add_sentinel_check(g, sentinel_elem_ptr, sentinel);
66946793 }
66956794
6696 slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, src_ptr, &start_val, 1, "");
6795 slice_start_ptr = LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, src_ptr, &start_val, 1, "");
66976796 }
66986797
66996798 len_value = LLVMBuildNUWSub(g->builder, end_val, start_val, "");
......@@ -6735,7 +6834,8 @@ static LLVMValueRef ir_render_slice(CodeGen *g, Stage1Air *executable, Stage1Air
67356834 // The slice may not have a pointer at all if it points to a zero-sized type
67366835 const size_t gen_ptr_index = result_type->data.structure.fields[slice_ptr_index]->gen_index;
67376836 if (gen_ptr_index != SIZE_MAX) {
6738 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, gen_ptr_index, "");
6837 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP2(g->builder,
6838 get_llvm_type(g, result_type), tmp_struct_ptr, gen_ptr_index, "");
67396839 if (slice_start_ptr != nullptr) {
67406840 gen_store_untyped(g, slice_start_ptr, ptr_field_ptr, 0, false);
67416841 } else if (want_runtime_safety) {
......@@ -6748,7 +6848,8 @@ static LLVMValueRef ir_render_slice(CodeGen *g, Stage1Air *executable, Stage1Air
67486848 const size_t gen_len_index = result_type->data.structure.fields[slice_len_index]->gen_index;
67496849 assert(gen_len_index != SIZE_MAX);
67506850
6751 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, gen_len_index, "");
6851 LLVMValueRef len_field_ptr = LLVMBuildStructGEP2(g->builder,
6852 get_llvm_type(g, result_type), tmp_struct_ptr, gen_len_index, "");
67526853 gen_store_untyped(g, len_value, len_field_ptr, 0, false);
67536854
67546855 return tmp_struct_ptr;
......@@ -6767,7 +6868,7 @@ static LLVMValueRef get_trap_fn_val(CodeGen *g) {
67676868
67686869
67696870static LLVMValueRef ir_render_breakpoint(CodeGen *g, Stage1Air *executable, Stage1AirInstBreakpoint *instruction) {
6770 LLVMBuildCall(g->builder, get_trap_fn_val(g), nullptr, 0, "");
6871 LLVMBuildCall2(g->builder, LLVMTypeOf(get_trap_fn_val(g)), get_trap_fn_val(g), nullptr, 0, "");
67716872 return nullptr;
67726873}
67736874
......@@ -6781,7 +6882,7 @@ static LLVMValueRef ir_render_return_address(CodeGen *g, Stage1Air *executable,
67816882 }
67826883
67836884 LLVMValueRef zero = LLVMConstNull(g->builtin_types.entry_i32->llvm_type);
6784 LLVMValueRef ptr_val = LLVMBuildCall(g->builder, get_return_address_fn_val(g), &zero, 1, "");
6885 LLVMValueRef ptr_val = LLVMBuildCall2(g->builder, LLVMTypeOf(get_return_address_fn_val(g)), get_return_address_fn_val(g), &zero, 1, "");
67856886 return LLVMBuildPtrToInt(g->builder, ptr_val, g->builtin_types.entry_usize->llvm_type, "");
67866887}
67876888
......@@ -6803,7 +6904,7 @@ static LLVMValueRef ir_render_frame_address(CodeGen *g, Stage1Air *executable,
68036904 Stage1AirInstFrameAddress *instruction)
68046905{
68056906 LLVMValueRef zero = LLVMConstNull(g->builtin_types.entry_i32->llvm_type);
6806 LLVMValueRef ptr_val = LLVMBuildCall(g->builder, get_frame_address_fn_val(g), &zero, 1, "");
6907 LLVMValueRef ptr_val = LLVMBuildCall2(g->builder, LLVMTypeOf(get_frame_address_fn_val(g)), get_frame_address_fn_val(g), &zero, 1, "");
68076908 return LLVMBuildPtrToInt(g->builder, ptr_val, g->builtin_types.entry_usize->llvm_type, "");
68086909}
68096910
......@@ -6866,7 +6967,7 @@ static LLVMValueRef ir_render_overflow_op(CodeGen *g, Stage1Air *executable, Sta
68666967 op2,
68676968 };
68686969
6869 LLVMValueRef result_struct = LLVMBuildCall(g->builder, fn_val, params, 2, "");
6970 LLVMValueRef result_struct = LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, params, 2, "");
68706971 LLVMValueRef result = LLVMBuildExtractValue(g->builder, result_struct, 0, "");
68716972 LLVMValueRef overflow_bit = LLVMBuildExtractValue(g->builder, result_struct, 1, "");
68726973 gen_store(g, result, ptr_result, instruction->result_ptr->value->type);
......@@ -6881,8 +6982,9 @@ static LLVMValueRef ir_render_test_err(CodeGen *g, Stage1Air *executable, Stage1
68816982
68826983 LLVMValueRef err_val;
68836984 if (type_has_bits(g, payload_type)) {
6884 LLVMValueRef err_val_ptr = LLVMBuildStructGEP(g->builder, err_union_handle, err_union_err_index, "");
6885 err_val = gen_load_untyped(g, err_val_ptr, 0, false, "");
6985 LLVMValueRef err_val_ptr = LLVMBuildStructGEP2(g->builder,
6986 get_llvm_type(g, err_union_type), err_union_handle, err_union_err_index, "");
6987 err_val = gen_load_untyped(g, LLVMGetGEPSourceElementType(err_val_ptr), err_val_ptr, 0, false, "");
68866988 } else {
68876989 err_val = err_union_handle;
68886990 }
......@@ -6907,7 +7009,8 @@ static LLVMValueRef ir_render_unwrap_err_code(CodeGen *g, Stage1Air *executable,
69077009 } else {
69087010 // TODO assign undef to the payload
69097011 LLVMValueRef err_union_handle = get_handle_value(g, err_union_ptr, err_union_type, ptr_type);
6910 return LLVMBuildStructGEP(g->builder, err_union_handle, err_union_err_index, "");
7012 return LLVMBuildStructGEP2(g->builder, get_llvm_type(g, err_union_type), err_union_handle,
7013 err_union_err_index, "");
69117014 }
69127015}
69137016
......@@ -6946,11 +7049,14 @@ static LLVMValueRef ir_render_unwrap_err_payload(CodeGen *g, Stage1Air *executab
69467049 return err_union_handle;
69477050 }
69487051
7052 LLVMTypeRef err_union_llvm_ty = get_llvm_type(g, err_union_type);
7053
69497054 if (want_safety) {
69507055 LLVMValueRef err_val;
69517056 if (type_has_bits(g, payload_type)) {
6952 LLVMValueRef err_val_ptr = LLVMBuildStructGEP(g->builder, err_union_handle, err_union_err_index, "");
6953 err_val = gen_load_untyped(g, err_val_ptr, 0, false, "");
7057 LLVMValueRef err_val_ptr = LLVMBuildStructGEP2(g->builder, err_union_llvm_ty,
7058 err_union_handle, err_union_err_index, "");
7059 err_val = gen_load_untyped(g, LLVMGetGEPSourceElementType(err_val_ptr), err_val_ptr, 0, false, "");
69547060 } else {
69557061 err_val = err_union_handle;
69567062 }
......@@ -6967,11 +7073,13 @@ static LLVMValueRef ir_render_unwrap_err_payload(CodeGen *g, Stage1Air *executab
69677073
69687074 if (type_has_bits(g, payload_type)) {
69697075 if (instruction->initializing) {
6970 LLVMValueRef err_tag_ptr = LLVMBuildStructGEP(g->builder, err_union_handle, err_union_err_index, "");
7076 LLVMValueRef err_tag_ptr = LLVMBuildStructGEP2(g->builder, err_union_llvm_ty,
7077 err_union_handle, err_union_err_index, "");
69717078 LLVMValueRef ok_err_val = LLVMConstNull(get_llvm_type(g, g->err_tag_type));
69727079 gen_store_untyped(g, ok_err_val, err_tag_ptr, 0, false);
69737080 }
6974 return LLVMBuildStructGEP(g->builder, err_union_handle, err_union_payload_index, "");
7081 return LLVMBuildStructGEP2(g->builder, err_union_llvm_ty, err_union_handle,
7082 err_union_payload_index, "");
69757083 } else {
69767084 if (instruction->initializing) {
69777085 gen_store_untyped(g, zero, err_union_ptr, 0, false);
......@@ -7006,11 +7114,14 @@ static LLVMValueRef ir_render_optional_wrap(CodeGen *g, Stage1Air *executable, S
70067114 }
70077115
70087116 LLVMValueRef result_loc = ir_llvm_value(g, instruction->result_loc);
7117 LLVMTypeRef result_llvm_struct_ty = get_llvm_type(g, wanted_type);
70097118
7010 LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, result_loc, maybe_child_index, "");
7119 LLVMValueRef val_ptr = LLVMBuildStructGEP2(g->builder, result_llvm_struct_ty, result_loc,
7120 maybe_child_index, "");
70117121 // child_type and instruction->value->value->type may differ by constness
70127122 gen_assign_raw(g, val_ptr, get_pointer_to_type(g, child_type, false), payload_val);
7013 LLVMValueRef maybe_ptr = LLVMBuildStructGEP(g->builder, result_loc, maybe_null_index, "");
7123 LLVMValueRef maybe_ptr = LLVMBuildStructGEP2(g->builder, result_llvm_struct_ty, result_loc,
7124 maybe_null_index, "");
70147125 gen_store_untyped(g, LLVMConstAllOnes(LLVMInt1Type()), maybe_ptr, 0, false);
70157126
70167127 return result_loc;
......@@ -7028,7 +7139,8 @@ static LLVMValueRef ir_render_err_wrap_code(CodeGen *g, Stage1Air *executable, S
70287139
70297140 LLVMValueRef result_loc = ir_llvm_value(g, instruction->result_loc);
70307141
7031 LLVMValueRef err_tag_ptr = LLVMBuildStructGEP(g->builder, result_loc, err_union_err_index, "");
7142 LLVMValueRef err_tag_ptr = LLVMBuildStructGEP2(g->builder, get_llvm_type(g, wanted_type),
7143 result_loc, err_union_err_index, "");
70327144 gen_store_untyped(g, err_val, err_tag_ptr, 0, false);
70337145
70347146 // TODO store undef to the payload
......@@ -7057,11 +7169,14 @@ static LLVMValueRef ir_render_err_wrap_payload(CodeGen *g, Stage1Air *executable
70577169 LLVMValueRef result_loc = ir_llvm_value(g, instruction->result_loc);
70587170
70597171 LLVMValueRef payload_val = ir_llvm_value(g, instruction->operand);
7172 LLVMTypeRef result_struct_llvm_ty = get_llvm_type(g, wanted_type);
70607173
7061 LLVMValueRef err_tag_ptr = LLVMBuildStructGEP(g->builder, result_loc, err_union_err_index, "");
7174 LLVMValueRef err_tag_ptr = LLVMBuildStructGEP2(g->builder, result_struct_llvm_ty, result_loc,
7175 err_union_err_index, "");
70627176 gen_store_untyped(g, ok_err_val, err_tag_ptr, 0, false);
70637177
7064 LLVMValueRef payload_ptr = LLVMBuildStructGEP(g->builder, result_loc, err_union_payload_index, "");
7178 LLVMValueRef payload_ptr = LLVMBuildStructGEP2(g->builder, result_struct_llvm_ty, result_loc,
7179 err_union_payload_index, "");
70657180 gen_assign_raw(g, payload_ptr, get_pointer_to_type(g, payload_type, false), payload_val);
70667181
70677182 return result_loc;
......@@ -7079,7 +7194,8 @@ static LLVMValueRef ir_render_union_tag(CodeGen *g, Stage1Air *executable, Stage
70797194 return union_val;
70807195
70817196 assert(union_type->data.unionation.gen_tag_index != SIZE_MAX);
7082 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP(g->builder, union_val,
7197 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP2(g->builder,
7198 get_llvm_type(g, union_type), union_val,
70837199 union_type->data.unionation.gen_tag_index, "");
70847200 ZigType *ptr_type = get_pointer_to_type(g, tag_type, false);
70857201 return get_handle_value(g, tag_field_ptr, tag_type, ptr_type);
......@@ -7221,14 +7337,12 @@ static LLVMValueRef ir_render_soft_mul_add(CodeGen *g, Stage1Air *executable, St
72217337 LLVMValueRef op1 = ir_llvm_value(g, instruction->op1);
72227338 LLVMValueRef op2 = ir_llvm_value(g, instruction->op2);
72237339 LLVMValueRef op3 = ir_llvm_value(g, instruction->op3);
7224 LLVMValueRef result;
72257340 if (vector_len == 0) {
72267341 LLVMValueRef params[3] = { op1, op2, op3 };
7227 result = LLVMBuildCall(g->builder, func_ref, params, 3, "");
7228 } else {
7229 result = build_alloca(g, instruction->op1->value->type, "", 0);
7342 return LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, params, 3, "");
72307343 }
72317344
7345 LLVMValueRef result = LLVMGetUndef(get_llvm_type(g, instruction->op1->value->type));
72327346 LLVMTypeRef usize_ref = g->builtin_types.entry_usize->llvm_type;
72337347 for (uint32_t i = 0; i < vector_len; i++) {
72347348 LLVMValueRef index_value = LLVMConstInt(usize_ref, i, false);
......@@ -7238,12 +7352,8 @@ static LLVMValueRef ir_render_soft_mul_add(CodeGen *g, Stage1Air *executable, St
72387352 LLVMBuildExtractElement(g->builder, op2, index_value, ""),
72397353 LLVMBuildExtractElement(g->builder, op3, index_value, ""),
72407354 };
7241 LLVMValueRef call_result = LLVMBuildCall(g->builder, func_ref, params, 3, "");
7242 LLVMBuildInsertElement(g->builder, LLVMBuildLoad(g->builder, result, ""),
7243 call_result, index_value, "");
7244 }
7245 if (vector_len != 0) {
7246 result = LLVMBuildLoad(g->builder, result, "");
7355 LLVMValueRef call_result = LLVMBuildCall2(g->builder, LLVMTypeOf(func_ref), func_ref, params, 3, "");
7356 result = LLVMBuildInsertElement(g->builder, result, call_result, index_value, "");
72477357 }
72487358 return result;
72497359}
......@@ -7262,7 +7372,7 @@ static LLVMValueRef ir_render_mul_add(CodeGen *g, Stage1Air *executable, Stage1A
72627372 instruction->base.value->type->id == ZigTypeIdVector);
72637373 LLVMValueRef fn_val = get_float_fn(g, instruction->base.value->type, ZigLLVMFnIdFMA, BuiltinFnIdMulAdd);
72647374 LLVMValueRef args[3] = { op1, op2, op3 };
7265 return LLVMBuildCall(g->builder, fn_val, args, 3, "");
7375 return LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, args, 3, "");
72667376}
72677377
72687378static LLVMValueRef ir_render_bswap(CodeGen *g, Stage1Air *executable, Stage1AirInstBswap *instruction) {
......@@ -7273,7 +7383,7 @@ static LLVMValueRef ir_render_bswap(CodeGen *g, Stage1Air *executable, Stage1Air
72737383 assert(int_type->id == ZigTypeIdInt);
72747384 if (int_type->data.integral.bit_count % 16 == 0) {
72757385 LLVMValueRef fn_val = get_int_builtin_fn(g, expr_type, BuiltinFnIdBswap);
7276 return LLVMBuildCall(g->builder, fn_val, &op, 1, "");
7386 return LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, &op, 1, "");
72777387 }
72787388 // Not an even number of bytes, so we zext 1 byte, then bswap, shift right 1 byte, truncate
72797389 ZigType *extended_type = get_int_type(g, int_type->data.integral.is_signed,
......@@ -7292,7 +7402,7 @@ static LLVMValueRef ir_render_bswap(CodeGen *g, Stage1Air *executable, Stage1Air
72927402 LLVMValueRef extended = LLVMBuildZExt(g->builder, op, get_llvm_type(g, extended_type), "");
72937403 // 00aabbcc
72947404 LLVMValueRef fn_val = get_int_builtin_fn(g, extended_type, BuiltinFnIdBswap);
7295 LLVMValueRef swapped = LLVMBuildCall(g->builder, fn_val, &extended, 1, "");
7405 LLVMValueRef swapped = LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, &extended, 1, "");
72967406 // ccbbaa00
72977407 LLVMValueRef shifted = ZigLLVMBuildLShrExact(g->builder, swapped, shift_amt, "");
72987408 // 00ccbbaa
......@@ -7328,7 +7438,7 @@ static LLVMValueRef ir_render_bit_reverse(CodeGen *g, Stage1Air *executable, Sta
73287438 ZigType *int_type = instruction->base.value->type;
73297439 assert(int_type->id == ZigTypeIdInt);
73307440 LLVMValueRef fn_val = get_int_builtin_fn(g, instruction->base.value->type, BuiltinFnIdBitReverse);
7331 return LLVMBuildCall(g->builder, fn_val, &op, 1, "");
7441 return LLVMBuildCall2(g->builder, LLVMTypeOf(fn_val), fn_val, &op, 1, "");
73327442}
73337443
73347444static LLVMValueRef ir_render_vector_to_array(CodeGen *g, Stage1Air *executable,
......@@ -7341,6 +7451,7 @@ static LLVMValueRef ir_render_vector_to_array(CodeGen *g, Stage1Air *executable,
73417451 LLVMValueRef vector = ir_llvm_value(g, instruction->vector);
73427452
73437453 ZigType *elem_type = array_type->data.array.child_type;
7454 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, elem_type);
73447455 bool bitcast_ok = elem_type->size_in_bits == elem_type->abi_size * 8;
73457456 if (bitcast_ok) {
73467457 LLVMValueRef casted_ptr = LLVMBuildBitCast(g->builder, result_loc,
......@@ -7357,7 +7468,7 @@ static LLVMValueRef ir_render_vector_to_array(CodeGen *g, Stage1Air *executable,
73577468 LLVMValueRef index_usize = LLVMConstInt(usize_type_ref, i, false);
73587469 LLVMValueRef index_u32 = LLVMConstInt(u32_type_ref, i, false);
73597470 LLVMValueRef indexes[] = { zero, index_usize };
7360 LLVMValueRef elem_ptr = LLVMBuildInBoundsGEP(g->builder, result_loc, indexes, 2, "");
7471 LLVMValueRef elem_ptr = LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, result_loc, indexes, 2, "");
73617472 LLVMValueRef elem = LLVMBuildExtractElement(g->builder, vector, index_u32, "");
73627473 LLVMBuildStore(g->builder, elem, elem_ptr);
73637474 }
......@@ -7377,12 +7488,10 @@ static LLVMValueRef ir_render_array_to_vector(CodeGen *g, Stage1Air *executable,
73777488 ZigType *elem_type = vector_type->data.vector.elem_type;
73787489 bool bitcast_ok = elem_type->size_in_bits == elem_type->abi_size * 8;
73797490 if (bitcast_ok) {
7380 LLVMValueRef casted_ptr = LLVMBuildBitCast(g->builder, array_ptr,
7381 LLVMPointerType(vector_type_ref, 0), "");
73827491 ZigType *array_type = instruction->array->value->type;
73837492 assert(array_type->id == ZigTypeIdArray);
73847493 uint32_t alignment = get_abi_alignment(g, array_type->data.array.child_type);
7385 return gen_load_untyped(g, casted_ptr, alignment, false, "");
7494 return gen_load_untyped(g, vector_type_ref, array_ptr, alignment, false, "");
73867495 } else {
73877496 // If the ABI size of the element type is not evenly divisible by size_in_bits, a simple bitcast
73887497 // will not work, and we fall back to insertelement.
......@@ -7390,12 +7499,14 @@ static LLVMValueRef ir_render_array_to_vector(CodeGen *g, Stage1Air *executable,
73907499 LLVMTypeRef u32_type_ref = LLVMInt32Type();
73917500 LLVMValueRef zero = LLVMConstInt(usize_type_ref, 0, false);
73927501 LLVMValueRef vector = LLVMGetUndef(vector_type_ref);
7502 LLVMTypeRef elem_llvm_ty = get_llvm_type(g, elem_type);
73937503 for (uintptr_t i = 0; i < instruction->base.value->type->data.vector.len; i++) {
73947504 LLVMValueRef index_usize = LLVMConstInt(usize_type_ref, i, false);
73957505 LLVMValueRef index_u32 = LLVMConstInt(u32_type_ref, i, false);
73967506 LLVMValueRef indexes[] = { zero, index_usize };
7397 LLVMValueRef elem_ptr = LLVMBuildInBoundsGEP(g->builder, array_ptr, indexes, 2, "");
7398 LLVMValueRef elem = LLVMBuildLoad(g->builder, elem_ptr, "");
7507 LLVMValueRef elem_ptr = LLVMBuildInBoundsGEP2(g->builder, elem_llvm_ty, array_ptr,
7508 indexes, 2, "");
7509 LLVMValueRef elem = LLVMBuildLoad2(g->builder, elem_llvm_ty, elem_ptr, "");
73997510 vector = LLVMBuildInsertElement(g->builder, vector, elem, index_u32, "");
74007511 }
74017512 return vector;
......@@ -7461,14 +7572,16 @@ static LLVMValueRef ir_render_suspend_finish(CodeGen *g, Stage1Air *executable,
74617572}
74627573
74637574static LLVMValueRef gen_await_early_return(CodeGen *g, Stage1AirInst *source_instr,
7464 LLVMValueRef target_frame_ptr, ZigType *result_type, ZigType *ptr_result_type,
7465 LLVMValueRef result_loc, bool non_async)
7575 LLVMTypeRef target_frame_struct_llvm_ty, LLVMValueRef target_frame_ptr,
7576 ZigType *result_type, ZigType *ptr_result_type, LLVMValueRef result_loc, bool non_async)
74667577{
74677578 LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
74687579 LLVMValueRef their_result_ptr = nullptr;
74697580 if (type_has_bits(g, result_type) && (non_async || result_loc != nullptr)) {
7470 LLVMValueRef their_result_ptr_ptr = LLVMBuildStructGEP(g->builder, target_frame_ptr, frame_ret_start, "");
7471 their_result_ptr = LLVMBuildLoad(g->builder, their_result_ptr_ptr, "");
7581 LLVMValueRef their_result_ptr_ptr = LLVMBuildStructGEP2(g->builder,
7582 target_frame_struct_llvm_ty, target_frame_ptr, frame_ret_start, "");
7583 their_result_ptr = LLVMBuildLoad2(g->builder,
7584 LLVMGetGEPSourceElementType(their_result_ptr_ptr), their_result_ptr_ptr, "");
74727585 if (result_loc != nullptr) {
74737586 LLVMTypeRef ptr_u8 = LLVMPointerType(LLVMInt8Type(), 0);
74747587 LLVMValueRef dest_ptr_casted = LLVMBuildBitCast(g->builder, result_loc, ptr_u8, "");
......@@ -7482,13 +7595,16 @@ static LLVMValueRef gen_await_early_return(CodeGen *g, Stage1AirInst *source_ins
74827595 }
74837596 }
74847597 if (codegen_fn_has_err_ret_tracing_arg(g, result_type)) {
7485 LLVMValueRef their_trace_ptr_ptr = LLVMBuildStructGEP(g->builder, target_frame_ptr,
7598 LLVMValueRef their_trace_ptr_ptr = LLVMBuildStructGEP2(g->builder,
7599 target_frame_struct_llvm_ty, target_frame_ptr,
74867600 frame_index_trace_arg(g, result_type), "");
7487 LLVMValueRef src_trace_ptr = LLVMBuildLoad(g->builder, their_trace_ptr_ptr, "");
7601 LLVMValueRef src_trace_ptr = LLVMBuildLoad2(g->builder,
7602 LLVMGetGEPSourceElementType(their_trace_ptr_ptr), their_trace_ptr_ptr, "");
74887603 bool is_llvm_alloca;
74897604 LLVMValueRef dest_trace_ptr = get_cur_err_ret_trace_val(g, source_instr->scope, &is_llvm_alloca);
74907605 LLVMValueRef args[] = { dest_trace_ptr, src_trace_ptr };
7491 ZigLLVMBuildCall(g->builder, get_merge_err_ret_traces_fn_val(g), args, 2,
7606 ZigLLVMBuildCall(g->builder, LLVMTypeOf(get_merge_err_ret_traces_fn_val(g)),
7607 get_merge_err_ret_traces_fn_val(g), args, 2,
74927608 get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
74937609 }
74947610 if (non_async && type_has_bits(g, result_type)) {
......@@ -7503,6 +7619,8 @@ static LLVMValueRef ir_render_await(CodeGen *g, Stage1Air *executable, Stage1Air
75037619 LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
75047620 LLVMValueRef zero = LLVMConstNull(usize_type_ref);
75057621 LLVMValueRef target_frame_ptr = ir_llvm_value(g, instruction->frame);
7622 LLVMTypeRef target_frame_llvm_ty = get_llvm_type(g,
7623 instruction->frame->value->type->data.pointer.child_type);
75067624 ZigType *result_type = instruction->base.value->type;
75077625 ZigType *ptr_result_type = get_pointer_to_type(g, result_type, true);
75087626
......@@ -7512,8 +7630,8 @@ static LLVMValueRef ir_render_await(CodeGen *g, Stage1Air *executable, Stage1Air
75127630 if (instruction->is_nosuspend ||
75137631 (instruction->target_fn != nullptr && !fn_is_async(instruction->target_fn)))
75147632 {
7515 return gen_await_early_return(g, &instruction->base, target_frame_ptr, result_type,
7516 ptr_result_type, result_loc, true);
7633 return gen_await_early_return(g, &instruction->base, target_frame_llvm_ty,
7634 target_frame_ptr, result_type, ptr_result_type, result_loc, true);
75177635 }
75187636
75197637 // Prepare to be suspended
......@@ -7525,7 +7643,8 @@ static LLVMValueRef ir_render_await(CodeGen *g, Stage1Air *executable, Stage1Air
75257643
75267644 // supply the awaiter return pointer
75277645 if (type_has_bits(g, result_type)) {
7528 LLVMValueRef awaiter_ret_ptr_ptr = LLVMBuildStructGEP(g->builder, target_frame_ptr, frame_ret_start + 1, "");
7646 LLVMValueRef awaiter_ret_ptr_ptr = LLVMBuildStructGEP2(g->builder, target_frame_llvm_ty,
7647 target_frame_ptr, frame_ret_start + 1, "");
75297648 if (result_loc == nullptr) {
75307649 // no copy needed
75317650 LLVMBuildStore(g->builder, LLVMConstNull(LLVMGetElementType(LLVMTypeOf(awaiter_ret_ptr_ptr))),
......@@ -7540,14 +7659,15 @@ static LLVMValueRef ir_render_await(CodeGen *g, Stage1Air *executable, Stage1Air
75407659 bool is_llvm_alloca;
75417660 LLVMValueRef my_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope, &is_llvm_alloca);
75427661 assert(my_err_ret_trace_val != nullptr);
7543 LLVMValueRef err_ret_trace_ptr_ptr = LLVMBuildStructGEP(g->builder, target_frame_ptr,
7544 frame_index_trace_arg(g, result_type) + 1, "");
7662 LLVMValueRef err_ret_trace_ptr_ptr = LLVMBuildStructGEP2(g->builder, target_frame_llvm_ty,
7663 target_frame_ptr, frame_index_trace_arg(g, result_type) + 1, "");
75457664 LLVMBuildStore(g->builder, my_err_ret_trace_val, err_ret_trace_ptr_ptr);
75467665 }
75477666
75487667 // caller's own frame pointer
75497668 LLVMValueRef awaiter_init_val = LLVMBuildPtrToInt(g->builder, g->cur_frame_ptr, usize_type_ref, "");
7550 LLVMValueRef awaiter_ptr = LLVMBuildStructGEP(g->builder, target_frame_ptr, frame_awaiter_index, "");
7669 LLVMValueRef awaiter_ptr = LLVMBuildStructGEP2(g->builder, target_frame_llvm_ty,
7670 target_frame_ptr, frame_awaiter_index, "");
75517671 LLVMValueRef prev_val = gen_maybe_atomic_op(g, LLVMAtomicRMWBinOpXchg, awaiter_ptr, awaiter_init_val,
75527672 LLVMAtomicOrderingRelease);
75537673
......@@ -7572,8 +7692,8 @@ static LLVMValueRef ir_render_await(CodeGen *g, Stage1Air *executable, Stage1Air
75727692 // Early return: The async function has already completed. We must copy the result and
75737693 // the error return trace if applicable.
75747694 LLVMPositionBuilderAtEnd(g->builder, early_return_block);
7575 gen_await_early_return(g, &instruction->base, target_frame_ptr, result_type, ptr_result_type,
7576 result_loc, false);
7695 gen_await_early_return(g, &instruction->base, target_frame_llvm_ty, target_frame_ptr,
7696 result_type, ptr_result_type, result_loc, false);
75777697 LLVMBuildBr(g->builder, end_bb);
75787698
75797699 LLVMPositionBuilderAtEnd(g->builder, resume_bb);
......@@ -7631,7 +7751,8 @@ static LLVMValueRef ir_render_spill_end(CodeGen *g, Stage1Air *executable, Stage
76317751 zig_unreachable();
76327752 case SpillIdRetErrCode: {
76337753 LLVMValueRef ptr = ir_llvm_value(g, g->cur_fn->err_code_spill);
7634 return LLVMBuildLoad(g->builder, ptr, "");
7754 LLVMTypeRef llvm_ty = g->builtin_types.entry_global_error_set->llvm_type;
7755 return LLVMBuildLoad2(g->builder, llvm_ty, ptr, "");
76357756 }
76367757
76377758 }
......@@ -7923,24 +8044,12 @@ static LLVMValueRef gen_const_ptr_array_recursive(CodeGen *g, ZigValue *array_co
79238044 ConstParent *parent = &array_const_val->parent;
79248045 LLVMValueRef base_ptr = gen_parent_ptr(g, array_const_val, parent);
79258046
7926 LLVMTypeKind el_type = LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(base_ptr)));
7927 if (el_type == LLVMArrayTypeKind) {
7928 ZigType *usize = g->builtin_types.entry_usize;
7929 LLVMValueRef indices[] = {
7930 LLVMConstNull(usize->llvm_type),
7931 LLVMConstInt(usize->llvm_type, index, false),
7932 };
7933 return LLVMConstInBoundsGEP(base_ptr, indices, 2);
7934 } else if (el_type == LLVMStructTypeKind) {
7935 ZigType *u32 = g->builtin_types.entry_u32;
7936 LLVMValueRef indices[] = {
7937 LLVMConstNull(get_llvm_type(g, u32)),
7938 LLVMConstInt(get_llvm_type(g, u32), index, false),
7939 };
7940 return LLVMConstInBoundsGEP(base_ptr, indices, 2);
7941 } else {
7942 return base_ptr;
7943 }
8047 ZigType *usize = g->builtin_types.entry_usize;
8048 LLVMValueRef indices[] = {
8049 LLVMConstNull(usize->llvm_type),
8050 LLVMConstInt(usize->llvm_type, index, false),
8051 };
8052 return LLVMConstInBoundsGEP2(get_llvm_type(g, array_const_val->type), base_ptr, indices, 2);
79448053}
79458054
79468055static LLVMValueRef gen_const_ptr_struct_recursive(CodeGen *g, ZigValue *struct_const_val, size_t field_index) {
......@@ -7957,9 +8066,7 @@ static LLVMValueRef gen_const_ptr_struct_recursive(CodeGen *g, ZigValue *struct_
79578066 // alignment purposes and have the following LLVM type: <{ %T, [N x i8] }>.
79588067 // Add an extra bitcast as we're only interested in the %T part.
79598068 assert(handle_is_ptr(g, struct_const_val->type));
7960 LLVMValueRef casted_base_ptr = LLVMConstBitCast(base_ptr,
7961 LLVMPointerType(get_llvm_type(g, struct_const_val->type), 0));
7962 return LLVMConstInBoundsGEP(casted_base_ptr, indices, 2);
8069 return LLVMConstInBoundsGEP2(get_llvm_type(g, struct_const_val->type), base_ptr, indices, 2);
79638070}
79648071
79658072static LLVMValueRef gen_const_ptr_err_union_code_recursive(CodeGen *g, ZigValue *err_union_const_val) {
......@@ -7971,7 +8078,7 @@ static LLVMValueRef gen_const_ptr_err_union_code_recursive(CodeGen *g, ZigValue
79718078 LLVMConstNull(get_llvm_type(g, u32)),
79728079 LLVMConstInt(get_llvm_type(g, u32), err_union_err_index, false),
79738080 };
7974 return LLVMConstInBoundsGEP(base_ptr, indices, 2);
8081 return LLVMConstInBoundsGEP2(get_llvm_type(g, err_union_const_val->type), base_ptr, indices, 2);
79758082}
79768083
79778084static LLVMValueRef gen_const_ptr_err_union_payload_recursive(CodeGen *g, ZigValue *err_union_const_val) {
......@@ -7983,7 +8090,7 @@ static LLVMValueRef gen_const_ptr_err_union_payload_recursive(CodeGen *g, ZigVal
79838090 LLVMConstNull(get_llvm_type(g, u32)),
79848091 LLVMConstInt(get_llvm_type(g, u32), err_union_payload_index, false),
79858092 };
7986 return LLVMConstInBoundsGEP(base_ptr, indices, 2);
8093 return LLVMConstInBoundsGEP2(get_llvm_type(g, err_union_const_val->type), base_ptr, indices, 2);
79878094}
79888095
79898096static LLVMValueRef gen_const_ptr_optional_payload_recursive(CodeGen *g, ZigValue *optional_const_val) {
......@@ -7995,7 +8102,7 @@ static LLVMValueRef gen_const_ptr_optional_payload_recursive(CodeGen *g, ZigValu
79958102 LLVMConstNull(get_llvm_type(g, u32)),
79968103 LLVMConstInt(get_llvm_type(g, u32), maybe_child_index, false),
79978104 };
7998 return LLVMConstInBoundsGEP(base_ptr, indices, 2);
8105 return LLVMConstInBoundsGEP2(get_llvm_type(g, optional_const_val->type), base_ptr, indices, 2);
79998106}
80008107
80018108static LLVMValueRef gen_const_ptr_union_recursive(CodeGen *g, ZigValue *union_const_val) {
......@@ -8012,7 +8119,7 @@ static LLVMValueRef gen_const_ptr_union_recursive(CodeGen *g, ZigValue *union_co
80128119 LLVMConstNull(get_llvm_type(g, u32)),
80138120 LLVMConstInt(get_llvm_type(g, u32), union_payload_index, false),
80148121 };
8015 return LLVMConstInBoundsGEP(base_ptr, indices, (union_payload_index != SIZE_MAX) ? 2 : 1);
8122 return LLVMConstInBoundsGEP2(get_llvm_type(g, union_const_val->type), base_ptr, indices, (union_payload_index != SIZE_MAX) ? 2 : 1);
80168123}
80178124
80188125static LLVMValueRef pack_const_int(CodeGen *g, LLVMTypeRef big_int_type_ref, ZigValue *const_val) {
......@@ -9206,28 +9313,38 @@ static void do_code_gen(CodeGen *g) {
92069313 }
92079314 }
92089315
9316 LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
9317
92099318 // finishing error return trace setup. we have to do this after all the allocas.
92109319 if (have_err_ret_trace_stack) {
92119320 ZigType *usize = g->builtin_types.entry_usize;
92129321 size_t index_field_index = g->stack_trace_type->data.structure.fields[0]->gen_index;
9213 LLVMValueRef index_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)index_field_index, "");
9322 LLVMValueRef index_field_ptr = LLVMBuildStructGEP2(g->builder,
9323 get_llvm_type(g, g->stack_trace_type),
9324 g->cur_err_ret_trace_val_stack, (unsigned)index_field_index, "");
92149325 gen_store_untyped(g, LLVMConstNull(usize->llvm_type), index_field_ptr, 0, false);
92159326
92169327 size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1]->gen_index;
9217 LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)addresses_field_index, "");
9328 LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP2(g->builder,
9329 get_llvm_type(g, g->stack_trace_type),
9330 g->cur_err_ret_trace_val_stack, (unsigned)addresses_field_index, "");
92189331
92199332 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1]->type_entry;
92209333 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index]->gen_index;
9221 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)ptr_field_index, "");
9334 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP2(g->builder,
9335 LLVMGetGEPSourceElementType(addresses_field_ptr),
9336 addresses_field_ptr, (unsigned)ptr_field_index, "");
92229337 LLVMValueRef zero = LLVMConstNull(usize->llvm_type);
92239338 LLVMValueRef indices[] = {zero, zero};
9224 LLVMValueRef err_ret_array_val_elem0_ptr = LLVMBuildInBoundsGEP(g->builder, err_ret_array_val,
9225 indices, 2, "");
9339 LLVMValueRef err_ret_array_val_elem0_ptr = LLVMBuildInBoundsGEP2(g->builder,
9340 usize_type_ref, err_ret_array_val, indices, 2, "");
92269341 ZigType *ptr_ptr_usize_type = get_pointer_to_type(g, get_pointer_to_type(g, usize, false), false);
92279342 gen_store(g, err_ret_array_val_elem0_ptr, ptr_field_ptr, ptr_ptr_usize_type);
92289343
92299344 size_t len_field_index = slice_type->data.structure.fields[slice_len_index]->gen_index;
9230 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)len_field_index, "");
9345 LLVMValueRef len_field_ptr = LLVMBuildStructGEP2(g->builder,
9346 LLVMGetGEPSourceElementType(addresses_field_ptr),
9347 addresses_field_ptr, (unsigned)len_field_index, "");
92319348 gen_store(g, LLVMConstInt(usize->llvm_type, stack_trace_ptr_count, false), len_field_ptr, get_pointer_to_type(g, usize, false));
92329349 }
92339350
......@@ -9235,7 +9352,6 @@ static void do_code_gen(CodeGen *g) {
92359352 (void)get_llvm_type(g, fn_table_entry->frame_type);
92369353 g->cur_resume_block_count = 0;
92379354
9238 LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
92399355 LLVMValueRef size_val = LLVMConstInt(usize_type_ref, fn_table_entry->frame_type->abi_size, false);
92409356 if (g->need_frame_size_prefix_data) {
92419357 ZigLLVMFunctionSetPrefixData(fn_table_entry->llvm_value, size_val);
......@@ -9254,22 +9370,31 @@ static void do_code_gen(CodeGen *g) {
92549370
92559371 LLVMPositionBuilderAtEnd(g->builder, g->cur_preamble_llvm_block);
92569372 render_async_spills(g);
9257 g->cur_async_awaiter_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, frame_awaiter_index, "");
9258 LLVMValueRef resume_index_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, frame_resume_index, "");
9373 g->cur_async_awaiter_ptr = LLVMBuildStructGEP2(g->builder,
9374 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
9375 g->cur_frame_ptr, frame_awaiter_index, "");
9376 LLVMValueRef resume_index_ptr = LLVMBuildStructGEP2(g->builder,
9377 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
9378 g->cur_frame_ptr, frame_resume_index, "");
92599379 g->cur_async_resume_index_ptr = resume_index_ptr;
92609380
92619381 if (type_has_bits(g, fn_type_id->return_type)) {
9262 LLVMValueRef cur_ret_ptr_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, frame_ret_start, "");
9263 g->cur_ret_ptr = LLVMBuildLoad(g->builder, cur_ret_ptr_ptr, "");
9382 LLVMValueRef cur_ret_ptr_ptr = LLVMBuildStructGEP2(g->builder,
9383 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
9384 g->cur_frame_ptr, frame_ret_start, "");
9385 g->cur_ret_ptr = LLVMBuildLoad2(g->builder,
9386 LLVMPointerTypeInContext(LLVMGetGlobalContext(), 0), cur_ret_ptr_ptr, "");
92649387 }
92659388 uint32_t trace_field_index_stack = UINT32_MAX;
92669389 if (codegen_fn_has_err_ret_tracing_stack(g, fn_table_entry, true)) {
92679390 trace_field_index_stack = frame_index_trace_stack(g, fn_table_entry);
9268 g->cur_err_ret_trace_val_stack = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr,
9391 g->cur_err_ret_trace_val_stack = LLVMBuildStructGEP2(g->builder,
9392 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
9393 g->cur_frame_ptr,
92699394 trace_field_index_stack, "");
92709395 }
92719396
9272 LLVMValueRef resume_index = LLVMBuildLoad(g->builder, resume_index_ptr, "");
9397 LLVMValueRef resume_index = LLVMBuildLoad2(g->builder, usize_type_ref, resume_index_ptr, "");
92739398 LLVMValueRef switch_instr = LLVMBuildSwitch(g->builder, resume_index, bad_resume_block, 4);
92749399 g->cur_async_switch_instr = switch_instr;
92759400
......@@ -9293,15 +9418,21 @@ static void do_code_gen(CodeGen *g) {
92939418 LLVMBuildStore(g->builder, g->cur_bad_not_suspended_index, g->cur_async_resume_index_ptr);
92949419 if (trace_field_index_stack != UINT32_MAX) {
92959420 if (codegen_fn_has_err_ret_tracing_arg(g, fn_type_id->return_type)) {
9296 LLVMValueRef trace_ptr_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr,
9421 LLVMValueRef trace_ptr_ptr = LLVMBuildStructGEP2(g->builder,
9422 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
9423 g->cur_frame_ptr,
92979424 frame_index_trace_arg(g, fn_type_id->return_type), "");
92989425 LLVMValueRef zero_ptr = LLVMConstNull(LLVMGetElementType(LLVMTypeOf(trace_ptr_ptr)));
92999426 LLVMBuildStore(g->builder, zero_ptr, trace_ptr_ptr);
93009427 }
93019428
9302 LLVMValueRef trace_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr,
9429 LLVMValueRef trace_field_ptr = LLVMBuildStructGEP2(g->builder,
9430 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
9431 g->cur_frame_ptr,
93039432 trace_field_index_stack, "");
9304 LLVMValueRef addrs_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr,
9433 LLVMValueRef addrs_field_ptr = LLVMBuildStructGEP2(g->builder,
9434 get_llvm_type(g, get_fn_frame_type(g, g->cur_fn)),
9435 g->cur_frame_ptr,
93059436 trace_field_index_stack + 1, "");
93069437
93079438 gen_init_stack_trace(g, trace_field_ptr, addrs_field_ptr);
src/zig_llvm.cpp+7-6
......@@ -417,12 +417,13 @@ LLVMValueRef ZigLLVMAddFunctionInAddressSpace(LLVMModuleRef M, const char *Name,
417417 return wrap(func);
418418}
419419
420LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
421 unsigned NumArgs, ZigLLVM_CallingConv CC, ZigLLVM_CallAttr attr, const char *Name)
420LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
421 LLVMValueRef *Args, unsigned NumArgs, ZigLLVM_CallingConv CC, ZigLLVM_CallAttr attr,
422 const char *Name)
422423{
423 Value *V = unwrap(Fn);
424 FunctionType *FnT = cast<FunctionType>(V->getType()->getNonOpaquePointerElementType());
425 CallInst *call_inst = CallInst::Create(FnT, V, makeArrayRef(unwrap(Args), NumArgs), Name);
424 FunctionType *FTy = unwrap<FunctionType>(Ty);
425 CallInst *call_inst = unwrap(B)->CreateCall(FTy, unwrap(Fn), makeArrayRef(unwrap(Args),
426 NumArgs), Name);
426427 call_inst->setCallingConv(static_cast<CallingConv::ID>(CC));
427428 switch (attr) {
428429 case ZigLLVM_CallAttrAuto:
......@@ -440,7 +441,7 @@ LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *A
440441 call_inst->addFnAttr(Attribute::AlwaysInline);
441442 break;
442443 }
443 return wrap(unwrap(B)->Insert(call_inst));
444 return wrap(call_inst);
444445}
445446
446447LLVMValueRef ZigLLVMBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign,
src/zig_llvm.h+3-2
......@@ -125,8 +125,9 @@ enum ZigLLVM_CallAttr {
125125 ZigLLVM_CallAttrAlwaysTail,
126126 ZigLLVM_CallAttrAlwaysInline,
127127};
128ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
129 unsigned NumArgs, enum ZigLLVM_CallingConv CC, enum ZigLLVM_CallAttr attr, const char *Name);
128ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMTypeRef function_type,
129 LLVMValueRef Fn, LLVMValueRef *Args, unsigned NumArgs, enum ZigLLVM_CallingConv CC,
130 enum ZigLLVM_CallAttr attr, const char *Name);
130131
131132ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign,
132133 LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size, bool isVolatile);