authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2016-04-27 17:34:53-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2016-04-27 17:34:53-07:00
log4815c03caa08ecca6bdca85885506e850f9869b1
tree8768da5abfa92c4e605bb5fbbcbca224859acb36
parent09042f1b0ca15c0184beb13ab58c3034507372dc

better parameter codegen

* ability to take address of a parameter (closes #97) * debug symbols work for parameters

8 files changed, 209 insertions(+), 158 deletions(-)

src/all_types.hpp+1-1
......@@ -1268,7 +1268,6 @@ struct VariableTableEntry {
12681268 TypeTableEntry *type;
12691269 LLVMValueRef value_ref;
12701270 bool is_const;
1271 bool is_ptr; // if true, value_ref is a pointer
12721271 // which node is the declaration of the variable
12731272 AstNode *decl_node;
12741273 // which node contains the ConstExprValue for this variable's value
......@@ -1277,6 +1276,7 @@ struct VariableTableEntry {
12771276 int src_arg_index;
12781277 int gen_arg_index;
12791278 BlockContext *block_context;
1279 LLVMValueRef param_value_ref;
12801280};
12811281
12821282struct ErrorTableEntry {
src/analyze.cpp+4-1
......@@ -1081,6 +1081,10 @@ static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_t
10811081 if (!fn_table_entry->is_extern) {
10821082 LLVMAddFunctionAttr(fn_table_entry->fn_value, LLVMNoUnwindAttribute);
10831083 }
1084 if (!g->is_release_build) {
1085 ZigLLVMAddFunctionAttr(fn_table_entry->fn_value, "no-frame-pointer-elim", "true");
1086 ZigLLVMAddFunctionAttr(fn_table_entry->fn_value, "no-frame-pointer-elim-non-leaf", nullptr);
1087 }
10841088
10851089 if (fn_table_entry->fn_def_node) {
10861090 // Add debug info.
......@@ -3369,7 +3373,6 @@ static VariableTableEntry *add_local_var(CodeGen *g, AstNode *source_node, Impor
33693373 }
33703374
33713375 variable_entry->is_const = is_const;
3372 variable_entry->is_ptr = true;
33733376 variable_entry->decl_node = source_node;
33743377 variable_entry->val_node = val_node;
33753378
src/codegen.cpp+157-147
......@@ -226,9 +226,13 @@ static TypeTableEntry *get_type_for_type_node(AstNode *node) {
226226 return const_val->data.x_type;
227227}
228228
229static void add_debug_source_node(CodeGen *g, AstNode *node) {
229static void set_debug_source_node(CodeGen *g, AstNode *node) {
230230 assert(node->block_context);
231 LLVMZigSetCurrentDebugLocation(g->builder, node->line + 1, node->column + 1, node->block_context->di_scope);
231 ZigLLVMSetCurrentDebugLocation(g->builder, node->line + 1, node->column + 1, node->block_context->di_scope);
232}
233
234static void clear_debug_source_node(CodeGen *g) {
235 ZigLLVMClearCurrentDebugLocation(g->builder);
232236}
233237
234238static TypeTableEntry *get_expr_type(AstNode *node) {
......@@ -325,7 +329,7 @@ static LLVMValueRef get_handle_value(CodeGen *g, AstNode *source_node, LLVMValue
325329 if (handle_is_ptr(type)) {
326330 return ptr;
327331 } else {
328 add_debug_source_node(g, source_node);
332 set_debug_source_node(g, source_node);
329333 return LLVMBuildLoad(g->builder, ptr, "");
330334 }
331335}
......@@ -347,7 +351,7 @@ static void add_bounds_check(CodeGen *g, AstNode *source_node, LLVMValueRef targ
347351 upper_value = nullptr;
348352 }
349353
350 add_debug_source_node(g, source_node);
354 set_debug_source_node(g, source_node);
351355
352356 LLVMBasicBlockRef bounds_check_fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "BoundsCheckFail");
353357 LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "BoundsCheckOk");
......@@ -382,7 +386,7 @@ static LLVMValueRef gen_err_name(CodeGen *g, AstNode *node) {
382386
383387 AstNode *err_val_node = node->data.fn_call_expr.params.at(0);
384388 LLVMValueRef err_val = gen_expr(g, err_val_node);
385 add_debug_source_node(g, node);
389 set_debug_source_node(g, node);
386390
387391 if (want_debug_safety(g, node)) {
388392 LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(err_val));
......@@ -425,7 +429,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
425429 operand,
426430 LLVMConstNull(LLVMInt1Type()),
427431 };
428 add_debug_source_node(g, node);
432 set_debug_source_node(g, node);
429433 return LLVMBuildCall(g->builder, fn_val, params, 2, "");
430434 }
431435 case BuiltinFnIdAddWithOverflow:
......@@ -457,7 +461,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
457461 op2,
458462 };
459463
460 add_debug_source_node(g, node);
464 set_debug_source_node(g, node);
461465 LLVMValueRef result_struct = LLVMBuildCall(g->builder, fn_val, params, 2, "");
462466 LLVMValueRef result = LLVMBuildExtractValue(g->builder, result_struct, 0, "");
463467 LLVMValueRef overflow_bit = LLVMBuildExtractValue(g->builder, result_struct, 1, "");
......@@ -479,7 +483,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
479483
480484 LLVMTypeRef ptr_u8 = LLVMPointerType(LLVMInt8Type(), 0);
481485
482 add_debug_source_node(g, node);
486 set_debug_source_node(g, node);
483487 LLVMValueRef dest_ptr_casted = LLVMBuildBitCast(g->builder, dest_ptr, ptr_u8, "");
484488 LLVMValueRef src_ptr_casted = LLVMBuildBitCast(g->builder, src_ptr, ptr_u8, "");
485489
......@@ -510,7 +514,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
510514
511515 LLVMTypeRef ptr_u8 = LLVMPointerType(LLVMInt8Type(), 0);
512516
513 add_debug_source_node(g, node);
517 set_debug_source_node(g, node);
514518 LLVMValueRef dest_ptr_casted = LLVMBuildBitCast(g->builder, dest_ptr, ptr_u8, "");
515519
516520 uint64_t align_in_bytes = get_memcpy_align(g, dest_type->data.pointer.child_type);
......@@ -540,7 +544,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
540544 case BuiltinFnIdErrName:
541545 return gen_err_name(g, node);
542546 case BuiltinFnIdBreakpoint:
543 add_debug_source_node(g, node);
547 set_debug_source_node(g, node);
544548 return LLVMBuildCall(g->builder, g->trap_fn_val, nullptr, 0, "");
545549 }
546550 zig_unreachable();
......@@ -570,7 +574,7 @@ static LLVMValueRef gen_enum_value_expr(CodeGen *g, AstNode *node, TypeTableEntr
570574 LLVMValueRef tmp_struct_ptr = node->data.field_access_expr.resolved_struct_val_expr.ptr;
571575
572576 // populate the new tag value
573 add_debug_source_node(g, node);
577 set_debug_source_node(g, node);
574578 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, 0, "");
575579 LLVMBuildStore(g->builder, tag_value, tag_field_ptr);
576580
......@@ -610,14 +614,14 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen *g, AstNode *source_node, TypeT
610614 return expr_val;
611615 } else if (actual_bits < wanted_bits) {
612616 if (actual_type->id == TypeTableEntryIdFloat) {
613 add_debug_source_node(g, source_node);
617 set_debug_source_node(g, source_node);
614618 return LLVMBuildFPExt(g->builder, expr_val, wanted_type->type_ref, "");
615619 } else if (actual_type->id == TypeTableEntryIdInt) {
616620 if (actual_type->data.integral.is_signed) {
617 add_debug_source_node(g, source_node);
621 set_debug_source_node(g, source_node);
618622 return LLVMBuildSExt(g->builder, expr_val, wanted_type->type_ref, "");
619623 } else {
620 add_debug_source_node(g, source_node);
624 set_debug_source_node(g, source_node);
621625 return LLVMBuildZExt(g->builder, expr_val, wanted_type->type_ref, "");
622626 }
623627 } else {
......@@ -625,10 +629,10 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen *g, AstNode *source_node, TypeT
625629 }
626630 } else if (actual_bits > wanted_bits) {
627631 if (actual_type->id == TypeTableEntryIdFloat) {
628 add_debug_source_node(g, source_node);
632 set_debug_source_node(g, source_node);
629633 return LLVMBuildFPTrunc(g->builder, expr_val, wanted_type->type_ref, "");
630634 } else if (actual_type->id == TypeTableEntryIdInt) {
631 add_debug_source_node(g, source_node);
635 set_debug_source_node(g, source_node);
632636 return LLVMBuildTrunc(g->builder, expr_val, wanted_type->type_ref, "");
633637 } else {
634638 zig_unreachable();
......@@ -675,12 +679,12 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
675679 {
676680 return expr_val;
677681 } else {
678 add_debug_source_node(g, node);
682 set_debug_source_node(g, node);
679683 LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, 0, "");
680684 gen_assign_raw(g, node, BinOpTypeAssign,
681685 val_ptr, expr_val, child_type, actual_type);
682686
683 add_debug_source_node(g, node);
687 set_debug_source_node(g, node);
684688 LLVMValueRef maybe_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, 1, "");
685689 LLVMBuildStore(g->builder, LLVMConstAllOnes(LLVMInt1Type()), maybe_ptr);
686690 }
......@@ -700,7 +704,7 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
700704 assert(wanted_type->id == TypeTableEntryIdErrorUnion);
701705 assert(actual_type);
702706
703 add_debug_source_node(g, node);
707 set_debug_source_node(g, node);
704708 LLVMValueRef err_tag_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, 0, "");
705709 LLVMBuildStore(g->builder, ok_err_val, err_tag_ptr);
706710
......@@ -720,13 +724,13 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
720724 zig_panic("TODO");
721725 }
722726 case CastOpPtrToInt:
723 add_debug_source_node(g, node);
727 set_debug_source_node(g, node);
724728 return LLVMBuildPtrToInt(g->builder, expr_val, wanted_type->type_ref, "");
725729 case CastOpIntToPtr:
726 add_debug_source_node(g, node);
730 set_debug_source_node(g, node);
727731 return LLVMBuildIntToPtr(g->builder, expr_val, wanted_type->type_ref, "");
728732 case CastOpPointerReinterpret:
729 add_debug_source_node(g, node);
733 set_debug_source_node(g, node);
730734 return LLVMBuildBitCast(g->builder, expr_val, wanted_type->type_ref, "");
731735 case CastOpWidenOrShorten:
732736 return gen_widen_or_shorten(g, node, actual_type, wanted_type, expr_val);
......@@ -738,7 +742,7 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
738742
739743 TypeTableEntry *pointer_type = wanted_type->data.structure.fields[0].type_entry;
740744
741 add_debug_source_node(g, node);
745 set_debug_source_node(g, node);
742746
743747 int ptr_index = wanted_type->data.structure.fields[0].gen_index;
744748 if (ptr_index >= 0) {
......@@ -758,26 +762,26 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
758762 case CastOpIntToFloat:
759763 assert(actual_type->id == TypeTableEntryIdInt);
760764 if (actual_type->data.integral.is_signed) {
761 add_debug_source_node(g, node);
765 set_debug_source_node(g, node);
762766 return LLVMBuildSIToFP(g->builder, expr_val, wanted_type->type_ref, "");
763767 } else {
764 add_debug_source_node(g, node);
768 set_debug_source_node(g, node);
765769 return LLVMBuildUIToFP(g->builder, expr_val, wanted_type->type_ref, "");
766770 }
767771 case CastOpFloatToInt:
768772 assert(wanted_type->id == TypeTableEntryIdInt);
769773 if (wanted_type->data.integral.is_signed) {
770 add_debug_source_node(g, node);
774 set_debug_source_node(g, node);
771775 return LLVMBuildFPToSI(g->builder, expr_val, wanted_type->type_ref, "");
772776 } else {
773 add_debug_source_node(g, node);
777 set_debug_source_node(g, node);
774778 return LLVMBuildFPToUI(g->builder, expr_val, wanted_type->type_ref, "");
775779 }
776780
777781 case CastOpBoolToInt:
778782 assert(wanted_type->id == TypeTableEntryIdInt);
779783 assert(actual_type->id == TypeTableEntryIdBool);
780 add_debug_source_node(g, node);
784 set_debug_source_node(g, node);
781785 return LLVMBuildZExt(g->builder, expr_val, wanted_type->type_ref, "");
782786
783787 }
......@@ -850,7 +854,7 @@ static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) {
850854 }
851855 }
852856
853 add_debug_source_node(g, node);
857 set_debug_source_node(g, node);
854858 LLVMValueRef result = LLVMZigBuildCall(g->builder, fn_val,
855859 gen_param_values, gen_param_index, fn_type->data.fn.calling_convention, "");
856860
......@@ -873,7 +877,7 @@ static LLVMValueRef gen_array_base_ptr(CodeGen *g, AstNode *node) {
873877 array_ptr = gen_field_access_expr(g, node, true);
874878 if (type_entry->id == TypeTableEntryIdPointer) {
875879 // we have a double pointer so we must dereference it once
876 add_debug_source_node(g, node);
880 set_debug_source_node(g, node);
877881 array_ptr = LLVMBuildLoad(g->builder, array_ptr, "");
878882 }
879883 } else {
......@@ -904,14 +908,14 @@ static LLVMValueRef gen_array_elem_ptr(CodeGen *g, AstNode *source_node, LLVMVal
904908 LLVMConstNull(g->builtin_types.entry_isize->type_ref),
905909 subscript_value
906910 };
907 add_debug_source_node(g, source_node);
911 set_debug_source_node(g, source_node);
908912 return LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 2, "");
909913 } else if (array_type->id == TypeTableEntryIdPointer) {
910914 assert(LLVMGetTypeKind(LLVMTypeOf(array_ptr)) == LLVMPointerTypeKind);
911915 LLVMValueRef indices[] = {
912916 subscript_value
913917 };
914 add_debug_source_node(g, source_node);
918 set_debug_source_node(g, source_node);
915919 return LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 1, "");
916920 } else if (array_type->id == TypeTableEntryIdStruct) {
917921 assert(array_type->data.structure.is_slice);
......@@ -919,7 +923,7 @@ static LLVMValueRef gen_array_elem_ptr(CodeGen *g, AstNode *source_node, LLVMVal
919923 assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(array_ptr))) == LLVMStructTypeKind);
920924
921925 if (want_debug_safety(g, source_node)) {
922 add_debug_source_node(g, source_node);
926 set_debug_source_node(g, source_node);
923927 int len_index = array_type->data.structure.fields[1].gen_index;
924928 assert(len_index >= 0);
925929 LLVMValueRef len_ptr = LLVMBuildStructGEP(g->builder, array_ptr, len_index, "");
......@@ -927,7 +931,7 @@ static LLVMValueRef gen_array_elem_ptr(CodeGen *g, AstNode *source_node, LLVMVal
927931 add_bounds_check(g, source_node, subscript_value, LLVMIntEQ, nullptr, LLVMIntULT, len);
928932 }
929933
930 add_debug_source_node(g, source_node);
934 set_debug_source_node(g, source_node);
931935 int ptr_index = array_type->data.structure.fields[0].gen_index;
932936 assert(ptr_index >= 0);
933937 LLVMValueRef ptr_ptr = LLVMBuildStructGEP(g->builder, array_ptr, ptr_index, "");
......@@ -960,8 +964,8 @@ static LLVMValueRef gen_field_ptr(CodeGen *g, AstNode *node, TypeTableEntry **ou
960964 VariableTableEntry *var = get_resolved_expr(struct_expr_node)->variable;
961965 assert(var);
962966
963 if (var->is_ptr && var->type->id == TypeTableEntryIdPointer) {
964 add_debug_source_node(g, node);
967 if (var->type->id == TypeTableEntryIdPointer) {
968 set_debug_source_node(g, node);
965969 struct_ptr = LLVMBuildLoad(g->builder, var->value_ref, "");
966970 } else {
967971 struct_ptr = var->value_ref;
......@@ -971,7 +975,7 @@ static LLVMValueRef gen_field_ptr(CodeGen *g, AstNode *node, TypeTableEntry **ou
971975 TypeTableEntry *field_type = get_expr_type(struct_expr_node);
972976 if (field_type->id == TypeTableEntryIdPointer) {
973977 // we have a double pointer so we must dereference it once
974 add_debug_source_node(g, node);
978 set_debug_source_node(g, node);
975979 struct_ptr = LLVMBuildLoad(g->builder, struct_ptr, "");
976980 }
977981 } else {
......@@ -986,7 +990,7 @@ static LLVMValueRef gen_field_ptr(CodeGen *g, AstNode *node, TypeTableEntry **ou
986990
987991 *out_type_entry = node->data.field_access_expr.type_struct_field->type_entry;
988992
989 add_debug_source_node(g, node);
993 set_debug_source_node(g, node);
990994 return LLVMBuildStructGEP(g->builder, struct_ptr, gen_field_index, "");
991995}
992996
......@@ -1017,7 +1021,7 @@ static LLVMValueRef gen_slice_expr(CodeGen *g, AstNode *node) {
10171021 }
10181022 }
10191023
1020 add_debug_source_node(g, node);
1024 set_debug_source_node(g, node);
10211025 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, 0, "");
10221026 LLVMValueRef indices[] = {
10231027 LLVMConstNull(g->builtin_types.entry_isize->type_ref),
......@@ -1039,7 +1043,7 @@ static LLVMValueRef gen_slice_expr(CodeGen *g, AstNode *node) {
10391043 add_bounds_check(g, node, start_val, LLVMIntEQ, nullptr, LLVMIntULE, end_val);
10401044 }
10411045
1042 add_debug_source_node(g, node);
1046 set_debug_source_node(g, node);
10431047 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, 0, "");
10441048 LLVMValueRef slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, array_ptr, &start_val, 1, "");
10451049 LLVMBuildStore(g->builder, slice_start_ptr, ptr_field_ptr);
......@@ -1061,7 +1065,7 @@ static LLVMValueRef gen_slice_expr(CodeGen *g, AstNode *node) {
10611065
10621066 LLVMValueRef prev_end = nullptr;
10631067 if (!node->data.slice_expr.end || want_debug_safety(g, node)) {
1064 add_debug_source_node(g, node);
1068 set_debug_source_node(g, node);
10651069 LLVMValueRef src_len_ptr = LLVMBuildStructGEP(g->builder, array_ptr, len_index, "");
10661070 prev_end = LLVMBuildLoad(g->builder, src_len_ptr, "");
10671071 }
......@@ -1082,7 +1086,7 @@ static LLVMValueRef gen_slice_expr(CodeGen *g, AstNode *node) {
10821086 }
10831087 }
10841088
1085 add_debug_source_node(g, node);
1089 set_debug_source_node(g, node);
10861090 LLVMValueRef src_ptr_ptr = LLVMBuildStructGEP(g->builder, array_ptr, ptr_index, "");
10871091 LLVMValueRef src_ptr = LLVMBuildLoad(g->builder, src_ptr_ptr, "");
10881092 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, ptr_index, "");
......@@ -1122,7 +1126,7 @@ static LLVMValueRef gen_array_access_expr(CodeGen *g, AstNode *node, bool is_lva
11221126 if (is_lvalue || !ptr || handle_is_ptr(child_type)) {
11231127 return ptr;
11241128 } else {
1125 add_debug_source_node(g, node);
1129 set_debug_source_node(g, node);
11261130 return LLVMBuildLoad(g->builder, ptr, "");
11271131 }
11281132}
......@@ -1130,11 +1134,9 @@ static LLVMValueRef gen_array_access_expr(CodeGen *g, AstNode *node, bool is_lva
11301134static LLVMValueRef gen_variable(CodeGen *g, AstNode *source_node, VariableTableEntry *variable) {
11311135 if (!type_has_bits(variable->type)) {
11321136 return nullptr;
1133 } else if (variable->is_ptr) {
1137 } else {
11341138 assert(variable->value_ref);
11351139 return get_handle_value(g, source_node, variable->value_ref, variable->type);
1136 } else {
1137 return variable->value_ref;
11381140 }
11391141}
11401142
......@@ -1157,7 +1159,7 @@ static LLVMValueRef gen_field_access_expr(CodeGen *g, AstNode *node, bool is_lva
11571159 if (is_lvalue || handle_is_ptr(type_entry)) {
11581160 return ptr;
11591161 } else {
1160 add_debug_source_node(g, node);
1162 set_debug_source_node(g, node);
11611163 return LLVMBuildLoad(g->builder, ptr, "");
11621164 }
11631165 } else if (struct_type->id == TypeTableEntryIdMetaType) {
......@@ -1233,10 +1235,10 @@ static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
12331235 {
12341236 LLVMValueRef expr = gen_expr(g, expr_node);
12351237 if (expr_type->id == TypeTableEntryIdInt) {
1236 add_debug_source_node(g, node);
1238 set_debug_source_node(g, node);
12371239 return LLVMBuildNeg(g->builder, expr, "");
12381240 } else if (expr_type->id == TypeTableEntryIdFloat) {
1239 add_debug_source_node(g, node);
1241 set_debug_source_node(g, node);
12401242 return LLVMBuildFNeg(g->builder, expr, "");
12411243 } else {
12421244 zig_unreachable();
......@@ -1246,13 +1248,13 @@ static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
12461248 {
12471249 LLVMValueRef expr = gen_expr(g, expr_node);
12481250 LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(expr));
1249 add_debug_source_node(g, node);
1251 set_debug_source_node(g, node);
12501252 return LLVMBuildICmp(g->builder, LLVMIntEQ, expr, zero, "");
12511253 }
12521254 case PrefixOpBinNot:
12531255 {
12541256 LLVMValueRef expr = gen_expr(g, expr_node);
1255 add_debug_source_node(g, node);
1257 set_debug_source_node(g, node);
12561258 return LLVMBuildNot(g->builder, expr, "");
12571259 }
12581260 case PrefixOpAddressOf:
......@@ -1291,13 +1293,13 @@ static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
12911293 if (want_debug_safety(g, node)) {
12921294 LLVMValueRef err_val;
12931295 if (type_has_bits(child_type)) {
1294 add_debug_source_node(g, node);
1296 set_debug_source_node(g, node);
12951297 LLVMValueRef err_val_ptr = LLVMBuildStructGEP(g->builder, expr_val, 0, "");
12961298 err_val = LLVMBuildLoad(g->builder, err_val_ptr, "");
12971299 } else {
12981300 err_val = expr_val;
12991301 }
1300 add_debug_source_node(g, node);
1302 set_debug_source_node(g, node);
13011303 LLVMValueRef zero = LLVMConstNull(g->err_tag_type->type_ref);
13021304 LLVMValueRef cond_val = LLVMBuildICmp(g->builder, LLVMIntEQ, err_val, zero, "");
13031305 LLVMBasicBlockRef err_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "UnwrapErrError");
......@@ -1327,7 +1329,7 @@ static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
13271329 TypeTableEntry *child_type = expr_type->data.maybe.child_type;
13281330
13291331 if (want_debug_safety(g, node)) {
1330 add_debug_source_node(g, node);
1332 set_debug_source_node(g, node);
13311333 LLVMValueRef cond_val;
13321334 if (child_type->id == TypeTableEntryIdPointer ||
13331335 child_type->id == TypeTableEntryIdFn)
......@@ -1356,7 +1358,7 @@ static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
13561358 {
13571359 return expr_val;
13581360 } else {
1359 add_debug_source_node(g, node);
1361 set_debug_source_node(g, node);
13601362 LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP(g->builder, expr_val, 0, "");
13611363 return get_handle_value(g, node, maybe_field_ptr, child_type);
13621364 }
......@@ -1375,26 +1377,26 @@ static LLVMValueRef gen_arithmetic_bin_op(CodeGen *g, AstNode *source_node,
13751377 switch (bin_op) {
13761378 case BinOpTypeBinOr:
13771379 case BinOpTypeAssignBitOr:
1378 add_debug_source_node(g, source_node);
1380 set_debug_source_node(g, source_node);
13791381 return LLVMBuildOr(g->builder, val1, val2, "");
13801382 case BinOpTypeBinXor:
13811383 case BinOpTypeAssignBitXor:
1382 add_debug_source_node(g, source_node);
1384 set_debug_source_node(g, source_node);
13831385 return LLVMBuildXor(g->builder, val1, val2, "");
13841386 case BinOpTypeBinAnd:
13851387 case BinOpTypeAssignBitAnd:
1386 add_debug_source_node(g, source_node);
1388 set_debug_source_node(g, source_node);
13871389 return LLVMBuildAnd(g->builder, val1, val2, "");
13881390 case BinOpTypeBitShiftLeft:
13891391 case BinOpTypeAssignBitShiftLeft:
1390 add_debug_source_node(g, source_node);
1392 set_debug_source_node(g, source_node);
13911393 return LLVMBuildShl(g->builder, val1, val2, "");
13921394 case BinOpTypeBitShiftRight:
13931395 case BinOpTypeAssignBitShiftRight:
13941396 assert(op1_type->id == TypeTableEntryIdInt);
13951397 assert(op2_type->id == TypeTableEntryIdInt);
13961398
1397 add_debug_source_node(g, source_node);
1399 set_debug_source_node(g, source_node);
13981400 if (op1_type->data.integral.is_signed) {
13991401 return LLVMBuildAShr(g->builder, val1, val2, "");
14001402 } else {
......@@ -1402,7 +1404,7 @@ static LLVMValueRef gen_arithmetic_bin_op(CodeGen *g, AstNode *source_node,
14021404 }
14031405 case BinOpTypeAdd:
14041406 case BinOpTypeAssignPlus:
1405 add_debug_source_node(g, source_node);
1407 set_debug_source_node(g, source_node);
14061408 if (op1_type->id == TypeTableEntryIdFloat) {
14071409 return LLVMBuildFAdd(g->builder, val1, val2, "");
14081410 } else {
......@@ -1410,7 +1412,7 @@ static LLVMValueRef gen_arithmetic_bin_op(CodeGen *g, AstNode *source_node,
14101412 }
14111413 case BinOpTypeSub:
14121414 case BinOpTypeAssignMinus:
1413 add_debug_source_node(g, source_node);
1415 set_debug_source_node(g, source_node);
14141416 if (op1_type->id == TypeTableEntryIdFloat) {
14151417 return LLVMBuildFSub(g->builder, val1, val2, "");
14161418 } else {
......@@ -1418,7 +1420,7 @@ static LLVMValueRef gen_arithmetic_bin_op(CodeGen *g, AstNode *source_node,
14181420 }
14191421 case BinOpTypeMult:
14201422 case BinOpTypeAssignTimes:
1421 add_debug_source_node(g, source_node);
1423 set_debug_source_node(g, source_node);
14221424 if (op1_type->id == TypeTableEntryIdFloat) {
14231425 return LLVMBuildFMul(g->builder, val1, val2, "");
14241426 } else {
......@@ -1426,7 +1428,7 @@ static LLVMValueRef gen_arithmetic_bin_op(CodeGen *g, AstNode *source_node,
14261428 }
14271429 case BinOpTypeDiv:
14281430 case BinOpTypeAssignDiv:
1429 add_debug_source_node(g, source_node);
1431 set_debug_source_node(g, source_node);
14301432 if (op1_type->id == TypeTableEntryIdFloat) {
14311433 return LLVMBuildFDiv(g->builder, val1, val2, "");
14321434 } else {
......@@ -1439,7 +1441,7 @@ static LLVMValueRef gen_arithmetic_bin_op(CodeGen *g, AstNode *source_node,
14391441 }
14401442 case BinOpTypeMod:
14411443 case BinOpTypeAssignMod:
1442 add_debug_source_node(g, source_node);
1444 set_debug_source_node(g, source_node);
14431445 if (op1_type->id == TypeTableEntryIdFloat) {
14441446 return LLVMBuildFRem(g->builder, val1, val2, "");
14451447 } else {
......@@ -1528,7 +1530,7 @@ static LLVMValueRef gen_cmp_expr(CodeGen *g, AstNode *node) {
15281530 TypeTableEntry *op2_type = get_expr_type(node->data.bin_op_expr.op2);
15291531 assert(op1_type == op2_type);
15301532
1531 add_debug_source_node(g, node);
1533 set_debug_source_node(g, node);
15321534 if (op1_type->id == TypeTableEntryIdFloat) {
15331535 LLVMRealPredicate pred = cmp_op_to_real_predicate(node->data.bin_op_expr.bin_op);
15341536 return LLVMBuildFCmp(g->builder, pred, val1, val2, "");
......@@ -1565,18 +1567,18 @@ static LLVMValueRef gen_bool_and_expr(CodeGen *g, AstNode *node) {
15651567 // block for when val1 == false (don't even evaluate the second part)
15661568 LLVMBasicBlockRef false_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "BoolAndFalse");
15671569
1568 add_debug_source_node(g, node);
1570 set_debug_source_node(g, node);
15691571 LLVMBuildCondBr(g->builder, val1, true_block, false_block);
15701572
15711573 LLVMPositionBuilderAtEnd(g->builder, true_block);
15721574 LLVMValueRef val2 = gen_expr(g, node->data.bin_op_expr.op2);
15731575 LLVMBasicBlockRef post_val2_block = LLVMGetInsertBlock(g->builder);
15741576
1575 add_debug_source_node(g, node);
1577 set_debug_source_node(g, node);
15761578 LLVMBuildBr(g->builder, false_block);
15771579
15781580 LLVMPositionBuilderAtEnd(g->builder, false_block);
1579 add_debug_source_node(g, node);
1581 set_debug_source_node(g, node);
15801582 LLVMValueRef phi = LLVMBuildPhi(g->builder, LLVMInt1Type(), "");
15811583 LLVMValueRef incoming_values[2] = {val1, val2};
15821584 LLVMBasicBlockRef incoming_blocks[2] = {post_val1_block, post_val2_block};
......@@ -1596,7 +1598,7 @@ static LLVMValueRef gen_bool_or_expr(CodeGen *g, AstNode *expr_node) {
15961598 // block for when val1 == true (don't even evaluate the second part)
15971599 LLVMBasicBlockRef true_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "BoolOrTrue");
15981600
1599 add_debug_source_node(g, expr_node);
1601 set_debug_source_node(g, expr_node);
16001602 LLVMBuildCondBr(g->builder, val1, true_block, false_block);
16011603
16021604 LLVMPositionBuilderAtEnd(g->builder, false_block);
......@@ -1604,11 +1606,11 @@ static LLVMValueRef gen_bool_or_expr(CodeGen *g, AstNode *expr_node) {
16041606
16051607 LLVMBasicBlockRef post_val2_block = LLVMGetInsertBlock(g->builder);
16061608
1607 add_debug_source_node(g, expr_node);
1609 set_debug_source_node(g, expr_node);
16081610 LLVMBuildBr(g->builder, true_block);
16091611
16101612 LLVMPositionBuilderAtEnd(g->builder, true_block);
1611 add_debug_source_node(g, expr_node);
1613 set_debug_source_node(g, expr_node);
16121614 LLVMValueRef phi = LLVMBuildPhi(g->builder, LLVMInt1Type(), "");
16131615 LLVMValueRef incoming_values[2] = {val1, val2};
16141616 LLVMBasicBlockRef incoming_blocks[2] = {post_val1_block, post_val2_block};
......@@ -1624,7 +1626,7 @@ static LLVMValueRef gen_struct_memcpy(CodeGen *g, AstNode *source_node, LLVMValu
16241626
16251627 LLVMTypeRef ptr_u8 = LLVMPointerType(LLVMInt8Type(), 0);
16261628
1627 add_debug_source_node(g, source_node);
1629 set_debug_source_node(g, source_node);
16281630 LLVMValueRef src_ptr = LLVMBuildBitCast(g->builder, src, ptr_u8, "");
16291631 LLVMValueRef dest_ptr = LLVMBuildBitCast(g->builder, dest, ptr_u8, "");
16301632
......@@ -1661,13 +1663,13 @@ static LLVMValueRef gen_assign_raw(CodeGen *g, AstNode *source_node, BinOpType b
16611663
16621664 if (bin_op != BinOpTypeAssign) {
16631665 assert(source_node->type == NodeTypeBinOpExpr);
1664 add_debug_source_node(g, source_node->data.bin_op_expr.op1);
1666 set_debug_source_node(g, source_node->data.bin_op_expr.op1);
16651667 LLVMValueRef left_value = LLVMBuildLoad(g->builder, target_ref, "");
16661668
16671669 value = gen_arithmetic_bin_op(g, source_node, left_value, value, op1_type, op2_type, bin_op);
16681670 }
16691671
1670 add_debug_source_node(g, source_node);
1672 set_debug_source_node(g, source_node);
16711673 LLVMBuildStore(g->builder, value, target_ref);
16721674 return nullptr;
16731675}
......@@ -1698,7 +1700,7 @@ static LLVMValueRef gen_unwrap_maybe(CodeGen *g, AstNode *node, LLVMValueRef may
16981700 {
16991701 return maybe_struct_ref;
17001702 } else {
1701 add_debug_source_node(g, node);
1703 set_debug_source_node(g, node);
17021704 LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP(g->builder, maybe_struct_ref, 0, "");
17031705 return get_handle_value(g, node, maybe_field_ptr, child_type);
17041706 }
......@@ -1724,7 +1726,7 @@ static LLVMValueRef gen_unwrap_maybe_expr(CodeGen *g, AstNode *node) {
17241726 cond_value = LLVMBuildICmp(g->builder, LLVMIntNE, maybe_struct_ref,
17251727 LLVMConstNull(child_type->type_ref), "");
17261728 } else {
1727 add_debug_source_node(g, node);
1729 set_debug_source_node(g, node);
17281730 LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP(g->builder, maybe_struct_ref, 1, "");
17291731 cond_value = LLVMBuildLoad(g->builder, maybe_field_ptr, "");
17301732 }
......@@ -1739,21 +1741,21 @@ static LLVMValueRef gen_unwrap_maybe_expr(CodeGen *g, AstNode *node) {
17391741
17401742 LLVMPositionBuilderAtEnd(g->builder, non_null_block);
17411743 LLVMValueRef non_null_result = gen_unwrap_maybe(g, op1_node, maybe_struct_ref);
1742 add_debug_source_node(g, node);
1744 set_debug_source_node(g, node);
17431745 LLVMBuildBr(g->builder, end_block);
17441746 LLVMBasicBlockRef post_non_null_result_block = LLVMGetInsertBlock(g->builder);
17451747
17461748 LLVMPositionBuilderAtEnd(g->builder, null_block);
17471749 LLVMValueRef null_result = gen_expr(g, op2_node);
17481750 if (null_reachable) {
1749 add_debug_source_node(g, node);
1751 set_debug_source_node(g, node);
17501752 LLVMBuildBr(g->builder, end_block);
17511753 }
17521754 LLVMBasicBlockRef post_null_result_block = LLVMGetInsertBlock(g->builder);
17531755
17541756 LLVMPositionBuilderAtEnd(g->builder, end_block);
17551757 if (null_reachable) {
1756 add_debug_source_node(g, node);
1758 set_debug_source_node(g, node);
17571759 LLVMValueRef phi = LLVMBuildPhi(g->builder, LLVMTypeOf(non_null_result), "");
17581760 LLVMValueRef incoming_values[2] = {non_null_result, null_result};
17591761 LLVMBasicBlockRef incoming_blocks[2] = {post_non_null_result_block, post_null_result_block};
......@@ -1826,7 +1828,7 @@ static LLVMValueRef gen_unwrap_err_expr(CodeGen *g, AstNode *node) {
18261828 assert(expr_type->id == TypeTableEntryIdErrorUnion);
18271829 TypeTableEntry *child_type = expr_type->data.error.child_type;
18281830 LLVMValueRef err_val;
1829 add_debug_source_node(g, node);
1831 set_debug_source_node(g, node);
18301832 if (handle_is_ptr(expr_type)) {
18311833 LLVMValueRef err_val_ptr = LLVMBuildStructGEP(g->builder, expr_val, 0, "");
18321834 err_val = LLVMBuildLoad(g->builder, err_val_ptr, "");
......@@ -1852,7 +1854,7 @@ static LLVMValueRef gen_unwrap_err_expr(CodeGen *g, AstNode *node) {
18521854 LLVMBuildStore(g->builder, err_val, var->value_ref);
18531855 }
18541856 LLVMValueRef err_result = gen_expr(g, op2);
1855 add_debug_source_node(g, node);
1857 set_debug_source_node(g, node);
18561858 if (have_end_block) {
18571859 LLVMBuildBr(g->builder, end_block);
18581860 } else if (err_reachable) {
......@@ -1927,10 +1929,10 @@ static LLVMValueRef gen_return(CodeGen *g, AstNode *source_node, LLVMValueRef va
19271929 if (handle_is_ptr(return_type)) {
19281930 assert(g->cur_ret_ptr);
19291931 gen_assign_raw(g, source_node, BinOpTypeAssign, g->cur_ret_ptr, value, return_type, return_type);
1930 add_debug_source_node(g, source_node);
1932 set_debug_source_node(g, source_node);
19311933 LLVMBuildRetVoid(g->builder);
19321934 } else {
1933 add_debug_source_node(g, source_node);
1935 set_debug_source_node(g, source_node);
19341936 LLVMBuildRet(g->builder, value);
19351937 }
19361938 return nullptr;
......@@ -1972,7 +1974,7 @@ static LLVMValueRef gen_return_expr(CodeGen *g, AstNode *node) {
19721974 LLVMBasicBlockRef return_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "ErrRetReturn");
19731975 LLVMBasicBlockRef continue_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "ErrRetContinue");
19741976
1975 add_debug_source_node(g, node);
1977 set_debug_source_node(g, node);
19761978 LLVMValueRef err_val;
19771979 if (type_has_bits(child_type)) {
19781980 LLVMValueRef err_val_ptr = LLVMBuildStructGEP(g->builder, value, 0, "");
......@@ -1992,7 +1994,7 @@ static LLVMValueRef gen_return_expr(CodeGen *g, AstNode *node) {
19921994 if (type_has_bits(return_type->data.error.child_type)) {
19931995 assert(g->cur_ret_ptr);
19941996
1995 add_debug_source_node(g, node);
1997 set_debug_source_node(g, node);
19961998 LLVMValueRef tag_ptr = LLVMBuildStructGEP(g->builder, g->cur_ret_ptr, 0, "");
19971999 LLVMBuildStore(g->builder, err_val, tag_ptr);
19982000 LLVMBuildRetVoid(g->builder);
......@@ -2005,7 +2007,7 @@ static LLVMValueRef gen_return_expr(CodeGen *g, AstNode *node) {
20052007
20062008 LLVMPositionBuilderAtEnd(g->builder, continue_block);
20072009 if (type_has_bits(child_type)) {
2008 add_debug_source_node(g, node);
2010 set_debug_source_node(g, node);
20092011 LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, value, 1, "");
20102012 return get_handle_value(g, node, val_ptr, child_type);
20112013 } else {
......@@ -2040,7 +2042,7 @@ static LLVMValueRef gen_if_bool_expr_raw(CodeGen *g, AstNode *source_node, LLVMV
20402042 endif_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "EndIf");
20412043 }
20422044
2043 add_debug_source_node(g, source_node);
2045 set_debug_source_node(g, source_node);
20442046 LLVMBuildCondBr(g->builder, cond_value, then_block, else_block);
20452047
20462048 LLVMPositionBuilderAtEnd(g->builder, then_block);
......@@ -2115,7 +2117,7 @@ static LLVMValueRef gen_if_var_expr(CodeGen *g, AstNode *node) {
21152117 {
21162118 cond_value = LLVMBuildICmp(g->builder, LLVMIntNE, init_val, LLVMConstNull(child_type->type_ref), "");
21172119 } else {
2118 add_debug_source_node(g, node);
2120 set_debug_source_node(g, node);
21192121 LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP(g->builder, init_val, 1, "");
21202122 cond_value = LLVMBuildLoad(g->builder, maybe_field_ptr, "");
21212123 }
......@@ -2271,7 +2273,7 @@ static LLVMValueRef gen_asm_expr(CodeGen *g, AstNode *node) {
22712273 LLVMValueRef asm_fn = LLVMConstInlineAsm(function_type, buf_ptr(&llvm_template),
22722274 buf_ptr(&constraint_buf), is_volatile, false);
22732275
2274 add_debug_source_node(g, node);
2276 set_debug_source_node(g, node);
22752277 return LLVMBuildCall(g->builder, asm_fn, param_values, input_and_output_count, "");
22762278}
22772279
......@@ -2313,7 +2315,7 @@ static LLVMValueRef gen_container_init_expr(CodeGen *g, AstNode *node) {
23132315 }
23142316 assert(buf_eql_buf(type_struct_field->name, &field_node->data.struct_val_field.name));
23152317
2316 add_debug_source_node(g, field_node);
2318 set_debug_source_node(g, field_node);
23172319 LLVMValueRef field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, type_struct_field->gen_index, "");
23182320 AstNode *expr_node = field_node->data.struct_val_field.expr;
23192321 LLVMValueRef value = gen_expr(g, expr_node);
......@@ -2324,7 +2326,7 @@ static LLVMValueRef gen_container_init_expr(CodeGen *g, AstNode *node) {
23242326 return tmp_struct_ptr;
23252327 } else if (type_entry->id == TypeTableEntryIdUnreachable) {
23262328 assert(node->data.container_init_expr.entries.length == 0);
2327 add_debug_source_node(g, node);
2329 set_debug_source_node(g, node);
23282330 if (want_debug_safety(g, node)) {
23292331 LLVMBuildCall(g->builder, g->trap_fn_val, nullptr, 0, "");
23302332 }
......@@ -2350,7 +2352,7 @@ static LLVMValueRef gen_container_init_expr(CodeGen *g, AstNode *node) {
23502352 LLVMConstNull(g->builtin_types.entry_isize->type_ref),
23512353 LLVMConstInt(g->builtin_types.entry_isize->type_ref, i, false),
23522354 };
2353 add_debug_source_node(g, field_node);
2355 set_debug_source_node(g, field_node);
23542356 LLVMValueRef elem_ptr = LLVMBuildInBoundsGEP(g->builder, tmp_array_ptr, indices, 2, "");
23552357 gen_assign_raw(g, field_node, BinOpTypeAssign, elem_ptr, elem_val,
23562358 child_type, get_expr_type(field_node));
......@@ -2382,7 +2384,7 @@ static LLVMValueRef gen_while_expr(CodeGen *g, AstNode *node) {
23822384 end_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "WhileEnd");
23832385 }
23842386
2385 add_debug_source_node(g, node);
2387 set_debug_source_node(g, node);
23862388 LLVMBuildBr(g->builder, body_block);
23872389
23882390 if (continue_expr_node) {
......@@ -2390,7 +2392,7 @@ static LLVMValueRef gen_while_expr(CodeGen *g, AstNode *node) {
23902392
23912393 gen_expr(g, continue_expr_node);
23922394
2393 add_debug_source_node(g, node);
2395 set_debug_source_node(g, node);
23942396 LLVMBuildBr(g->builder, body_block);
23952397 }
23962398
......@@ -2402,7 +2404,7 @@ static LLVMValueRef gen_while_expr(CodeGen *g, AstNode *node) {
24022404 g->continue_block_stack.pop();
24032405
24042406 if (get_expr_type(node->data.while_expr.body)->id != TypeTableEntryIdUnreachable) {
2405 add_debug_source_node(g, node);
2407 set_debug_source_node(g, node);
24062408 LLVMBuildBr(g->builder, continue_block);
24072409 }
24082410
......@@ -2418,7 +2420,7 @@ static LLVMValueRef gen_while_expr(CodeGen *g, AstNode *node) {
24182420 LLVMAppendBasicBlock(g->cur_fn->fn_value, "WhileContinue") : cond_block;
24192421 LLVMBasicBlockRef end_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "WhileEnd");
24202422
2421 add_debug_source_node(g, node);
2423 set_debug_source_node(g, node);
24222424 LLVMBuildBr(g->builder, cond_block);
24232425
24242426 if (continue_expr_node) {
......@@ -2426,13 +2428,13 @@ static LLVMValueRef gen_while_expr(CodeGen *g, AstNode *node) {
24262428
24272429 gen_expr(g, continue_expr_node);
24282430
2429 add_debug_source_node(g, node);
2431 set_debug_source_node(g, node);
24302432 LLVMBuildBr(g->builder, cond_block);
24312433 }
24322434
24332435 LLVMPositionBuilderAtEnd(g->builder, cond_block);
24342436 LLVMValueRef cond_val = gen_expr(g, node->data.while_expr.condition);
2435 add_debug_source_node(g, node->data.while_expr.condition);
2437 set_debug_source_node(g, node->data.while_expr.condition);
24362438 LLVMBuildCondBr(g->builder, cond_val, body_block, end_block);
24372439
24382440 LLVMPositionBuilderAtEnd(g->builder, body_block);
......@@ -2442,7 +2444,7 @@ static LLVMValueRef gen_while_expr(CodeGen *g, AstNode *node) {
24422444 g->break_block_stack.pop();
24432445 g->continue_block_stack.pop();
24442446 if (get_expr_type(node->data.while_expr.body)->id != TypeTableEntryIdUnreachable) {
2445 add_debug_source_node(g, node);
2447 set_debug_source_node(g, node);
24462448 LLVMBuildBr(g->builder, continue_block);
24472449 }
24482450
......@@ -2454,7 +2456,7 @@ static LLVMValueRef gen_while_expr(CodeGen *g, AstNode *node) {
24542456
24552457static void gen_var_debug_decl(CodeGen *g, VariableTableEntry *var) {
24562458 BlockContext *block_context = var->block_context;
2457 AstNode *source_node = block_context->node;
2459 AstNode *source_node = var->decl_node;
24582460 LLVMZigDILocation *debug_loc = LLVMZigGetDebugLoc(source_node->line + 1, source_node->column + 1,
24592461 block_context->di_scope);
24602462 LLVMZigInsertDeclareAtEnd(g->dbuilder, var->value_ref, var->di_loc_var, debug_loc,
......@@ -2482,7 +2484,7 @@ static LLVMValueRef gen_for_expr(CodeGen *g, AstNode *node) {
24822484 LLVMBasicBlockRef continue_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "ForContinue");
24832485
24842486 LLVMValueRef array_val = gen_array_base_ptr(g, node->data.for_expr.array_expr);
2485 add_debug_source_node(g, node);
2487 set_debug_source_node(g, node);
24862488 LLVMBuildStore(g->builder, LLVMConstNull(index_var->type->type_ref), index_ptr);
24872489
24882490 gen_var_debug_decl(g, index_var);
......@@ -2529,12 +2531,12 @@ static LLVMValueRef gen_for_expr(CodeGen *g, AstNode *node) {
25292531 g->break_block_stack.pop();
25302532 g->continue_block_stack.pop();
25312533 if (get_expr_type(node->data.for_expr.body)->id != TypeTableEntryIdUnreachable) {
2532 add_debug_source_node(g, node);
2534 set_debug_source_node(g, node);
25332535 LLVMBuildBr(g->builder, continue_block);
25342536 }
25352537
25362538 LLVMPositionBuilderAtEnd(g->builder, continue_block);
2537 add_debug_source_node(g, node);
2539 set_debug_source_node(g, node);
25382540 LLVMValueRef new_index_val = LLVMBuildAdd(g->builder, index_val, one_const, "");
25392541 LLVMBuildStore(g->builder, new_index_val, index_ptr);
25402542 LLVMBuildBr(g->builder, cond_block);
......@@ -2547,7 +2549,7 @@ static LLVMValueRef gen_break(CodeGen *g, AstNode *node) {
25472549 assert(node->type == NodeTypeBreak);
25482550 LLVMBasicBlockRef dest_block = g->break_block_stack.last();
25492551
2550 add_debug_source_node(g, node);
2552 set_debug_source_node(g, node);
25512553 return LLVMBuildBr(g->builder, dest_block);
25522554}
25532555
......@@ -2555,7 +2557,7 @@ static LLVMValueRef gen_continue(CodeGen *g, AstNode *node) {
25552557 assert(node->type == NodeTypeContinue);
25562558 LLVMBasicBlockRef dest_block = g->continue_block_stack.last();
25572559
2558 add_debug_source_node(g, node);
2560 set_debug_source_node(g, node);
25592561 return LLVMBuildBr(g->builder, dest_block);
25602562}
25612563
......@@ -2565,7 +2567,6 @@ static LLVMValueRef gen_var_decl_raw(CodeGen *g, AstNode *source_node, AstNodeVa
25652567 VariableTableEntry *variable = var_decl->variable;
25662568
25672569 assert(variable);
2568 assert(variable->is_ptr);
25692570
25702571 if (var_decl->expr) {
25712572 *init_value = gen_expr(g, var_decl->expr);
......@@ -2614,7 +2615,7 @@ static LLVMValueRef gen_var_decl_raw(CodeGen *g, AstNode *source_node, AstNodeVa
26142615
26152616 LLVMValueRef size_val = gen_expr(g, size_node);
26162617
2617 add_debug_source_node(g, source_node);
2618 set_debug_source_node(g, source_node);
26182619 LLVMValueRef ptr_val = LLVMBuildArrayAlloca(g->builder, child_type->type_ref,
26192620 size_val, "");
26202621
......@@ -2645,7 +2646,7 @@ static LLVMValueRef gen_var_decl_raw(CodeGen *g, AstNode *source_node, AstNodeVa
26452646 uint64_t align_bytes = get_memcpy_align(g, variable->type);
26462647
26472648 // memset uninitialized memory to 0xa
2648 add_debug_source_node(g, source_node);
2649 set_debug_source_node(g, source_node);
26492650 LLVMTypeRef ptr_u8 = LLVMPointerType(LLVMInt8Type(), 0);
26502651 LLVMValueRef fill_char = LLVMConstInt(LLVMInt8Type(), 0xaa, false);
26512652 LLVMValueRef dest_ptr = LLVMBuildBitCast(g->builder, variable->value_ref, ptr_u8, "");
......@@ -2708,11 +2709,11 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
27082709 LLVMValueRef target_value;
27092710 if (handle_is_ptr(target_type)) {
27102711 if (target_type->id == TypeTableEntryIdEnum) {
2711 add_debug_source_node(g, node);
2712 set_debug_source_node(g, node);
27122713 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP(g->builder, target_value_handle, 0, "");
27132714 target_value = LLVMBuildLoad(g->builder, tag_field_ptr, "");
27142715 } else if (target_type->id == TypeTableEntryIdErrorUnion) {
2715 add_debug_source_node(g, node);
2716 set_debug_source_node(g, node);
27162717 LLVMValueRef tag_field_ptr = LLVMBuildStructGEP(g->builder, target_value_handle, 0, "");
27172718 target_value = LLVMBuildLoad(g->builder, tag_field_ptr, "");
27182719 } else {
......@@ -2732,7 +2733,7 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
27322733 LLVMBasicBlockRef else_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "SwitchElse");
27332734 int prong_count = node->data.switch_expr.prongs.length;
27342735
2735 add_debug_source_node(g, node);
2736 set_debug_source_node(g, node);
27362737 LLVMValueRef switch_instr = LLVMBuildSwitch(g->builder, target_value, else_block, prong_count);
27372738
27382739 ZigList<LLVMValueRef> incoming_values = {0};
......@@ -2789,7 +2790,7 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
27892790 }
27902791
27912792 AstNode *var_node = prong_node->data.switch_prong.var_symbol;
2792 add_debug_source_node(g, var_node);
2793 set_debug_source_node(g, var_node);
27932794 if (prong_node->data.switch_prong.var_is_target_expr) {
27942795 gen_assign_raw(g, var_node, BinOpTypeAssign,
27952796 prong_var->value_ref, target_value, prong_var->type, target_type);
......@@ -2844,7 +2845,7 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
28442845 LLVMValueRef prong_val = gen_expr(g, prong_expr);
28452846
28462847 if (get_expr_type(prong_expr)->id != TypeTableEntryIdUnreachable) {
2847 add_debug_source_node(g, prong_expr);
2848 set_debug_source_node(g, prong_expr);
28482849 LLVMBuildBr(g->builder, end_block);
28492850 incoming_values.append(prong_val);
28502851 incoming_blocks.append(prong_block);
......@@ -2853,7 +2854,7 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
28532854
28542855 if (!else_prong) {
28552856 LLVMPositionBuilderAtEnd(g->builder, else_block);
2856 add_debug_source_node(g, node);
2857 set_debug_source_node(g, node);
28572858 if (want_debug_safety(g, node)) {
28582859 LLVMBuildCall(g->builder, g->trap_fn_val, nullptr, 0, "");
28592860 }
......@@ -2867,7 +2868,7 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
28672868 LLVMPositionBuilderAtEnd(g->builder, end_block);
28682869
28692870 if (result_has_bits) {
2870 add_debug_source_node(g, node);
2871 set_debug_source_node(g, node);
28712872 LLVMValueRef phi = LLVMBuildPhi(g->builder, LLVMTypeOf(incoming_values.at(0)), "");
28722873 LLVMAddIncoming(phi, incoming_values.items, incoming_blocks.items, incoming_values.length);
28732874 return phi;
......@@ -2885,7 +2886,7 @@ static LLVMValueRef gen_goto(CodeGen *g, AstNode *node) {
28852886 BlockContext *target_context = label->decl_node->block_context;
28862887 gen_defers_for_block(g, this_context, target_context, false, false);
28872888
2888 add_debug_source_node(g, node);
2889 set_debug_source_node(g, node);
28892890 LLVMBuildBr(g->builder, node->data.goto_expr.label_entry->basic_block);
28902891 return nullptr;
28912892}
......@@ -2898,7 +2899,7 @@ static LLVMValueRef gen_label(CodeGen *g, AstNode *node) {
28982899
28992900 LLVMBasicBlockRef basic_block = label->basic_block;
29002901 if (label->entered_from_fallthrough) {
2901 add_debug_source_node(g, node);
2902 set_debug_source_node(g, node);
29022903 LLVMBuildBr(g->builder, basic_block);
29032904 }
29042905 LLVMPositionBuilderAtEnd(g->builder, basic_block);
......@@ -3519,6 +3520,23 @@ static void do_code_gen(CodeGen *g) {
35193520
35203521 }
35213522
3523 clear_debug_source_node(g);
3524
3525 // allocate structs which are the result of casts
3526 for (int cea_i = 0; cea_i < fn_table_entry->cast_alloca_list.length; cea_i += 1) {
3527 AstNode *fn_call_node = fn_table_entry->cast_alloca_list.at(cea_i);
3528 Expr *expr = &fn_call_node->data.fn_call_expr.resolved_expr;
3529 fn_call_node->data.fn_call_expr.tmp_ptr = LLVMBuildAlloca(g->builder,
3530 expr->type_entry->type_ref, "");
3531 }
3532
3533 // allocate structs which are struct value expressions
3534 for (int alloca_i = 0; alloca_i < fn_table_entry->struct_val_expr_alloca_list.length; alloca_i += 1) {
3535 StructValExprCodeGen *struct_val_expr_node = fn_table_entry->struct_val_expr_alloca_list.at(alloca_i);
3536 struct_val_expr_node->ptr = LLVMBuildAlloca(g->builder,
3537 struct_val_expr_node->type_entry->type_ref, "");
3538 }
3539
35223540 // create debug variable declarations for variables and allocate all local variables
35233541 for (int var_i = 0; var_i < fn_table_entry->variable_list.length; var_i += 1) {
35243542 VariableTableEntry *var = fn_table_entry->variable_list.at(var_i);
......@@ -3527,29 +3545,32 @@ static void do_code_gen(CodeGen *g) {
35273545 continue;
35283546 }
35293547
3530 TypeTableEntry *gen_type;
35313548 if (var->block_context->node->type == NodeTypeFnDef) {
3532 var->is_ptr = false;
35333549 assert(var->gen_arg_index >= 0);
3534 var->value_ref = LLVMGetParam(fn, var->gen_arg_index);
3535
3536 gen_type = fn_table_entry->type_entry->data.fn.gen_param_info[var->src_arg_index].type;
3550 if (handle_is_ptr(var->type)) {
3551 TypeTableEntry *gen_type = fn_table_entry->type_entry->data.fn.gen_param_info[var->src_arg_index].type;
3552 var->value_ref = LLVMGetParam(fn, var->gen_arg_index);
3553 var->di_loc_var = LLVMZigCreateParameterVariable(g->dbuilder, var->block_context->di_scope,
3554 buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
3555 gen_type->di_type, !g->strip_debug_symbols, 0, var->gen_arg_index + 1);
3556 } else {
3557 var->value_ref = LLVMBuildAlloca(g->builder, var->type->type_ref, buf_ptr(&var->name));
3558 uint64_t align_bytes = LLVMABISizeOfType(g->target_data_ref, var->type->type_ref);
3559 LLVMSetAlignment(var->value_ref, align_bytes);
3560 var->di_loc_var = LLVMZigCreateAutoVariable(g->dbuilder, var->block_context->di_scope,
3561 buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
3562 var->type->di_type, !g->strip_debug_symbols, 0);
3563 }
35373564
3538 var->di_loc_var = LLVMZigCreateParameterVariable(g->dbuilder, var->block_context->di_scope,
3539 buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
3540 gen_type->di_type, !g->strip_debug_symbols, 0, var->gen_arg_index + 1);
35413565 } else {
3542
3543 add_debug_source_node(g, var->decl_node);
35443566 var->value_ref = LLVMBuildAlloca(g->builder, var->type->type_ref, buf_ptr(&var->name));
3567
35453568 uint64_t align_bytes = LLVMABISizeOfType(g->target_data_ref, var->type->type_ref);
35463569 LLVMSetAlignment(var->value_ref, align_bytes);
35473570
3548 gen_type = var->type;
3549
35503571 var->di_loc_var = LLVMZigCreateAutoVariable(g->dbuilder, var->block_context->di_scope,
35513572 buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
3552 gen_type->di_type, !g->strip_debug_symbols, 0);
3573 var->type->di_type, !g->strip_debug_symbols, 0);
35533574 }
35543575 }
35553576
......@@ -3567,25 +3588,14 @@ static void do_code_gen(CodeGen *g) {
35673588 VariableTableEntry *variable = param_decl->data.param_decl.variable;
35683589 assert(variable);
35693590
3570 gen_var_debug_decl(g, variable);
3571 }
3591 if (!handle_is_ptr(variable->type)) {
3592 clear_debug_source_node(g);
3593 LLVMBuildStore(g->builder, LLVMGetParam(fn, variable->gen_arg_index), variable->value_ref);
3594 }
35723595
3573 // allocate structs which are the result of casts
3574 for (int cea_i = 0; cea_i < fn_table_entry->cast_alloca_list.length; cea_i += 1) {
3575 AstNode *fn_call_node = fn_table_entry->cast_alloca_list.at(cea_i);
3576 add_debug_source_node(g, fn_call_node);
3577 Expr *expr = &fn_call_node->data.fn_call_expr.resolved_expr;
3578 fn_call_node->data.fn_call_expr.tmp_ptr = LLVMBuildAlloca(g->builder,
3579 expr->type_entry->type_ref, "");
3596 gen_var_debug_decl(g, variable);
35803597 }
35813598
3582 // allocate structs which are struct value expressions
3583 for (int alloca_i = 0; alloca_i < fn_table_entry->struct_val_expr_alloca_list.length; alloca_i += 1) {
3584 StructValExprCodeGen *struct_val_expr_node = fn_table_entry->struct_val_expr_alloca_list.at(alloca_i);
3585 add_debug_source_node(g, struct_val_expr_node->source_node);
3586 struct_val_expr_node->ptr = LLVMBuildAlloca(g->builder,
3587 struct_val_expr_node->type_entry->type_ref, "");
3588 }
35893599
35903600 TypeTableEntry *implicit_return_type = fn_def_node->data.fn_def.implicit_return_type;
35913601 gen_block(g, fn_def_node->data.fn_def.body, implicit_return_type);
src/zig_llvm.cpp+20-1
......@@ -369,11 +369,15 @@ LLVMZigDIBuilder *LLVMZigCreateDIBuilder(LLVMModuleRef module, bool allow_unreso
369369 return reinterpret_cast<LLVMZigDIBuilder *>(di_builder);
370370}
371371
372void LLVMZigSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, LLVMZigDIScope *scope) {
372void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, LLVMZigDIScope *scope) {
373373 unwrap(builder)->SetCurrentDebugLocation(DebugLoc::get(
374374 line, column, reinterpret_cast<DIScope*>(scope)));
375375}
376376
377void ZigLLVMClearCurrentDebugLocation(LLVMBuilderRef builder) {
378 unwrap(builder)->SetCurrentDebugLocation(DebugLoc());
379}
380
377381
378382LLVMZigDILexicalBlock *LLVMZigCreateLexicalBlock(LLVMZigDIBuilder *dbuilder, LLVMZigDIScope *scope,
379383 LLVMZigDIFile *file, unsigned line, unsigned col)
......@@ -530,6 +534,21 @@ void LLVMZigSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state) {
530534 }
531535}
532536
537void ZigLLVMAddFunctionAttr(LLVMValueRef fn_ref, const char *attr_name, const char *attr_value) {
538 Function *func = unwrap<Function>(fn_ref);
539 const AttributeSet attr_set = func->getAttributes();
540 AttrBuilder attr_builder;
541 if (attr_value) {
542 attr_builder.addAttribute(attr_name, attr_value);
543 } else {
544 attr_builder.addAttribute(attr_name);
545 }
546 const AttributeSet new_attr_set = attr_set.addAttributes(func->getContext(),
547 AttributeSet::FunctionIndex, AttributeSet::get(func->getContext(),
548 AttributeSet::FunctionIndex, attr_builder));
549 func->setAttributes(new_attr_set);
550}
551
533552
534553static_assert((Triple::ArchType)ZigLLVM_LastArchType == Triple::LastArchType, "");
535554static_assert((Triple::VendorType)ZigLLVM_LastVendorType == Triple::LastVendorType, "");
src/zig_llvm.hpp+4-1
......@@ -102,7 +102,8 @@ unsigned LLVMZigTag_DW_structure_type(void);
102102LLVMZigDIBuilder *LLVMZigCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved);
103103void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module);
104104
105void LLVMZigSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, LLVMZigDIScope *scope);
105void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, LLVMZigDIScope *scope);
106void ZigLLVMClearCurrentDebugLocation(LLVMBuilderRef builder);
106107
107108LLVMZigDIScope *LLVMZigLexicalBlockToScope(LLVMZigDILexicalBlock *lexical_block);
108109LLVMZigDIScope *LLVMZigCompileUnitToScope(LLVMZigDICompileUnit *compile_unit);
......@@ -149,6 +150,8 @@ LLVMZigDILocation *LLVMZigGetDebugLoc(unsigned line, unsigned col, LLVMZigDIScop
149150
150151void LLVMZigSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state);
151152
153void ZigLLVMAddFunctionAttr(LLVMValueRef fn, const char *attr_name, const char *attr_value);
154
152155
153156// copied from include/llvm/ADT/Triple.h
154157
std/compiler_rt.zig+5-3
......@@ -8,16 +8,17 @@ const udwords = [2]su_int;
88const low = if (@compile_var("is_big_endian")) 1 else 0;
99const high = 1 - low;
1010
11#debug_safety(false)
1112export fn __udivdi3(a: du_int, b: du_int) -> du_int {
1213 return __udivmoddi4(a, b, null);
1314}
1415
16#debug_safety(false)
1517fn du_int_to_udwords(x: du_int) -> udwords {
16 // TODO ability to take address of params
17 const x2 = x;
18 return *(&udwords)(&x2);
18 return *(&udwords)(&x);
1919}
2020
21#debug_safety(false)
2122export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {
2223 const n_uword_bits = @sizeof(su_int) * CHAR_BIT;
2324 const n_udword_bits = @sizeof(du_int) * CHAR_BIT;
......@@ -214,6 +215,7 @@ export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {
214215 return *(&du_int)(&q[0]);
215216}
216217
218#debug_safety(false)
217219export fn __umoddi3(a: du_int, b: du_int) -> du_int {
218220 var r: du_int = undefined;
219221 __udivmoddi4(a, b, &r);
std/math.zig+2-4
......@@ -1,11 +1,9 @@
11pub fn f64_from_bits(bits: u64) -> f64 {
2 const bits2 = bits;
3 *(&f64)(&bits2)
2 *(&f64)(&bits)
43}
54
65pub fn f64_to_bits(f: f64) -> u64 {
7 const f2 = f;
8 *(&u64)(&f2)
6 *(&u64)(&f)
97}
108
119pub fn f64_get_pos_inf() -> f64 {
test/self_hosted.zig+16
......@@ -1376,3 +1376,19 @@ fn bool_cmp() {
13761376}
13771377#static_eval_enable(false)
13781378fn test_bool_cmp(a: bool, b: bool) -> bool { a == b }
1379
1380
1381#attribute("test")
1382fn take_address_of_parameter() {
1383 test_take_address_of_parameter(12.34);
1384 test_take_address_of_parameter_noeval(12.34);
1385}
1386fn test_take_address_of_parameter(f: f32) {
1387 const f_ptr = &f;
1388 assert(*f_ptr == 12.34);
1389}
1390#static_eval_enable(false)
1391fn test_take_address_of_parameter_noeval(f: f32) {
1392 const f_ptr = &f;
1393 assert(*f_ptr == 12.34);
1394}