authorgravatar for alex_naskos@hotmail.comAlexandros Naskos <alex_naskos@hotmail.com> 2020-06-24 14:07:39+03:00
committergravatar for alex_naskos@hotmail.comAlexandros Naskos <alex_naskos@hotmail.com> 2020-06-24 14:07:39+03:00
log50b70bd77f31bba6ffca33b6acb90186e739118e
tree394812dc9470edfd9b261473262156e264284527
parent3aab6012c471522e2d1cd5a456f56cb9a7addeb6

@asyncCall now requires an argument tuple

6 files changed, 208 insertions(+), 87 deletions(-)

lib/std/dwarf.zig+1-1
......@@ -359,7 +359,7 @@ fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, endia
359359 const F = @TypeOf(async parseFormValue(allocator, in_stream, child_form_id, endian, is_64));
360360 var frame = try allocator.create(F);
361361 defer allocator.destroy(frame);
362 return await @asyncCall(frame, {}, parseFormValue, allocator, in_stream, child_form_id, endian, is_64);
362 return await @asyncCall(frame, {}, parseFormValue, .{ allocator, in_stream, child_form_id, endian, is_64 });
363363 },
364364 else => error.InvalidDebugInfo,
365365 };
lib/std/special/test_runner.zig+1-1
......@@ -35,7 +35,7 @@ pub fn main() anyerror!void {
3535 async_frame_buffer = try std.heap.page_allocator.alignedAlloc(u8, std.Target.stack_align, size);
3636 }
3737 const casted_fn = @ptrCast(fn () callconv(.Async) anyerror!void, test_fn.func);
38 break :blk await @asyncCall(async_frame_buffer, {}, casted_fn);
38 break :blk await @asyncCall(async_frame_buffer, {}, casted_fn, .{});
3939 },
4040 .blocking => {
4141 skip_count += 1;
lib/std/start.zig+1-1
......@@ -214,7 +214,7 @@ inline fn initEventLoopAndCallMain() u8 {
214214
215215 var result: u8 = undefined;
216216 var frame: @Frame(callMainAsync) = undefined;
217 _ = @asyncCall(&frame, &result, callMainAsync, loop);
217 _ = @asyncCall(&frame, &result, callMainAsync, .{loop});
218218 loop.run();
219219 return result;
220220 }
src/all_types.hpp+15
......@@ -2641,6 +2641,7 @@ enum IrInstSrcId {
26412641 IrInstSrcIdCall,
26422642 IrInstSrcIdCallArgs,
26432643 IrInstSrcIdCallExtra,
2644 IrInstSrcIdAsyncCallExtra,
26442645 IrInstSrcIdConst,
26452646 IrInstSrcIdReturn,
26462647 IrInstSrcIdContainerInitList,
......@@ -3255,6 +3256,20 @@ struct IrInstSrcCallExtra {
32553256 ResultLoc *result_loc;
32563257};
32573258
3259// This is a pass1 instruction, used by @asyncCall, when the args node
3260// is not a literal.
3261// `args` is expected to be either a struct or a tuple.
3262struct IrInstSrcAsyncCallExtra {
3263 IrInstSrc base;
3264
3265 CallModifier modifier;
3266 IrInstSrc *fn_ref;
3267 IrInstSrc *ret_ptr;
3268 IrInstSrc *new_stack;
3269 IrInstSrc *args;
3270 ResultLoc *result_loc;
3271};
3272
32583273struct IrInstGenCall {
32593274 IrInstGen base;
32603275
src/ir.cpp+135-30
......@@ -310,6 +310,8 @@ static void destroy_instruction_src(IrInstSrc *inst) {
310310 return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCall *>(inst));
311311 case IrInstSrcIdCallExtra:
312312 return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCallExtra *>(inst));
313 case IrInstSrcIdAsyncCallExtra:
314 return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAsyncCallExtra *>(inst));
313315 case IrInstSrcIdUnOp:
314316 return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcUnOp *>(inst));
315317 case IrInstSrcIdCondBr:
......@@ -1173,6 +1175,10 @@ static constexpr IrInstSrcId ir_inst_id(IrInstSrcCallExtra *) {
11731175 return IrInstSrcIdCallExtra;
11741176}
11751177
1178static constexpr IrInstSrcId ir_inst_id(IrInstSrcAsyncCallExtra *) {
1179 return IrInstSrcIdAsyncCallExtra;
1180}
1181
11761182static constexpr IrInstSrcId ir_inst_id(IrInstSrcConst *) {
11771183 return IrInstSrcIdConst;
11781184}
......@@ -2442,6 +2448,25 @@ static IrInstSrc *ir_build_call_extra(IrBuilderSrc *irb, Scope *scope, AstNode *
24422448 return &call_instruction->base;
24432449}
24442450
2451static IrInstSrc *ir_build_async_call_extra(IrBuilderSrc *irb, Scope *scope, AstNode *source_node,
2452 CallModifier modifier, IrInstSrc *fn_ref, IrInstSrc *ret_ptr, IrInstSrc *new_stack, IrInstSrc *args, ResultLoc *result_loc)
2453{
2454 IrInstSrcAsyncCallExtra *call_instruction = ir_build_instruction<IrInstSrcAsyncCallExtra>(irb, scope, source_node);
2455 call_instruction->modifier = modifier;
2456 call_instruction->fn_ref = fn_ref;
2457 call_instruction->ret_ptr = ret_ptr;
2458 call_instruction->new_stack = new_stack;
2459 call_instruction->args = args;
2460 call_instruction->result_loc = result_loc;
2461
2462 ir_ref_instruction(fn_ref, irb->current_basic_block);
2463 if (ret_ptr != nullptr) ir_ref_instruction(ret_ptr, irb->current_basic_block);
2464 ir_ref_instruction(new_stack, irb->current_basic_block);
2465 ir_ref_instruction(args, irb->current_basic_block);
2466
2467 return &call_instruction->base;
2468}
2469
24452470static IrInstSrc *ir_build_call_args(IrBuilderSrc *irb, Scope *scope, AstNode *source_node,
24462471 IrInstSrc *options, IrInstSrc *fn_ref, IrInstSrc **args_ptr, size_t args_len,
24472472 ResultLoc *result_loc)
......@@ -6183,11 +6208,10 @@ static IrInstSrc *ir_gen_this(IrBuilderSrc *irb, Scope *orig_scope, AstNode *nod
61836208static IrInstSrc *ir_gen_async_call(IrBuilderSrc *irb, Scope *scope, AstNode *await_node, AstNode *call_node,
61846209 LVal lval, ResultLoc *result_loc)
61856210{
6186 size_t arg_offset = 3;
6187 if (call_node->data.fn_call_expr.params.length < arg_offset) {
6211 if (call_node->data.fn_call_expr.params.length != 4) {
61886212 add_node_error(irb->codegen, call_node,
6189 buf_sprintf("expected at least %" ZIG_PRI_usize " arguments, found %" ZIG_PRI_usize,
6190 arg_offset, call_node->data.fn_call_expr.params.length));
6213 buf_sprintf("expected 4 arguments, found %" ZIG_PRI_usize,
6214 call_node->data.fn_call_expr.params.length));
61916215 return irb->codegen->invalid_inst_src;
61926216 }
61936217
......@@ -6206,20 +6230,37 @@ static IrInstSrc *ir_gen_async_call(IrBuilderSrc *irb, Scope *scope, AstNode *aw
62066230 if (fn_ref == irb->codegen->invalid_inst_src)
62076231 return fn_ref;
62086232
6209 size_t arg_count = call_node->data.fn_call_expr.params.length - arg_offset;
6210 IrInstSrc **args = heap::c_allocator.allocate<IrInstSrc*>(arg_count);
6211 for (size_t i = 0; i < arg_count; i += 1) {
6212 AstNode *arg_node = call_node->data.fn_call_expr.params.at(i + arg_offset);
6213 IrInstSrc *arg = ir_gen_node(irb, arg_node, scope);
6214 if (arg == irb->codegen->invalid_inst_src)
6215 return arg;
6216 args[i] = arg;
6217 }
6218
62196233 CallModifier modifier = (await_node == nullptr) ? CallModifierAsync : CallModifierNone;
62206234 bool is_async_call_builtin = true;
6221 IrInstSrc *call = ir_build_call_src(irb, scope, call_node, nullptr, fn_ref, arg_count, args,
6222 ret_ptr, modifier, is_async_call_builtin, bytes, result_loc);
6235 AstNode *args_node = call_node->data.fn_call_expr.params.at(3);
6236 if (args_node->type == NodeTypeContainerInitExpr) {
6237 if (args_node->data.container_init_expr.kind == ContainerInitKindArray ||
6238 args_node->data.container_init_expr.entries.length == 0)
6239 {
6240 size_t arg_count = args_node->data.container_init_expr.entries.length;
6241 IrInstSrc **args = heap::c_allocator.allocate<IrInstSrc*>(arg_count);
6242 for (size_t i = 0; i < arg_count; i += 1) {
6243 AstNode *arg_node = args_node->data.container_init_expr.entries.at(i);
6244 IrInstSrc *arg = ir_gen_node(irb, arg_node, scope);
6245 if (arg == irb->codegen->invalid_inst_src)
6246 return arg;
6247 args[i] = arg;
6248 }
6249
6250 IrInstSrc *call = ir_build_call_src(irb, scope, call_node, nullptr, fn_ref, arg_count, args,
6251 ret_ptr, modifier, is_async_call_builtin, bytes, result_loc);
6252 return ir_lval_wrap(irb, scope, call, lval, result_loc);
6253 } else {
6254 exec_add_error_node(irb->codegen, irb->exec, args_node,
6255 buf_sprintf("TODO: @asyncCall with anon struct literal"));
6256 return irb->codegen->invalid_inst_src;
6257 }
6258 }
6259 IrInstSrc *args = ir_gen_node(irb, args_node, scope);
6260 if (args == irb->codegen->invalid_inst_src)
6261 return args;
6262
6263 IrInstSrc *call = ir_build_async_call_extra(irb, scope, call_node, modifier, fn_ref, bytes, ret_ptr, args, result_loc);
62236264 return ir_lval_wrap(irb, scope, call, lval, result_loc);
62246265}
62256266
......@@ -20236,7 +20277,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
2023620277 // Fork a scope of the function with known values for the parameters.
2023720278 Scope *parent_scope = fn_entry->fndef_scope->base.parent;
2023820279 ZigFn *impl_fn = create_fn(ira->codegen, fn_proto_node);
20239 impl_fn->param_source_nodes = heap::c_allocator.allocate<AstNode *>(new_fn_arg_count);
20280
2024020281 buf_init_from_buf(&impl_fn->symbol_name, &fn_entry->symbol_name);
2024120282 impl_fn->fndef_scope = create_fndef_scope(ira->codegen, impl_fn->body_node, parent_scope, impl_fn);
2024220283 impl_fn->child_scope = &impl_fn->fndef_scope->base;
......@@ -20719,40 +20760,101 @@ static IrInstGen *ir_analyze_call_extra(IrAnalyze *ira, IrInst* source_instr,
2071920760 modifier, stack, stack_src, false, args_ptr, args_len, nullptr, result_loc);
2072020761}
2072120762
20722static IrInstGen *ir_analyze_instruction_call_extra(IrAnalyze *ira, IrInstSrcCallExtra *instruction) {
20723 IrInstGen *args = instruction->args->child;
20763static IrInstGen *ir_analyze_async_call_extra(IrAnalyze *ira, IrInst* source_instr, CallModifier modifier,
20764 IrInstSrc *pass1_fn_ref, IrInstSrc *ret_ptr, IrInstSrc *new_stack, IrInstGen **args_ptr, size_t args_len, ResultLoc *result_loc)
20765{
20766 IrInstGen *fn_ref = pass1_fn_ref->child;
20767 if (type_is_invalid(fn_ref->value->type))
20768 return ira->codegen->invalid_inst_gen;
20769
20770 if (ir_should_inline(ira->old_irb.exec, source_instr->scope)) {
20771 ir_add_error(ira, source_instr, buf_sprintf("TODO: comptime @asyncCall"));
20772 return ira->codegen->invalid_inst_gen;
20773 }
20774
20775 ZigFn *fn = nullptr;
20776 if (instr_is_comptime(fn_ref)) {
20777 if (fn_ref->value->type->id == ZigTypeIdBoundFn) {
20778 assert(fn_ref->value->special == ConstValSpecialStatic);
20779 fn = fn_ref->value->data.x_bound_fn.fn;
20780 } else {
20781 fn = ir_resolve_fn(ira, fn_ref);
20782 }
20783 }
20784
20785 IrInstGen *ret_ptr_uncasted = nullptr;
20786 if (ret_ptr != nullptr) {
20787 ret_ptr_uncasted = ret_ptr->child;
20788 if (type_is_invalid(ret_ptr_uncasted->value->type))
20789 return ira->codegen->invalid_inst_gen;
20790 }
20791
20792 ZigType *fn_type = (fn != nullptr) ? fn->type_entry : fn_ref->value->type;
20793 IrInstGen *casted_new_stack = analyze_casted_new_stack(ira, source_instr, new_stack->child,
20794 &new_stack->base, true, fn);
20795 if (casted_new_stack != nullptr && type_is_invalid(casted_new_stack->value->type))
20796 return ira->codegen->invalid_inst_gen;
20797
20798 IrInstGen *result = ir_analyze_async_call(ira, source_instr, fn, fn_type, fn_ref, args_ptr, args_len,
20799 casted_new_stack, true, ret_ptr_uncasted, result_loc);
20800 return ir_finish_anal(ira, result);
20801}
20802
20803static bool ir_extract_tuple_call_args(IrAnalyze *ira, IrInst *source_instr, IrInstGen *args, IrInstGen ***args_ptr, size_t *args_len) {
2072420804 ZigType *args_type = args->value->type;
2072520805 if (type_is_invalid(args_type))
20726 return ira->codegen->invalid_inst_gen;
20806 return false;
2072720807
2072820808 if (args_type->id != ZigTypeIdStruct) {
2072920809 ir_add_error(ira, &args->base,
2073020810 buf_sprintf("expected tuple or struct, found '%s'", buf_ptr(&args_type->name)));
20731 return ira->codegen->invalid_inst_gen;
20811 return false;
2073220812 }
2073320813
20734 IrInstGen **args_ptr = nullptr;
20735 size_t args_len = 0;
20736
2073720814 if (is_tuple(args_type)) {
20738 args_len = args_type->data.structure.src_field_count;
20739 args_ptr = heap::c_allocator.allocate<IrInstGen *>(args_len);
20740 for (size_t i = 0; i < args_len; i += 1) {
20815 *args_len = args_type->data.structure.src_field_count;
20816 *args_ptr = heap::c_allocator.allocate<IrInstGen *>(*args_len);
20817 for (size_t i = 0; i < *args_len; i += 1) {
2074120818 TypeStructField *arg_field = args_type->data.structure.fields[i];
20742 args_ptr[i] = ir_analyze_struct_value_field_value(ira, &instruction->base.base, args, arg_field);
20743 if (type_is_invalid(args_ptr[i]->value->type))
20744 return ira->codegen->invalid_inst_gen;
20819 (*args_ptr)[i] = ir_analyze_struct_value_field_value(ira, source_instr, args, arg_field);
20820 if (type_is_invalid((*args_ptr)[i]->value->type))
20821 return false;
2074520822 }
2074620823 } else {
2074720824 ir_add_error(ira, &args->base, buf_sprintf("TODO: struct args"));
20825 return false;
20826 }
20827 return true;
20828}
20829
20830static IrInstGen *ir_analyze_instruction_call_extra(IrAnalyze *ira, IrInstSrcCallExtra *instruction) {
20831 IrInstGen *args = instruction->args->child;
20832 IrInstGen **args_ptr = nullptr;
20833 size_t args_len = 0;
20834 if (!ir_extract_tuple_call_args(ira, &instruction->base.base, args, &args_ptr, &args_len)) {
2074820835 return ira->codegen->invalid_inst_gen;
2074920836 }
20837
2075020838 IrInstGen *result = ir_analyze_call_extra(ira, &instruction->base.base, instruction->options,
2075120839 instruction->fn_ref, args_ptr, args_len, instruction->result_loc);
2075220840 heap::c_allocator.deallocate(args_ptr, args_len);
2075320841 return result;
2075420842}
2075520843
20844static IrInstGen *ir_analyze_instruction_async_call_extra(IrAnalyze *ira, IrInstSrcAsyncCallExtra *instruction) {
20845 IrInstGen *args = instruction->args->child;
20846 IrInstGen **args_ptr = nullptr;
20847 size_t args_len = 0;
20848 if (!ir_extract_tuple_call_args(ira, &instruction->base.base, args, &args_ptr, &args_len)) {
20849 return ira->codegen->invalid_inst_gen;
20850 }
20851
20852 IrInstGen *result = ir_analyze_async_call_extra(ira, &instruction->base.base, instruction->modifier,
20853 instruction->fn_ref, instruction->ret_ptr, instruction->new_stack, args_ptr, args_len, instruction->result_loc);
20854 heap::c_allocator.deallocate(args_ptr, args_len);
20855 return result;
20856}
20857
2075620858static IrInstGen *ir_analyze_instruction_call_args(IrAnalyze *ira, IrInstSrcCallArgs *instruction) {
2075720859 IrInstGen **args_ptr = heap::c_allocator.allocate<IrInstGen *>(instruction->args_len);
2075820860 for (size_t i = 0; i < instruction->args_len; i += 1) {
......@@ -31101,6 +31203,8 @@ static IrInstGen *ir_analyze_instruction_base(IrAnalyze *ira, IrInstSrc *instruc
3110131203 return ir_analyze_instruction_call_args(ira, (IrInstSrcCallArgs *)instruction);
3110231204 case IrInstSrcIdCallExtra:
3110331205 return ir_analyze_instruction_call_extra(ira, (IrInstSrcCallExtra *)instruction);
31206 case IrInstSrcIdAsyncCallExtra:
31207 return ir_analyze_instruction_async_call_extra(ira, (IrInstSrcAsyncCallExtra *)instruction);
3110431208 case IrInstSrcIdBr:
3110531209 return ir_analyze_instruction_br(ira, (IrInstSrcBr *)instruction);
3110631210 case IrInstSrcIdCondBr:
......@@ -31610,6 +31714,7 @@ bool ir_inst_src_has_side_effects(IrInstSrc *instruction) {
3161031714 case IrInstSrcIdDeclVar:
3161131715 case IrInstSrcIdStorePtr:
3161231716 case IrInstSrcIdCallExtra:
31717 case IrInstSrcIdAsyncCallExtra:
3161331718 case IrInstSrcIdCall:
3161431719 case IrInstSrcIdCallArgs:
3161531720 case IrInstSrcIdReturn:
src/ir_print.cpp+55-54
......@@ -5,6 +5,7 @@
55 * See http://opensource.org/licenses/MIT
66 */
77
8#include "all_types.hpp"
89#include "analyze.hpp"
910#include "ir.hpp"
1011#include "ir_print.hpp"
......@@ -55,6 +56,36 @@ struct IrPrintGen {
5556static void ir_print_other_inst_src(IrPrintSrc *irp, IrInstSrc *inst);
5657static void ir_print_other_inst_gen(IrPrintGen *irp, IrInstGen *inst);
5758
59static void ir_print_call_modifier(FILE *f, CallModifier modifier) {
60 switch (modifier) {
61 case CallModifierNone:
62 break;
63 case CallModifierNoSuspend:
64 fprintf(f, "nosuspend ");
65 break;
66 case CallModifierAsync:
67 fprintf(f, "async ");
68 break;
69 case CallModifierNeverTail:
70 fprintf(f, "notail ");
71 break;
72 case CallModifierNeverInline:
73 fprintf(f, "noinline ");
74 break;
75 case CallModifierAlwaysTail:
76 fprintf(f, "tail ");
77 break;
78 case CallModifierAlwaysInline:
79 fprintf(f, "inline ");
80 break;
81 case CallModifierCompileTime:
82 fprintf(f, "comptime ");
83 break;
84 case CallModifierBuiltin:
85 zig_unreachable();
86 }
87}
88
5889const char* ir_inst_src_type_str(IrInstSrcId id) {
5990 switch (id) {
6091 case IrInstSrcIdInvalid:
......@@ -97,6 +128,8 @@ const char* ir_inst_src_type_str(IrInstSrcId id) {
97128 return "SrcVarPtr";
98129 case IrInstSrcIdCallExtra:
99130 return "SrcCallExtra";
131 case IrInstSrcIdAsyncCallExtra:
132 return "SrcAsyncCallExtra";
100133 case IrInstSrcIdCall:
101134 return "SrcCall";
102135 case IrInstSrcIdCallArgs:
......@@ -851,6 +884,23 @@ static void ir_print_call_extra(IrPrintSrc *irp, IrInstSrcCallExtra *instruction
851884 ir_print_result_loc(irp, instruction->result_loc);
852885}
853886
887static void ir_print_async_call_extra(IrPrintSrc *irp, IrInstSrcAsyncCallExtra *instruction) {
888 fprintf(irp->f, "modifier=");
889 ir_print_call_modifier(irp->f, instruction->modifier);
890 fprintf(irp->f, ", fn=");
891 ir_print_other_inst_src(irp, instruction->fn_ref);
892 if (instruction->ret_ptr != nullptr) {
893 fprintf(irp->f, ", ret_ptr=");
894 ir_print_other_inst_src(irp, instruction->ret_ptr);
895 }
896 fprintf(irp->f, ", new_stack=");
897 ir_print_other_inst_src(irp, instruction->new_stack);
898 fprintf(irp->f, ", args=");
899 ir_print_other_inst_src(irp, instruction->args);
900 fprintf(irp->f, ", result=");
901 ir_print_result_loc(irp, instruction->result_loc);
902}
903
854904static void ir_print_call_args(IrPrintSrc *irp, IrInstSrcCallArgs *instruction) {
855905 fprintf(irp->f, "opts=");
856906 ir_print_other_inst_src(irp, instruction->options);
......@@ -868,33 +918,7 @@ static void ir_print_call_args(IrPrintSrc *irp, IrInstSrcCallArgs *instruction)
868918}
869919
870920static void ir_print_call_src(IrPrintSrc *irp, IrInstSrcCall *call_instruction) {
871 switch (call_instruction->modifier) {
872 case CallModifierNone:
873 break;
874 case CallModifierNoSuspend:
875 fprintf(irp->f, "nosuspend ");
876 break;
877 case CallModifierAsync:
878 fprintf(irp->f, "async ");
879 break;
880 case CallModifierNeverTail:
881 fprintf(irp->f, "notail ");
882 break;
883 case CallModifierNeverInline:
884 fprintf(irp->f, "noinline ");
885 break;
886 case CallModifierAlwaysTail:
887 fprintf(irp->f, "tail ");
888 break;
889 case CallModifierAlwaysInline:
890 fprintf(irp->f, "inline ");
891 break;
892 case CallModifierCompileTime:
893 fprintf(irp->f, "comptime ");
894 break;
895 case CallModifierBuiltin:
896 zig_unreachable();
897 }
921 ir_print_call_modifier(irp->f, call_instruction->modifier);
898922 if (call_instruction->fn_entry) {
899923 fprintf(irp->f, "%s", buf_ptr(&call_instruction->fn_entry->symbol_name));
900924 } else {
......@@ -913,33 +937,7 @@ static void ir_print_call_src(IrPrintSrc *irp, IrInstSrcCall *call_instruction)
913937}
914938
915939static void ir_print_call_gen(IrPrintGen *irp, IrInstGenCall *call_instruction) {
916 switch (call_instruction->modifier) {
917 case CallModifierNone:
918 break;
919 case CallModifierNoSuspend:
920 fprintf(irp->f, "nosuspend ");
921 break;
922 case CallModifierAsync:
923 fprintf(irp->f, "async ");
924 break;
925 case CallModifierNeverTail:
926 fprintf(irp->f, "notail ");
927 break;
928 case CallModifierNeverInline:
929 fprintf(irp->f, "noinline ");
930 break;
931 case CallModifierAlwaysTail:
932 fprintf(irp->f, "tail ");
933 break;
934 case CallModifierAlwaysInline:
935 fprintf(irp->f, "inline ");
936 break;
937 case CallModifierCompileTime:
938 fprintf(irp->f, "comptime ");
939 break;
940 case CallModifierBuiltin:
941 zig_unreachable();
942 }
940 ir_print_call_modifier(irp->f, call_instruction->modifier);
943941 if (call_instruction->fn_entry) {
944942 fprintf(irp->f, "%s", buf_ptr(&call_instruction->fn_entry->symbol_name));
945943 } else {
......@@ -2619,6 +2617,9 @@ static void ir_print_inst_src(IrPrintSrc *irp, IrInstSrc *instruction, bool trai
26192617 case IrInstSrcIdCallExtra:
26202618 ir_print_call_extra(irp, (IrInstSrcCallExtra *)instruction);
26212619 break;
2620 case IrInstSrcIdAsyncCallExtra:
2621 ir_print_async_call_extra(irp, (IrInstSrcAsyncCallExtra *)instruction);
2622 break;
26222623 case IrInstSrcIdCall:
26232624 ir_print_call_src(irp, (IrInstSrcCall *)instruction);
26242625 break;