Commit 99985ad6fc
Changed files (6)
src/all_types.hpp
@@ -56,7 +56,13 @@ struct IrExecutable {
IrAnalyze *analysis;
Scope *begin_scope;
ZigList<Tld *> tld_list;
+
IrInstruction *coro_handle;
+ IrInstruction *coro_awaiter_field_ptr;
+ IrInstruction *coro_result_ptr_field_ptr;
+ IrInstruction *implicit_allocator_ptr;
+ IrBasicBlock *coro_early_final;
+ IrBasicBlock *coro_normal_final;
};
enum OutType {
@@ -1968,6 +1974,10 @@ enum IrInstructionId {
IrInstructionIdCoroSize,
IrInstructionIdCoroBegin,
IrInstructionIdCoroAllocFail,
+ IrInstructionIdCoroSuspend,
+ IrInstructionIdCoroEnd,
+ IrInstructionIdCoroFree,
+ IrInstructionIdCoroResume,
};
struct IrInstruction {
@@ -2819,6 +2829,8 @@ struct IrInstructionGetImplicitAllocator {
struct IrInstructionCoroId {
IrInstruction base;
+
+ IrInstruction *promise_ptr;
};
struct IrInstructionCoroAlloc {
@@ -2844,6 +2856,30 @@ struct IrInstructionCoroAllocFail {
IrInstruction *err_val;
};
+struct IrInstructionCoroSuspend {
+ IrInstruction base;
+
+ IrInstruction *save_point;
+ IrInstruction *is_final;
+};
+
+struct IrInstructionCoroEnd {
+ IrInstruction base;
+};
+
+struct IrInstructionCoroFree {
+ IrInstruction base;
+
+ IrInstruction *coro_id;
+ IrInstruction *coro_handle;
+};
+
+struct IrInstructionCoroResume {
+ IrInstruction base;
+
+ IrInstruction *awaiter_handle;
+};
+
static const size_t slice_ptr_index = 0;
static const size_t slice_len_index = 1;
src/analyze.cpp
@@ -475,9 +475,7 @@ TypeTableEntry *get_maybe_type(CodeGen *g, TypeTableEntry *child_type) {
if (child_type->zero_bits) {
entry->type_ref = LLVMInt1Type();
entry->di_type = g->builtin_types.entry_bool->di_type;
- } else if (child_type->id == TypeTableEntryIdPointer ||
- child_type->id == TypeTableEntryIdFn)
- {
+ } else if (type_is_codegen_pointer(child_type)) {
// this is an optimization but also is necessary for calling C
// functions where all pointers are maybe pointers
// function types are technically pointers
@@ -1262,7 +1260,7 @@ static bool type_allowed_in_packed_struct(TypeTableEntry *type_entry) {
case TypeTableEntryIdMaybe:
{
TypeTableEntry *child_type = type_entry->data.maybe.child_type;
- return child_type->id == TypeTableEntryIdPointer || child_type->id == TypeTableEntryIdFn;
+ return type_is_codegen_pointer(child_type);
}
case TypeTableEntryIdEnum:
return type_entry->data.enumeration.decl_node->data.container_decl.init_arg_expr != nullptr;
@@ -1673,6 +1671,8 @@ TypeTableEntry *get_struct_type(CodeGen *g, const char *type_name, const char *f
field->src_index = i;
field->gen_index = i;
+ assert(type_has_bits(field->type_entry));
+
auto prev_entry = struct_type->data.structure.fields_by_name.put_unique(field->name, field);
assert(prev_entry == nullptr);
}
@@ -3669,9 +3669,11 @@ void resolve_container_type(CodeGen *g, TypeTableEntry *type_entry) {
TypeTableEntry *get_codegen_ptr_type(TypeTableEntry *type) {
if (type->id == TypeTableEntryIdPointer) return type;
if (type->id == TypeTableEntryIdFn) return type;
+ if (type->id == TypeTableEntryIdPromise) return type;
if (type->id == TypeTableEntryIdMaybe) {
if (type->data.maybe.child_type->id == TypeTableEntryIdPointer) return type->data.maybe.child_type;
if (type->data.maybe.child_type->id == TypeTableEntryIdFn) return type->data.maybe.child_type;
+ if (type->data.maybe.child_type->id == TypeTableEntryIdPromise) return type->data.maybe.child_type;
}
return nullptr;
}
src/analyze.hpp
@@ -51,6 +51,7 @@ VariableTableEntry *find_variable(CodeGen *g, Scope *orig_context, Buf *name);
Tld *find_decl(CodeGen *g, Scope *scope, Buf *name);
void resolve_top_level_decl(CodeGen *g, Tld *tld, bool pointer_only, AstNode *source_node);
bool type_is_codegen_pointer(TypeTableEntry *type);
+
TypeTableEntry *get_codegen_ptr_type(TypeTableEntry *type);
uint32_t get_ptr_align(TypeTableEntry *type);
TypeTableEntry *validate_var_type(CodeGen *g, AstNode *source_node, TypeTableEntry *type_entry);
src/codegen.cpp
@@ -542,7 +542,7 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, FnTableEntry *fn_table_entry) {
if (!type_has_bits(return_type)) {
// nothing to do
- } else if (return_type->id == TypeTableEntryIdPointer || return_type->id == TypeTableEntryIdFn) {
+ } else if (type_is_codegen_pointer(return_type)) {
addLLVMAttr(fn_table_entry->llvm_value, 0, "nonnull");
} else if (handle_is_ptr(return_type) &&
calling_convention_does_first_arg_return(fn_type->data.fn.fn_type_id.cc))
@@ -2789,7 +2789,7 @@ static LLVMValueRef gen_non_null_bit(CodeGen *g, TypeTableEntry *maybe_type, LLV
if (child_type->zero_bits) {
return maybe_handle;
} else {
- bool maybe_is_ptr = (child_type->id == TypeTableEntryIdPointer || child_type->id == TypeTableEntryIdFn);
+ bool maybe_is_ptr = type_is_codegen_pointer(child_type);
if (maybe_is_ptr) {
return LLVMBuildICmp(g->builder, LLVMIntNE, maybe_handle, LLVMConstNull(maybe_type->type_ref), "");
} else {
@@ -2829,7 +2829,7 @@ static LLVMValueRef ir_render_unwrap_maybe(CodeGen *g, IrExecutable *executable,
if (child_type->zero_bits) {
return nullptr;
} else {
- bool maybe_is_ptr = (child_type->id == TypeTableEntryIdPointer || child_type->id == TypeTableEntryIdFn);
+ bool maybe_is_ptr = type_is_codegen_pointer(child_type);
if (maybe_is_ptr) {
return maybe_ptr;
} else {
@@ -3052,6 +3052,10 @@ static LLVMValueRef ir_render_align_cast(CodeGen *g, IrExecutable *executable, I
{
align_bytes = target_type->data.maybe.child_type->data.fn.fn_type_id.alignment;
ptr_val = target_val;
+ } else if (target_type->id == TypeTableEntryIdMaybe &&
+ target_type->data.maybe.child_type->id == TypeTableEntryIdPromise)
+ {
+ zig_panic("TODO audit this function");
} else if (target_type->id == TypeTableEntryIdStruct && target_type->data.structure.is_slice) {
TypeTableEntry *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index].type_entry;
align_bytes = slice_ptr_type->data.pointer.alignment;
@@ -3522,9 +3526,7 @@ static LLVMValueRef ir_render_maybe_wrap(CodeGen *g, IrExecutable *executable, I
}
LLVMValueRef payload_val = ir_llvm_value(g, instruction->value);
- if (child_type->id == TypeTableEntryIdPointer ||
- child_type->id == TypeTableEntryIdFn)
- {
+ if (type_is_codegen_pointer(child_type)) {
return payload_val;
}
@@ -3716,6 +3718,22 @@ static LLVMValueRef ir_render_coro_alloc_fail(CodeGen *g, IrExecutable *executab
zig_panic("TODO ir_render_coro_alloc_fail");
}
+static LLVMValueRef ir_render_coro_suspend(CodeGen *g, IrExecutable *executable, IrInstructionCoroSuspend *instruction) {
+ zig_panic("TODO ir_render_coro_suspend");
+}
+
+static LLVMValueRef ir_render_coro_end(CodeGen *g, IrExecutable *executable, IrInstructionCoroEnd *instruction) {
+ zig_panic("TODO ir_render_coro_end");
+}
+
+static LLVMValueRef ir_render_coro_free(CodeGen *g, IrExecutable *executable, IrInstructionCoroFree *instruction) {
+ zig_panic("TODO ir_render_coro_free");
+}
+
+static LLVMValueRef ir_render_coro_resume(CodeGen *g, IrExecutable *executable, IrInstructionCoroResume *instruction) {
+ zig_panic("TODO ir_render_coro_resume");
+}
+
static void set_debug_location(CodeGen *g, IrInstruction *instruction) {
AstNode *source_node = instruction->source_node;
Scope *scope = instruction->scope;
@@ -3911,6 +3929,14 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
return ir_render_coro_begin(g, executable, (IrInstructionCoroBegin *)instruction);
case IrInstructionIdCoroAllocFail:
return ir_render_coro_alloc_fail(g, executable, (IrInstructionCoroAllocFail *)instruction);
+ case IrInstructionIdCoroSuspend:
+ return ir_render_coro_suspend(g, executable, (IrInstructionCoroSuspend *)instruction);
+ case IrInstructionIdCoroEnd:
+ return ir_render_coro_end(g, executable, (IrInstructionCoroEnd *)instruction);
+ case IrInstructionIdCoroFree:
+ return ir_render_coro_free(g, executable, (IrInstructionCoroFree *)instruction);
+ case IrInstructionIdCoroResume:
+ return ir_render_coro_resume(g, executable, (IrInstructionCoroResume *)instruction);
}
zig_unreachable();
}
@@ -4155,9 +4181,7 @@ static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val, const c
TypeTableEntry *child_type = type_entry->data.maybe.child_type;
if (child_type->zero_bits) {
return LLVMConstInt(LLVMInt1Type(), const_val->data.x_maybe ? 1 : 0, false);
- } else if (child_type->id == TypeTableEntryIdPointer ||
- child_type->id == TypeTableEntryIdFn)
- {
+ } else if (type_is_codegen_pointer(child_type)) {
if (const_val->data.x_maybe) {
return gen_const_val(g, const_val->data.x_maybe, "");
} else {
@@ -6085,9 +6109,7 @@ static void get_c_type(CodeGen *g, GenH *gen_h, TypeTableEntry *type_entry, Buf
if (child_type->zero_bits) {
buf_init_from_str(out_buf, "bool");
return;
- } else if (child_type->id == TypeTableEntryIdPointer ||
- child_type->id == TypeTableEntryIdFn)
- {
+ } else if (type_is_codegen_pointer(child_type)) {
return get_c_type(g, gen_h, child_type, out_buf);
} else {
zig_unreachable();
src/ir.cpp
@@ -46,7 +46,10 @@ static LVal make_lval_addr(bool is_const, bool is_volatile) {
}
static const char * ASYNC_ALLOC_FIELD_NAME = "allocFn";
-//static const char * ASYNC_FREE_FIELD_NAME = "freeFn";
+static const char * ASYNC_FREE_FIELD_NAME = "freeFn";
+static const char * AWAITER_HANDLE_FIELD_NAME = "awaiter_handle";
+static const char * RESULT_FIELD_NAME = "result";
+static const char * RESULT_PTR_FIELD_NAME = "result_ptr";
enum ConstCastResultId {
ConstCastResultIdOk,
@@ -672,6 +675,22 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionCoroAllocFail *)
return IrInstructionIdCoroAllocFail;
}
+static constexpr IrInstructionId ir_instruction_id(IrInstructionCoroSuspend *) {
+ return IrInstructionIdCoroSuspend;
+}
+
+static constexpr IrInstructionId ir_instruction_id(IrInstructionCoroEnd *) {
+ return IrInstructionIdCoroEnd;
+}
+
+static constexpr IrInstructionId ir_instruction_id(IrInstructionCoroFree *) {
+ return IrInstructionIdCoroFree;
+}
+
+static constexpr IrInstructionId ir_instruction_id(IrInstructionCoroResume *) {
+ return IrInstructionIdCoroResume;
+}
+
template<typename T>
static T *ir_create_instruction(IrBuilder *irb, Scope *scope, AstNode *source_node) {
T *special_instruction = allocate<T>(1);
@@ -743,14 +762,6 @@ static IrInstruction *ir_build_return(IrBuilder *irb, Scope *scope, AstNode *sou
return &return_instruction->base;
}
-static IrInstruction *ir_build_return_from(IrBuilder *irb, IrInstruction *old_instruction,
- IrInstruction *return_value)
-{
- IrInstruction *new_instruction = ir_build_return(irb, old_instruction->scope, old_instruction->source_node, return_value);
- ir_link_new_instruction(new_instruction, old_instruction);
- return new_instruction;
-}
-
static IrInstruction *ir_create_const(IrBuilder *irb, Scope *scope, AstNode *source_node,
TypeTableEntry *type_entry)
{
@@ -822,6 +833,14 @@ static IrInstruction *ir_build_const_u29(IrBuilder *irb, Scope *scope, AstNode *
return &const_instruction->base;
}
+static IrInstruction *ir_build_const_u8(IrBuilder *irb, Scope *scope, AstNode *source_node, uint8_t value) {
+ IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
+ const_instruction->base.value.type = irb->codegen->builtin_types.entry_u8;
+ const_instruction->base.value.special = ConstValSpecialStatic;
+ bigint_init_unsigned(&const_instruction->base.value.data.x_bigint, value);
+ return &const_instruction->base;
+}
+
static IrInstruction *ir_create_const_type(IrBuilder *irb, Scope *scope, AstNode *source_node,
TypeTableEntry *type_entry)
{
@@ -909,6 +928,33 @@ static IrInstruction *ir_build_const_c_str_lit(IrBuilder *irb, Scope *scope, Ast
return &const_instruction->base;
}
+static IrInstruction *ir_build_const_promise_init(IrBuilder *irb, Scope *scope, AstNode *source_node,
+ TypeTableEntry *return_type)
+{
+ TypeTableEntry *awaiter_handle_type = get_maybe_type(irb->codegen, irb->codegen->builtin_types.entry_promise);
+ TypeTableEntry *result_ptr_type = get_pointer_to_type(irb->codegen, return_type, false);
+ const char *field_names[] = {AWAITER_HANDLE_FIELD_NAME, RESULT_FIELD_NAME, RESULT_PTR_FIELD_NAME};
+ TypeTableEntry *field_types[] = {awaiter_handle_type, return_type, result_ptr_type};
+ size_t field_count = type_has_bits(result_ptr_type) ? 3 : 1;
+ TypeTableEntry *struct_type = get_struct_type(irb->codegen, "AsyncFramePromise", field_names, field_types,
+ field_count);
+
+ IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
+ const_instruction->base.value.type = struct_type;
+ const_instruction->base.value.special = ConstValSpecialStatic;
+ const_instruction->base.value.data.x_struct.fields = allocate<ConstExprValue>(2);
+ const_instruction->base.value.data.x_struct.fields[0].type = awaiter_handle_type;
+ const_instruction->base.value.data.x_struct.fields[0].special = ConstValSpecialStatic;
+ const_instruction->base.value.data.x_struct.fields[0].data.x_maybe = nullptr;
+ if (field_count == 3) {
+ const_instruction->base.value.data.x_struct.fields[1].type = return_type;
+ const_instruction->base.value.data.x_struct.fields[1].special = ConstValSpecialUndef;
+ const_instruction->base.value.data.x_struct.fields[2].type = result_ptr_type;
+ const_instruction->base.value.data.x_struct.fields[2].special = ConstValSpecialUndef;
+ }
+ return &const_instruction->base;
+}
+
static IrInstruction *ir_build_bin_op(IrBuilder *irb, Scope *scope, AstNode *source_node, IrBinOp op_id,
IrInstruction *op1, IrInstruction *op2, bool safety_check_on)
{
@@ -2451,8 +2497,11 @@ static IrInstruction *ir_build_get_implicit_allocator(IrBuilder *irb, Scope *sco
return &instruction->base;
}
-static IrInstruction *ir_build_coro_id(IrBuilder *irb, Scope *scope, AstNode *source_node) {
+static IrInstruction *ir_build_coro_id(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *promise_ptr) {
IrInstructionCoroId *instruction = ir_build_instruction<IrInstructionCoroId>(irb, scope, source_node);
+ instruction->promise_ptr = promise_ptr;
+
+ ir_ref_instruction(promise_ptr, irb->current_basic_block);
return &instruction->base;
}
@@ -2494,6 +2543,48 @@ static IrInstruction *ir_build_coro_alloc_fail(IrBuilder *irb, Scope *scope, Ast
return &instruction->base;
}
+static IrInstruction *ir_build_coro_suspend(IrBuilder *irb, Scope *scope, AstNode *source_node,
+ IrInstruction *save_point, IrInstruction *is_final)
+{
+ IrInstructionCoroSuspend *instruction = ir_build_instruction<IrInstructionCoroSuspend>(irb, scope, source_node);
+ instruction->save_point = save_point;
+ instruction->is_final = is_final;
+
+ if (save_point != nullptr) ir_ref_instruction(save_point, irb->current_basic_block);
+ ir_ref_instruction(is_final, irb->current_basic_block);
+
+ return &instruction->base;
+}
+
+static IrInstruction *ir_build_coro_end(IrBuilder *irb, Scope *scope, AstNode *source_node) {
+ IrInstructionCoroEnd *instruction = ir_build_instruction<IrInstructionCoroEnd>(irb, scope, source_node);
+ return &instruction->base;
+}
+
+static IrInstruction *ir_build_coro_free(IrBuilder *irb, Scope *scope, AstNode *source_node,
+ IrInstruction *coro_id, IrInstruction *coro_handle)
+{
+ IrInstructionCoroFree *instruction = ir_build_instruction<IrInstructionCoroFree>(irb, scope, source_node);
+ instruction->coro_id = coro_id;
+ instruction->coro_handle = coro_handle;
+
+ ir_ref_instruction(coro_id, irb->current_basic_block);
+ ir_ref_instruction(coro_handle, irb->current_basic_block);
+
+ return &instruction->base;
+}
+
+static IrInstruction *ir_build_coro_resume(IrBuilder *irb, Scope *scope, AstNode *source_node,
+ IrInstruction *awaiter_handle)
+{
+ IrInstructionCoroResume *instruction = ir_build_instruction<IrInstructionCoroResume>(irb, scope, source_node);
+ instruction->awaiter_handle = awaiter_handle;
+
+ ir_ref_instruction(awaiter_handle, irb->current_basic_block);
+
+ return &instruction->base;
+}
+
static void ir_count_defers(IrBuilder *irb, Scope *inner_scope, Scope *outer_scope, size_t *results) {
results[ReturnKindUnconditional] = 0;
results[ReturnKindError] = 0;
@@ -2566,6 +2657,29 @@ static ScopeDeferExpr *get_scope_defer_expr(Scope *scope) {
return nullptr;
}
+static IrInstruction *ir_gen_async_return(IrBuilder *irb, Scope *scope, AstNode *node, IrInstruction *return_value,
+ bool is_generated_code)
+{
+ FnTableEntry *fn_entry = exec_fn_entry(irb->exec);
+ bool is_async = fn_entry != nullptr && fn_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync;
+ if (!is_async) {
+ IrInstruction *return_inst = ir_build_return(irb, scope, node, return_value);
+ return_inst->is_gen = is_generated_code;
+ return return_inst;
+ }
+
+ if (irb->exec->coro_result_ptr_field_ptr) {
+ IrInstruction *result_ptr = ir_build_load_ptr(irb, scope, node, irb->exec->coro_result_ptr_field_ptr);
+ ir_build_store_ptr(irb, scope, node, result_ptr, return_value);
+ }
+ IrInstruction *maybe_await_handle = ir_build_load_ptr(irb, scope, node, irb->exec->coro_awaiter_field_ptr);
+ IrInstruction *is_non_null = ir_build_test_nonnull(irb, scope, node, maybe_await_handle);
+ IrInstruction *is_comptime = ir_build_const_bool(irb, scope, node, false);
+ return ir_build_cond_br(irb, scope, node, is_non_null, irb->exec->coro_normal_final, irb->exec->coro_early_final,
+ is_comptime);
+ // the above blocks are rendered by ir_gen after the rest of codegen
+}
+
static IrInstruction *ir_gen_return(IrBuilder *irb, Scope *scope, AstNode *node, LVal lval) {
assert(node->type == NodeTypeReturnExpr);
@@ -2615,18 +2729,22 @@ static IrInstruction *ir_gen_return(IrBuilder *irb, Scope *scope, AstNode *node,
}
ir_mark_gen(ir_build_cond_br(irb, scope, node, is_err, err_block, ok_block, is_comptime));
+ IrBasicBlock *ret_stmt_block = ir_create_basic_block(irb, scope, "RetStmt");
ir_set_cursor_at_end_and_append_block(irb, err_block);
ir_gen_defers_for_block(irb, scope, outer_scope, true);
- ir_build_return(irb, scope, node, return_value);
+ ir_build_br(irb, scope, node, ret_stmt_block, is_comptime);
ir_set_cursor_at_end_and_append_block(irb, ok_block);
ir_gen_defers_for_block(irb, scope, outer_scope, false);
- return ir_build_return(irb, scope, node, return_value);
+ ir_build_br(irb, scope, node, ret_stmt_block, is_comptime);
+
+ ir_set_cursor_at_end_and_append_block(irb, ret_stmt_block);
+ return ir_gen_async_return(irb, scope, node, return_value, false);
} else {
// generate unconditional defers
ir_gen_defers_for_block(irb, scope, outer_scope, false);
- return ir_build_return(irb, scope, node, return_value);
+ return ir_gen_async_return(irb, scope, node, return_value, false);
}
}
case ReturnKindError:
@@ -2646,7 +2764,7 @@ static IrInstruction *ir_gen_return(IrBuilder *irb, Scope *scope, AstNode *node,
ir_set_cursor_at_end_and_append_block(irb, return_block);
ir_gen_defers_for_block(irb, scope, outer_scope, true);
IrInstruction *err_val = ir_build_unwrap_err_code(irb, scope, node, err_union_ptr);
- ir_build_return(irb, scope, node, err_val);
+ ir_gen_async_return(irb, scope, node, err_val, false);
ir_set_cursor_at_end_and_append_block(irb, continue_block);
IrInstruction *unwrapped_ptr = ir_build_unwrap_err_payload(irb, scope, node, err_union_ptr, false);
@@ -5842,6 +5960,7 @@ static void invalidate_exec(IrExecutable *exec) {
invalidate_exec(exec->source_exec);
}
+
bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutable *ir_executable) {
assert(node->owner);
@@ -5858,48 +5977,81 @@ bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutable *ir_exec
FnTableEntry *fn_entry = exec_fn_entry(irb->exec);
bool is_async = fn_entry != nullptr && fn_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync;
+ IrInstruction *u8_ptr_type;
+ IrInstruction *const_bool_false;
+ IrInstruction *coro_unwrapped_mem_ptr;
+ IrInstruction *coro_id;
+ IrInstruction *coro_promise_ptr;
+ IrInstruction *coro_result_field_ptr;
+ TypeTableEntry *return_type;
+ Buf *result_ptr_field_name;
if (is_async) {
- IrInstruction *is_comptime_false = ir_build_const_bool(irb, scope, node, false);
- IrInstruction *coro_id = ir_build_coro_id(irb, scope, node);
+ // create the coro promise
+ const_bool_false = ir_build_const_bool(irb, scope, node, false);
+ VariableTableEntry *promise_var = ir_create_var(irb, node, scope, nullptr, false, false, true, const_bool_false);
+ //scope = promise_var->child_scope;
+
+ return_type = fn_entry->type_entry->data.fn.fn_type_id.return_type;
+ IrInstruction *promise_init = ir_build_const_promise_init(irb, scope, node, return_type);
+ ir_build_var_decl(irb, scope, node, promise_var, nullptr, nullptr, promise_init);
+
+ coro_promise_ptr = ir_build_var_ptr(irb, scope, node, promise_var, false, false);
+ Buf *awaiter_handle_field_name = buf_create_from_str(AWAITER_HANDLE_FIELD_NAME);
+ irb->exec->coro_awaiter_field_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr,
+ awaiter_handle_field_name);
+ if (type_has_bits(return_type)) {
+ Buf *result_field_name = buf_create_from_str(RESULT_FIELD_NAME);
+ coro_result_field_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr, result_field_name);
+ result_ptr_field_name = buf_create_from_str(RESULT_PTR_FIELD_NAME);
+ irb->exec->coro_result_ptr_field_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr,
+ result_ptr_field_name);
+ ir_build_store_ptr(irb, scope, node, irb->exec->coro_result_ptr_field_ptr, coro_result_field_ptr);
+ }
+
+ u8_ptr_type = ir_build_const_type(irb, scope, node,
+ get_pointer_to_type(irb->codegen, irb->codegen->builtin_types.entry_u8, false));
+ IrInstruction *promise_as_u8_ptr = ir_build_ptr_cast(irb, scope, node, u8_ptr_type, coro_promise_ptr);
+ coro_id = ir_build_coro_id(irb, scope, node, promise_as_u8_ptr);
IrInstruction *need_dyn_alloc = ir_build_coro_alloc(irb, scope, node, coro_id);
IrInstruction *zero = ir_build_const_usize(irb, scope, node, 0);
- IrInstruction *u8_ptr_type = ir_build_const_type(irb, scope, node,
- get_pointer_to_type(irb->codegen, irb->codegen->builtin_types.entry_u8, false));
IrInstruction *null_ptr = ir_build_int_to_ptr(irb, scope, node, u8_ptr_type, zero);
IrBasicBlock *dyn_alloc_block = ir_create_basic_block(irb, scope, "DynAlloc");
IrBasicBlock *coro_begin_block = ir_create_basic_block(irb, scope, "CoroBegin");
- ir_build_cond_br(irb, scope, node, need_dyn_alloc, dyn_alloc_block, coro_begin_block, is_comptime_false);
+ ir_build_cond_br(irb, scope, node, need_dyn_alloc, dyn_alloc_block, coro_begin_block, const_bool_false);
ir_set_cursor_at_end_and_append_block(irb, dyn_alloc_block);
IrInstruction *coro_size = ir_build_coro_size(irb, scope, node);
- IrInstruction *implicit_allocator_ptr = ir_build_get_implicit_allocator(irb, scope, node);
+ irb->exec->implicit_allocator_ptr = ir_build_get_implicit_allocator(irb, scope, node);
Buf *alloc_field_name = buf_create_from_str(ASYNC_ALLOC_FIELD_NAME);
- IrInstruction *alloc_fn_ptr = ir_build_field_ptr(irb, scope, node, implicit_allocator_ptr, alloc_field_name);
+ IrInstruction *alloc_fn_ptr = ir_build_field_ptr(irb, scope, node, irb->exec->implicit_allocator_ptr,
+ alloc_field_name);
IrInstruction *alloc_fn = ir_build_load_ptr(irb, scope, node, alloc_fn_ptr);
IrInstruction *alignment = ir_build_const_u29(irb, scope, node, irb->codegen->pointer_size_bytes * 2);
size_t arg_count = 3;
IrInstruction **args = allocate<IrInstruction *>(arg_count);
- args[0] = implicit_allocator_ptr; // self
+ args[0] = irb->exec->implicit_allocator_ptr; // self
args[1] = coro_size; // byte_count
args[2] = alignment; // alignment
- IrInstruction *alloc_result = ir_build_call(irb, scope, node, nullptr, alloc_fn, arg_count, args, false, FnInlineAuto, false, nullptr);
+ IrInstruction *alloc_result = ir_build_call(irb, scope, node, nullptr, alloc_fn, arg_count, args, false,
+ FnInlineAuto, false, nullptr);
IrInstruction *alloc_result_ptr = ir_build_ref(irb, scope, node, alloc_result, true, false);
IrInstruction *alloc_result_is_err = ir_build_test_err(irb, scope, node, alloc_result);
IrBasicBlock *alloc_err_block = ir_create_basic_block(irb, scope, "AllocError");
IrBasicBlock *alloc_ok_block = ir_create_basic_block(irb, scope, "AllocOk");
- ir_build_cond_br(irb, scope, node, alloc_result_is_err, alloc_err_block, alloc_ok_block, is_comptime_false);
+ ir_build_cond_br(irb, scope, node, alloc_result_is_err, alloc_err_block, alloc_ok_block, const_bool_false);
ir_set_cursor_at_end_and_append_block(irb, alloc_err_block);
IrInstruction *err_val = ir_build_unwrap_err_code(irb, scope, node, alloc_result_ptr);
ir_build_coro_alloc_fail(irb, scope, node, err_val);
ir_set_cursor_at_end_and_append_block(irb, alloc_ok_block);
- IrInstruction *unwrapped_mem_ptr = ir_build_unwrap_err_payload(irb, scope, node, alloc_result_ptr, false);
+ coro_unwrapped_mem_ptr = ir_build_unwrap_err_payload(irb, scope, node, alloc_result_ptr, false);
Buf *ptr_field_name = buf_create_from_str("ptr");
- IrInstruction *coro_mem_ptr_field = ir_build_field_ptr(irb, scope, node, unwrapped_mem_ptr, ptr_field_name);
+ IrInstruction *coro_mem_ptr_field = ir_build_field_ptr(irb, scope, node, coro_unwrapped_mem_ptr,
+ ptr_field_name);
IrInstruction *coro_mem_ptr = ir_build_load_ptr(irb, scope, node, coro_mem_ptr_field);
- ir_build_br(irb, scope, node, coro_begin_block, is_comptime_false);
+ ir_build_br(irb, scope, node, coro_begin_block, const_bool_false);
ir_set_cursor_at_end_and_append_block(irb, coro_begin_block);
IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
@@ -5910,6 +6062,8 @@ bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutable *ir_exec
incoming_values[1] = coro_mem_ptr;
IrInstruction *coro_mem = ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values);
irb->exec->coro_handle = ir_build_coro_begin(irb, scope, node, coro_id, coro_mem);
+ irb->exec->coro_early_final = ir_create_basic_block(irb, scope, "CoroEarlyFinal");
+ irb->exec->coro_normal_final = ir_create_basic_block(irb, scope, "CoroNormalFinal");
}
IrInstruction *result = ir_gen_node_extra(irb, node, scope, LVAL_NONE);
@@ -5918,7 +6072,84 @@ bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutable *ir_exec
return false;
if (!instr_is_unreachable(result)) {
- ir_mark_gen(ir_build_return(irb, scope, result->source_node, result));
+ ir_gen_async_return(irb, scope, result->source_node, result, true);
+ }
+
+ if (is_async) {
+ IrBasicBlock *invalid_resume_block = ir_create_basic_block(irb, scope, "InvalidResume");
+ IrBasicBlock *final_cleanup_block = ir_create_basic_block(irb, scope, "FinalCleanup");
+ IrBasicBlock *suspend_block = ir_create_basic_block(irb, scope, "Suspend");
+ IrBasicBlock *check_free_block = ir_create_basic_block(irb, scope, "CheckFree");
+
+ ir_set_cursor_at_end_and_append_block(irb, irb->exec->coro_early_final);
+ IrInstruction *const_bool_true = ir_build_const_bool(irb, scope, node, true);
+ IrInstruction *suspend_code = ir_build_coro_suspend(irb, scope, node, nullptr, const_bool_true);
+ IrInstructionSwitchBrCase *cases = allocate<IrInstructionSwitchBrCase>(2);
+ cases[0].value = ir_build_const_u8(irb, scope, node, 0);
+ cases[0].block = invalid_resume_block;
+ cases[1].value = ir_build_const_u8(irb, scope, node, 1);
+ cases[1].block = final_cleanup_block;
+ ir_build_switch_br(irb, scope, node, suspend_code, suspend_block, 2, cases, const_bool_false);
+
+ ir_set_cursor_at_end_and_append_block(irb, suspend_block);
+ ir_build_coro_end(irb, scope, node);
+ ir_build_return(irb, scope, node, irb->exec->coro_handle);
+
+ ir_set_cursor_at_end_and_append_block(irb, invalid_resume_block);
+ ir_build_unreachable(irb, scope, node);
+
+ ir_set_cursor_at_end_and_append_block(irb, irb->exec->coro_normal_final);
+ ir_build_br(irb, scope, node, check_free_block, const_bool_false);
+
+ ir_set_cursor_at_end_and_append_block(irb, final_cleanup_block);
+ if (type_has_bits(return_type)) {
+ IrInstruction *result_ptr = ir_build_load_ptr(irb, scope, node, irb->exec->coro_result_ptr_field_ptr);
+ IrInstruction *result_ptr_as_u8_ptr = ir_build_ptr_cast(irb, scope, node, u8_ptr_type, result_ptr);
+ IrInstruction *return_value_ptr_as_u8_ptr = ir_build_ptr_cast(irb, scope, node, u8_ptr_type,
+ coro_result_field_ptr);
+ IrInstruction *return_type_inst = ir_build_const_type(irb, scope, node,
+ fn_entry->type_entry->data.fn.fn_type_id.return_type);
+ IrInstruction *size_of_ret_val = ir_build_size_of(irb, scope, node, return_type_inst);
+ ir_build_memcpy(irb, scope, node, result_ptr_as_u8_ptr, return_value_ptr_as_u8_ptr, size_of_ret_val);
+ }
+ ir_build_br(irb, scope, node, check_free_block, const_bool_false);
+
+ ir_set_cursor_at_end_and_append_block(irb, check_free_block);
+ IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
+ IrInstruction **incoming_values = allocate<IrInstruction *>(2);
+ incoming_blocks[0] = final_cleanup_block;
+ incoming_values[0] = const_bool_false;
+ incoming_blocks[1] = irb->exec->coro_normal_final;
+ incoming_values[1] = const_bool_true;
+ IrInstruction *resume_awaiter = ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values);
+ IrInstruction *mem_to_free = ir_build_coro_free(irb, scope, node, coro_id, irb->exec->coro_handle);
+ IrInstruction *is_non_null = ir_build_test_nonnull(irb, scope, node, mem_to_free);
+ IrBasicBlock *dyn_free_block = ir_create_basic_block(irb, scope, "DynFree");
+ IrBasicBlock *end_free_block = ir_create_basic_block(irb, scope, "EndFree");
+ ir_build_cond_br(irb, scope, node, is_non_null, dyn_free_block, end_free_block, const_bool_false);
+
+ ir_set_cursor_at_end_and_append_block(irb, dyn_free_block);
+ Buf *free_field_name = buf_create_from_str(ASYNC_FREE_FIELD_NAME);
+ IrInstruction *free_fn_ptr = ir_build_field_ptr(irb, scope, node, irb->exec->implicit_allocator_ptr,
+ free_field_name);
+ IrInstruction *free_fn = ir_build_load_ptr(irb, scope, node, free_fn_ptr);
+ size_t arg_count = 2;
+ IrInstruction **args = allocate<IrInstruction *>(arg_count);
+ args[0] = irb->exec->implicit_allocator_ptr; // self
+ args[1] = ir_build_load_ptr(irb, scope, node, coro_unwrapped_mem_ptr); // old_mem
+ ir_build_call(irb, scope, node, nullptr, free_fn, arg_count, args, false, FnInlineAuto, false, nullptr);
+ ir_build_br(irb, scope, node, end_free_block, const_bool_false);
+
+ ir_set_cursor_at_end_and_append_block(irb, end_free_block);
+ IrBasicBlock *resume_block = ir_create_basic_block(irb, scope, "Resume");
+ ir_build_cond_br(irb, scope, node, resume_awaiter, resume_block, suspend_block, const_bool_false);
+
+ ir_set_cursor_at_end_and_append_block(irb, resume_block);
+ IrInstruction *unwrapped_await_handle_ptr = ir_build_unwrap_maybe(irb, scope, node,
+ irb->exec->coro_awaiter_field_ptr, false);
+ IrInstruction *awaiter_handle = ir_build_load_ptr(irb, scope, node, unwrapped_await_handle_ptr);
+ ir_build_coro_resume(irb, scope, node, awaiter_handle);
+ ir_build_br(irb, scope, node, suspend_block, const_bool_false);
}
return true;
@@ -9514,8 +9745,11 @@ static TypeTableEntry *ir_analyze_instruction_return(IrAnalyze *ira,
ir_add_error(ira, casted_value, buf_sprintf("function returns address of local variable"));
return ir_unreach_error(ira);
}
- ir_build_return_from(&ira->new_irb, &return_instruction->base, casted_value);
- return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+ IrInstruction *result = ir_build_return(&ira->new_irb, return_instruction->base.scope,
+ return_instruction->base.source_node, casted_value);
+ result->value.type = ira->codegen->builtin_types.entry_unreachable;
+ ir_link_new_instruction(result, &return_instruction->base);
+ return ir_finish_anal(ira, result->value.type);
}
static TypeTableEntry *ir_analyze_instruction_const(IrAnalyze *ira, IrInstructionConst *const_instruction) {
@@ -16624,11 +16858,8 @@ static TypeTableEntry *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstr
TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
- if (!(target->value.type->id == TypeTableEntryIdPointer ||
- target->value.type->id == TypeTableEntryIdFn ||
- (target->value.type->id == TypeTableEntryIdMaybe &&
- (target->value.type->data.maybe.child_type->id == TypeTableEntryIdPointer ||
- target->value.type->data.maybe.child_type->id == TypeTableEntryIdFn))))
+ if (!(type_is_codegen_pointer(target->value.type) || (target->value.type->id == TypeTableEntryIdMaybe &&
+ type_is_codegen_pointer(target->value.type->data.maybe.child_type))))
{
ir_add_error(ira, target,
buf_sprintf("expected pointer, found '%s'", buf_ptr(&target->value.type->name)));
@@ -16829,7 +17060,12 @@ static TypeTableEntry *ir_analyze_instruction_cancel(IrAnalyze *ira, IrInstructi
}
static TypeTableEntry *ir_analyze_instruction_coro_id(IrAnalyze *ira, IrInstructionCoroId *instruction) {
- IrInstruction *result = ir_build_coro_id(&ira->new_irb, instruction->base.scope, instruction->base.source_node);
+ IrInstruction *promise_ptr = instruction->promise_ptr->other;
+ if (type_is_invalid(promise_ptr->value.type))
+ return ira->codegen->builtin_types.entry_invalid;
+
+ IrInstruction *result = ir_build_coro_id(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
+ promise_ptr);
ir_link_new_instruction(result, &instruction->base);
result->value.type = ira->codegen->builtin_types.entry_usize;
return result->value.type;
@@ -16889,6 +17125,63 @@ static TypeTableEntry *ir_analyze_instruction_coro_alloc_fail(IrAnalyze *ira, Ir
return ir_finish_anal(ira, result->value.type);
}
+static TypeTableEntry *ir_analyze_instruction_coro_suspend(IrAnalyze *ira, IrInstructionCoroSuspend *instruction) {
+ IrInstruction *save_point = nullptr;
+ if (instruction->save_point != nullptr) {
+ save_point = instruction->save_point->other;
+ if (type_is_invalid(save_point->value.type))
+ return ira->codegen->builtin_types.entry_invalid;
+ }
+
+ IrInstruction *is_final = instruction->is_final->other;
+ if (type_is_invalid(is_final->value.type))
+ return ira->codegen->builtin_types.entry_invalid;
+
+ IrInstruction *result = ir_build_coro_suspend(&ira->new_irb, instruction->base.scope,
+ instruction->base.source_node, save_point, is_final);
+ ir_link_new_instruction(result, &instruction->base);
+ result->value.type = ira->codegen->builtin_types.entry_u8;
+ return result->value.type;
+}
+
+static TypeTableEntry *ir_analyze_instruction_coro_end(IrAnalyze *ira, IrInstructionCoroEnd *instruction) {
+ IrInstruction *result = ir_build_coro_end(&ira->new_irb, instruction->base.scope,
+ instruction->base.source_node);
+ ir_link_new_instruction(result, &instruction->base);
+ result->value.type = ira->codegen->builtin_types.entry_void;
+ return result->value.type;
+}
+
+static TypeTableEntry *ir_analyze_instruction_coro_free(IrAnalyze *ira, IrInstructionCoroFree *instruction) {
+ IrInstruction *coro_id = instruction->coro_id->other;
+ if (type_is_invalid(coro_id->value.type))
+ return ira->codegen->builtin_types.entry_invalid;
+
+ IrInstruction *coro_handle = instruction->coro_handle->other;
+ if (type_is_invalid(coro_handle->value.type))
+ return ira->codegen->builtin_types.entry_invalid;
+
+ IrInstruction *result = ir_build_coro_free(&ira->new_irb, instruction->base.scope,
+ instruction->base.source_node, coro_id, coro_handle);
+ ir_link_new_instruction(result, &instruction->base);
+ TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
+ result->value.type = get_maybe_type(ira->codegen, ptr_type);
+ return result->value.type;
+}
+
+static TypeTableEntry *ir_analyze_instruction_coro_resume(IrAnalyze *ira, IrInstructionCoroResume *instruction) {
+ IrInstruction *awaiter_handle = instruction->awaiter_handle->other;
+ if (type_is_invalid(awaiter_handle->value.type))
+ return ira->codegen->builtin_types.entry_invalid;
+
+ IrInstruction *result = ir_build_coro_resume(&ira->new_irb, instruction->base.scope,
+ instruction->base.source_node, awaiter_handle);
+ ir_link_new_instruction(result, &instruction->base);
+ result->value.type = ira->codegen->builtin_types.entry_void;
+ return result->value.type;
+}
+
+
static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *instruction) {
switch (instruction->id) {
case IrInstructionIdInvalid:
@@ -17105,6 +17398,14 @@ static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructi
return ir_analyze_instruction_get_implicit_allocator(ira, (IrInstructionGetImplicitAllocator *)instruction);
case IrInstructionIdCoroAllocFail:
return ir_analyze_instruction_coro_alloc_fail(ira, (IrInstructionCoroAllocFail *)instruction);
+ case IrInstructionIdCoroSuspend:
+ return ir_analyze_instruction_coro_suspend(ira, (IrInstructionCoroSuspend *)instruction);
+ case IrInstructionIdCoroEnd:
+ return ir_analyze_instruction_coro_end(ira, (IrInstructionCoroEnd *)instruction);
+ case IrInstructionIdCoroFree:
+ return ir_analyze_instruction_coro_free(ira, (IrInstructionCoroFree *)instruction);
+ case IrInstructionIdCoroResume:
+ return ir_analyze_instruction_coro_resume(ira, (IrInstructionCoroResume *)instruction);
}
zig_unreachable();
}
@@ -17134,7 +17435,10 @@ TypeTableEntry *ir_analyze(CodeGen *codegen, IrExecutable *old_exec, IrExecutabl
IrAnalyze *ira = allocate<IrAnalyze>(1);
old_exec->analysis = ira;
ira->codegen = codegen;
- ira->explicit_return_type = expected_type;
+
+ FnTableEntry *fn_entry = exec_fn_entry(old_exec);
+ bool is_async = fn_entry != nullptr && fn_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync;
+ ira->explicit_return_type = is_async ? get_promise_type(codegen, expected_type) : expected_type;
ira->old_irb.codegen = codegen;
ira->old_irb.exec = old_exec;
@@ -17222,6 +17526,8 @@ bool ir_has_side_effects(IrInstruction *instruction) {
case IrInstructionIdCoroId:
case IrInstructionIdCoroBegin:
case IrInstructionIdCoroAllocFail:
+ case IrInstructionIdCoroEnd:
+ case IrInstructionIdCoroResume:
return true;
case IrInstructionIdPhi:
@@ -17299,6 +17605,8 @@ bool ir_has_side_effects(IrInstruction *instruction) {
case IrInstructionIdGetImplicitAllocator:
case IrInstructionIdCoroAlloc:
case IrInstructionIdCoroSize:
+ case IrInstructionIdCoroSuspend:
+ case IrInstructionIdCoroFree:
return false;
case IrInstructionIdAsm:
src/ir_print.cpp
@@ -1031,7 +1031,9 @@ static void ir_print_get_implicit_allocator(IrPrint *irp, IrInstructionGetImplic
}
static void ir_print_coro_id(IrPrint *irp, IrInstructionCoroId *instruction) {
- fprintf(irp->f, "@coroId()");
+ fprintf(irp->f, "@coroId(");
+ ir_print_other_instruction(irp, instruction->promise_ptr);
+ fprintf(irp->f, ")");
}
static void ir_print_coro_alloc(IrPrint *irp, IrInstructionCoroAlloc *instruction) {
@@ -1058,6 +1060,36 @@ static void ir_print_coro_alloc_fail(IrPrint *irp, IrInstructionCoroAllocFail *i
fprintf(irp->f, ")");
}
+static void ir_print_coro_suspend(IrPrint *irp, IrInstructionCoroSuspend *instruction) {
+ fprintf(irp->f, "@coroSuspend(");
+ if (instruction->save_point != nullptr) {
+ ir_print_other_instruction(irp, instruction->save_point);
+ } else {
+ fprintf(irp->f, "null");
+ }
+ fprintf(irp->f, ",");
+ ir_print_other_instruction(irp, instruction->is_final);
+ fprintf(irp->f, ")");
+}
+
+static void ir_print_coro_end(IrPrint *irp, IrInstructionCoroEnd *instruction) {
+ fprintf(irp->f, "@coroEnd()");
+}
+
+static void ir_print_coro_free(IrPrint *irp, IrInstructionCoroFree *instruction) {
+ fprintf(irp->f, "@coroFree(");
+ ir_print_other_instruction(irp, instruction->coro_id);
+ fprintf(irp->f, ",");
+ ir_print_other_instruction(irp, instruction->coro_handle);
+ fprintf(irp->f, ")");
+}
+
+static void ir_print_coro_resume(IrPrint *irp, IrInstructionCoroResume *instruction) {
+ fprintf(irp->f, "@coroResume(");
+ ir_print_other_instruction(irp, instruction->awaiter_handle);
+ fprintf(irp->f, ")");
+}
+
static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
ir_print_prefix(irp, instruction);
switch (instruction->id) {
@@ -1399,6 +1431,18 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
case IrInstructionIdCoroAllocFail:
ir_print_coro_alloc_fail(irp, (IrInstructionCoroAllocFail *)instruction);
break;
+ case IrInstructionIdCoroSuspend:
+ ir_print_coro_suspend(irp, (IrInstructionCoroSuspend *)instruction);
+ break;
+ case IrInstructionIdCoroEnd:
+ ir_print_coro_end(irp, (IrInstructionCoroEnd *)instruction);
+ break;
+ case IrInstructionIdCoroFree:
+ ir_print_coro_free(irp, (IrInstructionCoroFree *)instruction);
+ break;
+ case IrInstructionIdCoroResume:
+ ir_print_coro_resume(irp, (IrInstructionCoroResume *)instruction);
+ break;
}
fprintf(irp->f, "\n");
}