authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-08-25 20:27:56-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-08-25 20:27:56-04:00
log64e9b0ee4673bf79d42ea14e354b324308f90b93
tree5f6ddd1a1f84f9bd8fdfe752d6a8542cb51b7565
parent8f41da221690a8dbbbce41a07513715b9a31e70a
signaturelock-open Commit is signed but in an unrecognized format.

make the zero-bit-ness of pointers lazy

this case works now: ```zig const Foo = struct { field: @typeOf(func).ReturnType, }; fn func(self: *Foo) void {} ```

2 files changed, 72 insertions(+), 39 deletions(-)

src/analyze.cpp+66-33
......@@ -474,15 +474,21 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_cons
474474 buf_ptr(&child_type->name));
475475 }
476476
477 if (type_has_bits(child_type)) {
478 entry->abi_size = g->builtin_types.entry_usize->abi_size;
479 entry->size_in_bits = g->builtin_types.entry_usize->size_in_bits;
480 entry->abi_align = g->builtin_types.entry_usize->abi_align;
477 if (type_is_resolved(child_type, ResolveStatusZeroBitsKnown)) {
478 if (type_has_bits(child_type)) {
479 entry->abi_size = g->builtin_types.entry_usize->abi_size;
480 entry->size_in_bits = g->builtin_types.entry_usize->size_in_bits;
481 entry->abi_align = g->builtin_types.entry_usize->abi_align;
482 } else {
483 assert(byte_alignment == 0);
484 entry->abi_size = 0;
485 entry->size_in_bits = 0;
486 entry->abi_align = 0;
487 }
481488 } else {
482 assert(byte_alignment == 0);
483 entry->abi_size = 0;
484 entry->size_in_bits = 0;
485 entry->abi_align = 0;
489 entry->abi_size = SIZE_MAX;
490 entry->size_in_bits = SIZE_MAX;
491 entry->abi_align = UINT32_MAX;
486492 }
487493
488494 entry->data.pointer.ptr_len = ptr_len;
......@@ -5585,6 +5591,25 @@ static Error resolve_async_frame(CodeGen *g, ZigType *frame_type) {
55855591 return ErrorNone;
55865592}
55875593
5594static Error resolve_pointer_zero_bits(CodeGen *g, ZigType *ty) {
5595 Error err;
5596 ZigType *elem_type = ty->data.pointer.child_type;
5597
5598 if ((err = type_resolve(g, elem_type, ResolveStatusZeroBitsKnown)))
5599 return err;
5600
5601 if (type_has_bits(elem_type)) {
5602 ty->abi_size = g->builtin_types.entry_usize->abi_size;
5603 ty->size_in_bits = g->builtin_types.entry_usize->size_in_bits;
5604 ty->abi_align = g->builtin_types.entry_usize->abi_align;
5605 } else {
5606 ty->abi_size = 0;
5607 ty->size_in_bits = 0;
5608 ty->abi_align = 0;
5609 }
5610 return ErrorNone;
5611}
5612
55885613Error type_resolve(CodeGen *g, ZigType *ty, ResolveStatus status) {
55895614 if (type_is_invalid(ty))
55905615 return ErrorSemanticAnalyzeFail;
......@@ -5594,36 +5619,44 @@ Error type_resolve(CodeGen *g, ZigType *ty, ResolveStatus status) {
55945619 case ResolveStatusInvalid:
55955620 zig_unreachable();
55965621 case ResolveStatusZeroBitsKnown:
5597 if (ty->id == ZigTypeIdStruct) {
5598 return resolve_struct_zero_bits(g, ty);
5599 } else if (ty->id == ZigTypeIdEnum) {
5600 return resolve_enum_zero_bits(g, ty);
5601 } else if (ty->id == ZigTypeIdUnion) {
5602 return resolve_union_zero_bits(g, ty);
5622 switch (ty->id) {
5623 case ZigTypeIdStruct:
5624 return resolve_struct_zero_bits(g, ty);
5625 case ZigTypeIdEnum:
5626 return resolve_enum_zero_bits(g, ty);
5627 case ZigTypeIdUnion:
5628 return resolve_union_zero_bits(g, ty);
5629 case ZigTypeIdPointer:
5630 return resolve_pointer_zero_bits(g, ty);
5631 default:
5632 return ErrorNone;
56035633 }
5604 return ErrorNone;
56055634 case ResolveStatusAlignmentKnown:
5606 if (ty->id == ZigTypeIdStruct) {
5607 return resolve_struct_alignment(g, ty);
5608 } else if (ty->id == ZigTypeIdEnum) {
5609 return resolve_enum_zero_bits(g, ty);
5610 } else if (ty->id == ZigTypeIdUnion) {
5611 return resolve_union_alignment(g, ty);
5612 } else if (ty->id == ZigTypeIdFnFrame) {
5613 return resolve_async_frame(g, ty);
5635 switch (ty->id) {
5636 case ZigTypeIdStruct:
5637 return resolve_struct_alignment(g, ty);
5638 case ZigTypeIdEnum:
5639 return resolve_enum_zero_bits(g, ty);
5640 case ZigTypeIdUnion:
5641 return resolve_union_alignment(g, ty);
5642 case ZigTypeIdFnFrame:
5643 return resolve_async_frame(g, ty);
5644 default:
5645 return ErrorNone;
56145646 }
5615 return ErrorNone;
56165647 case ResolveStatusSizeKnown:
5617 if (ty->id == ZigTypeIdStruct) {
5618 return resolve_struct_type(g, ty);
5619 } else if (ty->id == ZigTypeIdEnum) {
5620 return resolve_enum_zero_bits(g, ty);
5621 } else if (ty->id == ZigTypeIdUnion) {
5622 return resolve_union_type(g, ty);
5623 } else if (ty->id == ZigTypeIdFnFrame) {
5624 return resolve_async_frame(g, ty);
5648 switch (ty->id) {
5649 case ZigTypeIdStruct:
5650 return resolve_struct_type(g, ty);
5651 case ZigTypeIdEnum:
5652 return resolve_enum_zero_bits(g, ty);
5653 case ZigTypeIdUnion:
5654 return resolve_union_type(g, ty);
5655 case ZigTypeIdFnFrame:
5656 return resolve_async_frame(g, ty);
5657 default:
5658 return ErrorNone;
56255659 }
5626 return ErrorNone;
56275660 case ResolveStatusLLVMFwdDecl:
56285661 case ResolveStatusLLVMFull:
56295662 resolve_llvm_types(g, ty, status);
src/ir.cpp+6-6
......@@ -25582,12 +25582,12 @@ static Error ir_resolve_lazy_raw(CodeGen *codegen, AstNode *source_node, ConstEx
2558225582 }
2558325583 }
2558425584
25585 ResolveStatus needed_status = (align_bytes == 0) ?
25586 ResolveStatusZeroBitsKnown : ResolveStatusAlignmentKnown;
25587 if ((err = type_resolve(codegen, elem_type, needed_status)))
25588 return err;
25589 if (!type_has_bits(elem_type))
25590 align_bytes = 0;
25585 if (align_bytes != 0) {
25586 if ((err = type_resolve(codegen, elem_type, ResolveStatusAlignmentKnown)))
25587 return err;
25588 if (!type_has_bits(elem_type))
25589 align_bytes = 0;
25590 }
2559125591 bool allow_zero = lazy_ptr_type->is_allowzero || lazy_ptr_type->ptr_len == PtrLenC;
2559225592 assert(val->type->id == ZigTypeIdMetaType);
2559325593 val->data.x_type = get_pointer_to_type_extra(codegen, elem_type,