copy elision: catch with identifier expression

andrewrk · andrewrk · commit d77b368ea6fe · 2018-10-30T04:18:35.000-04:00
This commit also makes `@sizeOf(?error) == @sizeof(error)`. Since 0 is not a valid error code, 0 can be used for the null value, in the same way that 0 is used for the null value of pointers. ```zig export fn entry() void { var x: error!Bar = fail(); var y = x catch bar2(); } ``` ```llvm define void @entry() #2 !dbg !42 { Entry: %error_return_trace_addresses = alloca [30 x i64], align 8 %error_return_trace = alloca %StackTrace, align 8 %x = alloca { i16, %Bar }, align 4 %y = alloca %Bar, align 4 %0 = getelementptr inbounds %StackTrace, %StackTrace* %error_return_trace, i32 0, i32 0 store i64 0, i64* %0, align 8 %1 = getelementptr inbounds %StackTrace, %StackTrace* %error_return_trace, i32 0, i32 1 %2 = getelementptr inbounds %"[]usize", %"[]usize"* %1, i32 0, i32 0 %3 = getelementptr inbounds [30 x i64], [30 x i64]* %error_return_trace_addresses, i64 0, i64 0 store i64* %3, i64** %2, align 8 %4 = getelementptr inbounds %"[]usize", %"[]usize"* %1, i32 0, i32 1 store i64 30, i64* %4, align 8 %5 = getelementptr inbounds { i16, %Bar }, { i16, %Bar }* %x, i32 0, i32 0, !dbg !59 %6 = call fastcc i16 @fail(%StackTrace* %error_return_trace), !dbg !60 store i16 %6, i16* %5, align 2, !dbg !60 call void @llvm.dbg.declare(metadata { i16, %Bar }* %x, metadata !46, metadata !DIExpression()), !dbg !59 %7 = getelementptr inbounds { i16, %Bar }, { i16, %Bar }* %x, i32 0, i32 1, !dbg !61 %8 = bitcast %Bar* %7 to i8*, !dbg !61 %9 = bitcast %Bar* %y to i8*, !dbg !61 call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %9, i8* align 4 %8, i64 8, i1 false), !dbg !61 %10 = getelementptr inbounds { i16, %Bar }, { i16, %Bar }* %x, i32 0, i32 0, !dbg !61 %11 = load i16, i16* %10, align 2, !dbg !62 %12 = icmp ne i16 %11, 0, !dbg !62 br i1 %12, label %CatchError, label %CatchEnd, !dbg !62 CatchError: ; preds = %Entry call fastcc void @bar2(%Bar* sret %y), !dbg !63 br label %CatchEnd, !dbg !62 CatchEnd: ; preds = %CatchError, %Entry call void @llvm.dbg.declare(metadata %Bar* %y, metadata !57, metadata !DIExpression()), !dbg !64 ret void, !dbg !65 } ```
diff --git a/src/all_types.hpp b/src/all_types.hpp
@@ -2186,6 +2186,7 @@ enum IrInstructionId {
     IrInstructionIdAllocaSrc,
     IrInstructionIdAllocaGen,
     IrInstructionIdAssertNonError,
+    IrInstructionIdErrorUnionFieldErrorSet,
 };
 
 struct IrInstruction {
@@ -2882,6 +2883,12 @@ struct IrInstructionUnwrapErrCode {
     IrInstruction *value;
 };
 
+struct IrInstructionErrorUnionFieldErrorSet {
+    IrInstruction base;
+
+    IrInstruction *ptr;
+};
+
 struct IrInstructionUnwrapErrPayload {
     IrInstruction base;
 
diff --git a/src/analyze.cpp b/src/analyze.cpp
@@ -589,7 +589,7 @@ ZigType *get_optional_type(CodeGen *g, ZigType *child_type) {
         if (child_type->zero_bits) {
             entry->type_ref = LLVMInt1Type();
             entry->di_type = g->builtin_types.entry_bool->di_type;
-        } else if (type_is_codegen_pointer(child_type)) {
+        } else if (type_is_codegen_pointer(child_type) || child_type->id == ZigTypeIdErrorSet) {
             assert(child_type->di_type);
             // this is an optimization but also is necessary for calling C
             // functions where all pointers are maybe pointers
@@ -4490,7 +4490,8 @@ bool handle_is_ptr(ZigType *type_entry) {
              return type_has_bits(type_entry->data.error_union.payload_type);
         case ZigTypeIdOptional:
              return type_has_bits(type_entry->data.maybe.child_type) &&
-                    !type_is_codegen_pointer(type_entry->data.maybe.child_type);
+                    !type_is_codegen_pointer(type_entry->data.maybe.child_type) &&
+                    type_entry->data.maybe.child_type->id != ZigTypeIdErrorSet;
         case ZigTypeIdUnion:
              assert(type_entry->data.unionation.zero_bits_known);
              if (type_entry->data.unionation.gen_field_count == 0)
diff --git a/src/codegen.cpp b/src/codegen.cpp
@@ -3734,8 +3734,8 @@ static LLVMValueRef gen_non_null_bit(CodeGen *g, ZigType *maybe_type, LLVMValueR
     if (child_type->zero_bits) {
         return maybe_handle;
     } else {
-        bool maybe_is_ptr = type_is_codegen_pointer(child_type);
-        if (maybe_is_ptr) {
+        bool is_scalar = type_is_codegen_pointer(child_type) || child_type->id == ZigTypeIdErrorSet;
+        if (is_scalar) {
             return LLVMBuildICmp(g->builder, LLVMIntNE, maybe_handle, LLVMConstNull(maybe_type->type_ref), "");
         } else {
             LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP(g->builder, maybe_handle, maybe_null_index, "");
@@ -3774,8 +3774,8 @@ static LLVMValueRef ir_render_unwrap_maybe(CodeGen *g, IrExecutable *executable,
     if (child_type->zero_bits) {
         return nullptr;
     } else {
-        bool maybe_is_ptr = type_is_codegen_pointer(child_type);
-        if (maybe_is_ptr) {
+        bool is_scalar = type_is_codegen_pointer(child_type) || child_type->id == ZigTypeIdErrorSet;
+        if (is_scalar) {
             return maybe_ptr;
         } else {
             LLVMValueRef maybe_struct_ref = get_handle_value(g, maybe_ptr, maybe_type, ptr_type);
@@ -4552,6 +4552,7 @@ static LLVMValueRef ir_render_unwrap_err_code(CodeGen *g, IrExecutable *executab
     ZigType *ptr_type = instruction->value->value.type;
     assert(ptr_type->id == ZigTypeIdPointer);
     ZigType *err_union_type = ptr_type->data.pointer.child_type;
+    assert(err_union_type->id == ZigTypeIdErrorUnion);
     ZigType *payload_type = err_union_type->data.error_union.payload_type;
     LLVMValueRef err_union_ptr = ir_llvm_value(g, instruction->value);
     LLVMValueRef err_union_handle = get_handle_value(g, err_union_ptr, err_union_type, ptr_type);
@@ -4564,6 +4565,23 @@ static LLVMValueRef ir_render_unwrap_err_code(CodeGen *g, IrExecutable *executab
     }
 }
 
+static LLVMValueRef ir_render_error_union_field_error_set(CodeGen *g, IrExecutable *executable,
+        IrInstructionErrorUnionFieldErrorSet *instruction)
+{
+    ZigType *ptr_type = instruction->ptr->value.type;
+    assert(ptr_type->id == ZigTypeIdPointer);
+    ZigType *err_union_type = ptr_type->data.pointer.child_type;
+    assert(err_union_type->id == ZigTypeIdErrorUnion);
+    ZigType *payload_type = err_union_type->data.error_union.payload_type;
+    LLVMValueRef err_union_ptr = ir_llvm_value(g, instruction->ptr);
+
+    if (type_has_bits(payload_type)) {
+        return LLVMBuildStructGEP(g->builder, err_union_ptr, err_union_err_index, "");
+    } else {
+        return err_union_ptr;
+    }
+}
+
 static LLVMValueRef ir_render_unwrap_err_payload(CodeGen *g, IrExecutable *executable, IrInstructionUnwrapErrPayload *instruction) {
     ZigType *ptr_type = instruction->value->value.type;
     assert(ptr_type->id == ZigTypeIdPointer);
@@ -4615,7 +4633,7 @@ static LLVMValueRef ir_render_maybe_wrap(CodeGen *g, IrExecutable *executable, I
     }
 
     LLVMValueRef payload_val = ir_llvm_value(g, instruction->value);
-    if (type_is_codegen_pointer(child_type)) {
+    if (type_is_codegen_pointer(child_type) || child_type->id == ZigTypeIdErrorSet) {
         return payload_val;
     }
 
@@ -5301,6 +5319,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_overflow_op(g, executable, (IrInstructionOverflowOp *)instruction);
         case IrInstructionIdTestErr:
             return ir_render_test_err(g, executable, (IrInstructionTestErr *)instruction);
+        case IrInstructionIdErrorUnionFieldErrorSet:
+            return ir_render_error_union_field_error_set(g, executable, (IrInstructionErrorUnionFieldErrorSet *)instruction);
         case IrInstructionIdUnwrapErrCode:
             return ir_render_unwrap_err_code(g, executable, (IrInstructionUnwrapErrCode *)instruction);
         case IrInstructionIdUnwrapErrPayload:
@@ -5735,6 +5755,8 @@ static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val, const c
                     return LLVMConstInt(LLVMInt1Type(), const_val->data.x_optional ? 1 : 0, false);
                 } else if (type_is_codegen_pointer(child_type)) {
                     return gen_const_val_ptr(g, const_val, name);
+                } else if (child_type->id == ZigTypeIdErrorSet) {
+                    zig_panic("TODO");
                 } else {
                     LLVMValueRef child_val;
                     LLVMValueRef maybe_val;
diff --git a/src/ir.cpp b/src/ir.cpp
@@ -903,6 +903,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionAssertNonError *
     return IrInstructionIdAssertNonError;
 }
 
+static constexpr IrInstructionId ir_instruction_id(IrInstructionErrorUnionFieldErrorSet *) {
+    return IrInstructionIdErrorUnionFieldErrorSet;
+}
+
 template<typename T>
 static T *ir_create_instruction(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     T *special_instruction = allocate<T>(1);
@@ -2921,6 +2925,17 @@ static IrInstruction *ir_build_assert_non_error(IrBuilder *irb, Scope *scope, As
     return &instruction->base;
 }
 
+static IrInstruction *ir_build_error_union_field_error_set(IrBuilder *irb, Scope *scope, AstNode *source_node,
+        IrInstruction *ptr)
+{
+    IrInstructionErrorUnionFieldErrorSet *instruction = ir_build_instruction<IrInstructionErrorUnionFieldErrorSet>(irb, scope, source_node);
+    instruction->ptr = ptr;
+
+    ir_ref_instruction(ptr, 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;
@@ -3153,7 +3168,7 @@ static IrInstruction *ir_gen_ptr(IrBuilder *irb, Scope *scope, AstNode *node, LV
             // must return the error code
             IrInstruction *payload_ptr = ir_build_unwrap_err_payload(irb, scope, node, ptr, false);
             ir_build_load_ptr(irb, scope, node, payload_ptr, result_loc);
-            return ir_build_unwrap_err_code(irb, scope, node, ptr);
+            return ir_build_error_union_field_error_set(irb, scope, node, ptr);
         }
         case LValOptional:
             zig_panic("TODO");
@@ -5109,11 +5124,12 @@ static IrInstruction *ir_gen_pointer_type(IrBuilder *irb, Scope *scope, AstNode
 static IrInstruction *ir_gen_catch_unreachable(IrBuilder *irb, Scope *scope, AstNode *source_node,
         AstNode *expr_node, LVal lval, IrInstruction *result_loc)
 {
-    IrInstruction *err_val = ir_gen_node(irb, expr_node, scope, LValErrorUnion, result_loc);
-    if (err_val == irb->codegen->invalid_instruction)
+    IrInstruction *err_code_ptr = ir_gen_node(irb, expr_node, scope, LValErrorUnion, result_loc);
+    if (err_code_ptr == irb->codegen->invalid_instruction)
         return irb->codegen->invalid_instruction;
 
-    ir_build_assert_non_error(irb, scope, source_node, err_val);
+    IrInstruction *err_code = ir_build_load_ptr(irb, scope, source_node, err_code_ptr, nullptr);
+    ir_build_assert_non_error(irb, scope, source_node, err_code);
 
     return ir_gen_lval_ptr(irb, scope, source_node, lval, result_loc);
 }
@@ -6453,11 +6469,12 @@ static IrInstruction *ir_gen_catch(IrBuilder *irb, Scope *parent_scope, AstNode
         return ir_gen_catch_unreachable(irb, parent_scope, node, op1_node, lval, result_loc);
     }
 
-    IrInstruction *err_val = ir_gen_node(irb, op1_node, parent_scope, LValErrorUnion, result_loc);
-    if (err_val == irb->codegen->invalid_instruction)
+    IrInstruction *err_code_ptr = ir_gen_node(irb, op1_node, parent_scope, LValErrorUnion, result_loc);
+    if (err_code_ptr == irb->codegen->invalid_instruction)
         return irb->codegen->invalid_instruction;
 
-    IrInstruction *is_err = ir_build_test_err(irb, parent_scope, node, err_val);
+    IrInstruction *opt_err_code = ir_build_load_ptr(irb, parent_scope, node, err_code_ptr, nullptr);
+    IrInstruction *is_err = ir_build_test_nonnull(irb, parent_scope, node, opt_err_code);
 
     IrInstruction *is_comptime;
     if (ir_should_inline(irb->exec, parent_scope)) {
@@ -6480,7 +6497,9 @@ static IrInstruction *ir_gen_catch(IrBuilder *irb, Scope *parent_scope, AstNode
         ZigVar *var = ir_create_var(irb, node, parent_scope, var_name,
             is_const, is_const, is_shadowable, is_comptime);
         err_scope = var->child_scope;
-        ir_build_var_decl_src(irb, err_scope, var_node, var, nullptr, nullptr, err_val);
+        IrInstruction *unwrapped_err_code_ptr = ir_build_unwrap_maybe(irb, err_scope, var_node,
+                err_code_ptr, false);
+        ir_build_var_decl_src(irb, err_scope, var_node, var, nullptr, nullptr, unwrapped_err_code_ptr);
     } else {
         err_scope = parent_scope;
     }
@@ -19573,6 +19592,40 @@ static IrInstruction *ir_analyze_instruction_test_err(IrAnalyze *ira, IrInstruct
     }
 }
 
+static IrInstruction *ir_analyze_instruction_error_union_field_error_set(IrAnalyze *ira,
+    IrInstructionErrorUnionFieldErrorSet *instruction)
+{
+    IrInstruction *ptr = instruction->ptr->child;
+    if (type_is_invalid(ptr->value.type))
+        return ira->codegen->invalid_instruction;
+    ZigType *ptr_type = ptr->value.type;
+
+    assert(ptr_type->id == ZigTypeIdPointer);
+
+    ZigType *type_entry = ptr_type->data.pointer.child_type;
+    if (type_is_invalid(type_entry))
+        return ira->codegen->invalid_instruction;
+
+    if (type_entry->id != ZigTypeIdErrorUnion) {
+        ir_add_error(ira, ptr,
+            buf_sprintf("expected error union type, found '%s'", buf_ptr(&type_entry->name)));
+        return ira->codegen->invalid_instruction;
+    }
+
+    ZigType *opt_err_set = get_optional_type(ira->codegen, type_entry->data.error_union.err_set_type);
+    ZigType *result_type = get_pointer_to_type_extra(ira->codegen, opt_err_set,
+            ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile, PtrLenSingle, 0, 0, 0);
+
+    if (instr_is_comptime(ptr)) {
+        zig_panic("TODO need to change ConstExprValue x_err_union to have a ConstExprValue for error set value");
+    }
+
+    IrInstruction *result = ir_build_error_union_field_error_set(&ira->new_irb,
+        instruction->base.scope, instruction->base.source_node, ptr);
+    result->value.type = result_type;
+    return result;
+}
+
 static IrInstruction *ir_analyze_instruction_unwrap_err_code(IrAnalyze *ira,
     IrInstructionUnwrapErrCode *instruction)
 {
@@ -19681,19 +19734,21 @@ static IrInstruction *ir_analyze_instruction_assert_non_error(IrAnalyze *ira,
     if (type_is_invalid(err_code->value.type))
         return ira->codegen->invalid_instruction;
 
-    assert(err_code->value.type->id == ZigTypeIdErrorSet);
+    assert(err_code->value.type->id == ZigTypeIdOptional);
+    assert(err_code->value.type->data.maybe.child_type->id == ZigTypeIdErrorSet);
 
     if (instr_is_comptime(err_code)) {
-        ConstExprValue *err_val = ir_resolve_const(ira, err_code, UndefBad);
-        if (err_val == nullptr)
+        ConstExprValue *opt_val = ir_resolve_const(ira, err_code, UndefBad);
+        if (opt_val == nullptr)
             return ira->codegen->invalid_instruction;
+        ConstExprValue *err_val = opt_val->data.x_optional;
+        if (err_val == nullptr)
+            return ir_const_void(ira, &instruction->base);
         ErrorTableEntry *err = err_val->data.x_err_set;
-        if (err != nullptr) {
-            ir_add_error(ira, &instruction->base,
-                buf_sprintf("caught unexpected error '%s'", buf_ptr(&err->name)));
-            return ira->codegen->invalid_instruction;
-        }
-        return ir_const_void(ira, &instruction->base);
+        assert(err != nullptr);
+        ir_add_error(ira, &instruction->base,
+            buf_sprintf("caught unexpected error '%s'", buf_ptr(&err->name)));
+        return ira->codegen->invalid_instruction;
     }
 
     ir_build_assert_non_error(&ira->new_irb, instruction->base.scope,
@@ -21593,6 +21648,8 @@ static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructio
             return ir_analyze_instruction_result_ptr_cast(ira, (IrInstructionResultPtrCast *)instruction);
         case IrInstructionIdAllocaSrc:
             return ir_analyze_instruction_alloca(ira, (IrInstructionAllocaSrc *)instruction);
+        case IrInstructionIdErrorUnionFieldErrorSet:
+            return ir_analyze_instruction_error_union_field_error_set(ira, (IrInstructionErrorUnionFieldErrorSet *)instruction);
         case IrInstructionIdResultBytesToSlice:
             zig_panic("TODO");
         case IrInstructionIdResultSliceToBytes:
@@ -21829,6 +21886,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdResultBytesToSlice:
         case IrInstructionIdAllocaSrc:
         case IrInstructionIdAllocaGen:
+        case IrInstructionIdErrorUnionFieldErrorSet:
             return false;
 
         case IrInstructionIdLoadPtr:
diff --git a/src/ir_print.cpp b/src/ir_print.cpp
@@ -1393,6 +1393,12 @@ static void ir_print_assert_non_error(IrPrint *irp, IrInstructionAssertNonError
     fprintf(irp->f, ")");
 }
 
+static void ir_print_error_union_field_error_set(IrPrint *irp, IrInstructionErrorUnionFieldErrorSet *instruction) {
+    fprintf(irp->f, "ErrorUnionFieldErrorSet(");
+    ir_print_other_instruction(irp, instruction->ptr);
+    fprintf(irp->f, ")");
+}
+
 static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
     ir_print_prefix(irp, instruction);
     switch (instruction->id) {
@@ -1854,6 +1860,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
         case IrInstructionIdAssertNonError:
             ir_print_assert_non_error(irp, (IrInstructionAssertNonError *)instruction);
             break;
+        case IrInstructionIdErrorUnionFieldErrorSet:
+            ir_print_error_union_field_error_set(irp, (IrInstructionErrorUnionFieldErrorSet *)instruction);
+            break;
     }
     fprintf(irp->f, "\n");
 }
