Commit 345f8db1c49efe3d9ca9859a296f24e728a3b43a | zig

author	Andrew Kelley <andrew@ziglang.org> 2018-09-18 17:51:50-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-09-18 17:51:50-04:00
log	345f8db1c49efe3d9ca9859a296f24e728a3b43a
tree	c0b6d17a4ef6f444365f0af57682bb9a29c5cbd5
parent	c1af3605328d21f59ee8ceba3c7350193f0a2429
signature	Commit is signed but in an unrecognized format.

fix optional pointer to empty struct incorrectly being non-null

closes #1178

4 files changed, 28 insertions(+), 8 deletions(-)

src
test
- cases
  - null.zig

src/analyze.cpp+11-3

 @@ -3971,7 +3971,7 @@ void resolve_container_type(CodeGen *g, ZigType *type_entry) {
     }
 }
-ZigType *get_codegen_ptr_type(ZigType *type) {
+ZigType *get_src_ptr_type(ZigType *type) {
     if (type->id == ZigTypeIdPointer) return type;
     if (type->id == ZigTypeIdFn) return type;
     if (type->id == ZigTypeIdPromise) return type;
 @@ -3983,12 +3983,19 @@ ZigType *get_codegen_ptr_type(ZigType *type) {
     return nullptr;
 }
+ZigType *get_codegen_ptr_type(ZigType *type) {
+    ZigType *ty = get_src_ptr_type(type);
+    if (ty == nullptr || !type_has_bits(ty))
+        return nullptr;
+    return ty;
+}
 bool type_is_codegen_pointer(ZigType *type) {
     return get_codegen_ptr_type(type) == type;
 }
 uint32_t get_ptr_align(CodeGen *g, ZigType *type) {
-    ZigType *ptr_type = get_codegen_ptr_type(type);
+    ZigType *ptr_type = get_src_ptr_type(type);
     if (ptr_type->id == ZigTypeIdPointer) {
         return (ptr_type->data.pointer.explicit_alignment == 0) ?
             get_abi_alignment(g, ptr_type->data.pointer.child_type) : ptr_type->data.pointer.explicit_alignment;
 @@ -3996,6 +4003,7 @@ uint32_t get_ptr_align(CodeGen *g, ZigType *type) {
         // I tried making this use LLVMABIAlignmentOfType but it trips this assertion in LLVM:
         // "Cannot getTypeInfo() on a type that is unsized!"
         // when getting the alignment of `?extern fn() void`.
+        // See http://lists.llvm.org/pipermail/llvm-dev/2018-September/126142.html
         return (ptr_type->data.fn.fn_type_id.alignment == 0) ? 1 : ptr_type->data.fn.fn_type_id.alignment;
     } else if (ptr_type->id == ZigTypeIdPromise) {
         return get_coro_frame_align_bytes(g);
 @@ -4005,7 +4013,7 @@ uint32_t get_ptr_align(CodeGen *g, ZigType *type) {
 }
 bool get_ptr_const(ZigType *type) {
-    ZigType *ptr_type = get_codegen_ptr_type(type);
+    ZigType *ptr_type = get_src_ptr_type(type);
     if (ptr_type->id == ZigTypeIdPointer) {
         return ptr_type->data.pointer.is_const;
     } else if (ptr_type->id == ZigTypeIdFn) {

src/analyze.hpp+1

...	@@ -53,6 +53,7 @@ Tld find_decl(CodeGen g, Scope scope, Buf name);	...	@@ -53,6 +53,7 @@ Tld find_decl(CodeGen g, Scope scope, Buf name);
53	void resolve_top_level_decl(CodeGen g, Tld tld, bool pointer_only, AstNode *source_node);	53	void resolve_top_level_decl(CodeGen g, Tld tld, bool pointer_only, AstNode *source_node);
54	bool type_is_codegen_pointer(ZigType *type);	54	bool type_is_codegen_pointer(ZigType *type);
55		55
		56	ZigType get_src_ptr_type(ZigType type);
56	ZigType get_codegen_ptr_type(ZigType type);	57	ZigType get_codegen_ptr_type(ZigType type);
57	uint32_t get_ptr_align(CodeGen g, ZigType type);	58	uint32_t get_ptr_align(CodeGen g, ZigType type);
58	bool get_ptr_const(ZigType *type);	59	bool get_ptr_const(ZigType *type);

src/ir.cpp+10-5

 @@ -155,7 +155,7 @@ static void buf_read_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
 static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue *val);
 static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *const_val) {
-    assert(get_codegen_ptr_type(const_val->type) != nullptr);
+    assert(get_src_ptr_type(const_val->type) != nullptr);
     assert(const_val->special == ConstValSpecialStatic);
     ConstExprValue *result;
     switch (const_val->data.x_ptr.special) {
 @@ -20161,12 +20161,15 @@ static ZigType *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtr
     if (type_is_invalid(src_type))
         return ira->codegen->builtin_types.entry_invalid;
-    if (get_codegen_ptr_type(src_type) == nullptr) {
+    // We have a check for zero bits later so we use get_src_ptr_type to
+    // validate src_type and dest_type.
+    if (get_src_ptr_type(src_type) == nullptr) {
         ir_add_error(ira, ptr, buf_sprintf("expected pointer, found '%s'", buf_ptr(&src_type->name)));
         return ira->codegen->builtin_types.entry_invalid;
     }
-    if (get_codegen_ptr_type(dest_type) == nullptr) {
+    if (get_src_ptr_type(dest_type) == nullptr) {
         ir_add_error(ira, dest_type_value,
                 buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
         return ira->codegen->builtin_types.entry_invalid;
 @@ -20465,7 +20468,8 @@ static ZigType *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstructionI
     if (type_is_invalid(dest_type))
         return ira->codegen->builtin_types.entry_invalid;
-    if (get_codegen_ptr_type(dest_type) == nullptr) {
+    // We explicitly check for the size, so we can use get_src_ptr_type
+    if (get_src_ptr_type(dest_type) == nullptr) {
         ir_add_error(ira, dest_type_value, buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
         return ira->codegen->builtin_types.entry_invalid;
     }
 @@ -20571,7 +20575,8 @@ static ZigType *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstructionP
     ZigType *usize = ira->codegen->builtin_types.entry_usize;
-    if (get_codegen_ptr_type(target->value.type) == nullptr) {
+    // We check size explicitly so we can use get_src_ptr_type here.
+    if (get_src_ptr_type(target->value.type) == nullptr) {
         ir_add_error(ira, target,
                 buf_sprintf("expected pointer, found '%s'", buf_ptr(&target->value.type->name)));
         return ira->codegen->builtin_types.entry_invalid;

test/cases/null.zig+6

...	@@ -154,3 +154,9 @@ test "optional types" {	...	@@ -154,3 +154,9 @@ test "optional types" {
154	const StructWithOptionalType = struct {	154	const StructWithOptionalType = struct {
155	t: ?type,	155	t: ?type,
156	};	156	};
		157
		158	test "optional pointer to 0 bit type null value at runtime" {
		159	const EmptyStruct = struct {};
		160	var x: ?*EmptyStruct = null;
		161	assert(x == null);
		162	}