Commit 22b4c9e1a9595bd94ada4c500a430e2668ffcd07 | zig

src/Sema.zig+59-16

 @@ -7983,12 +7983,25 @@ fn analyzePtrArithmetic(
     const runtime_src = rs: {
         if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
             if (try sema.resolveDefinedValue(block, offset_src, offset)) |offset_val| {
+                const ptr_ty = sema.typeOf(ptr);
+                const offset_int = offset_val.toUnsignedInt();
+                const new_ptr_ty = ptr_ty; // TODO modify alignment
+                if (ptr_val.getUnsignedInt()) |addr| {
+                    const target = sema.mod.getTarget();
+                    const elem_ty = ptr_ty.childType();
+                    const elem_size = elem_ty.abiSize(target);
+                    const new_addr = switch (air_tag) {
+                        .ptr_add => addr + elem_size * offset_int,
+                        .ptr_sub => addr - elem_size * offset_int,
+                        else => unreachable,
+                    };
+                    const new_ptr_val = try Value.Tag.int_u64.create(sema.arena, new_addr);
+                    return sema.addConstant(new_ptr_ty, new_ptr_val);
+                }
                 if (air_tag == .ptr_sub) {
                     return sema.fail(block, op_src, "TODO implement Sema comptime pointer subtraction", .{});
                 }
-                const offset_int = offset_val.toUnsignedInt();
                 const new_ptr_val = try ptr_val.elemPtr(sema.arena, offset_int);
-                const new_ptr_ty = sema.typeOf(ptr);
                 return sema.addConstant(new_ptr_ty, new_ptr_val);
             } else break :rs offset_src;
         } else break :rs ptr_src;
 @@ -11979,6 +11992,8 @@ fn coerce(
             return sema.wrapOptional(block, dest_ty, intermediate, inst_src);
         },
         .Pointer => {
+            const dest_info = dest_ty.ptrInfo().data;
             // Function body to function pointer.
             if (inst_ty.zigTypeTag() == .Fn) {
                 const fn_val = try sema.resolveConstValue(block, inst_src, inst);
 @@ -11989,16 +12004,16 @@ fn coerce(
             // *T to *[1]T
             single_item: {
-                if (!dest_ty.isSinglePointer()) break :single_item;
+                if (dest_info.size != .One) break :single_item;
                 if (!inst_ty.isSinglePointer()) break :single_item;
                 const ptr_elem_ty = inst_ty.childType();
-                const array_ty = dest_ty.childType();
+                const array_ty = dest_info.pointee_type;
                 if (array_ty.zigTypeTag() != .Array) break :single_item;
                 const array_elem_ty = array_ty.childType();
-                const dest_is_mut = !dest_ty.isConstPtr();
+                const dest_is_mut = dest_info.mutable;
                 if (inst_ty.isConstPtr() and dest_is_mut) break :single_item;
-                if (inst_ty.isVolatilePtr() and !dest_ty.isVolatilePtr()) break :single_item;
+                if (inst_ty.isVolatilePtr() and !dest_info.@"volatile") break :single_item;
-                if (inst_ty.ptrAddressSpace() != dest_ty.ptrAddressSpace()) break :single_item;
+                if (inst_ty.ptrAddressSpace() != dest_info.@"addrspace") break :single_item;
                 switch (coerceInMemoryAllowed(array_elem_ty, ptr_elem_ty, dest_is_mut, target)) {
                     .ok => {},
                     .no_match => break :single_item,
 @@ -12012,18 +12027,18 @@ fn coerce(
                 const array_ty = inst_ty.childType();
                 if (array_ty.zigTypeTag() != .Array) break :src_array_ptr;
                 const array_elem_type = array_ty.childType();
-                const dest_is_mut = !dest_ty.isConstPtr();
+                const dest_is_mut = dest_info.mutable;
                 if (inst_ty.isConstPtr() and dest_is_mut) break :src_array_ptr;
-                if (inst_ty.isVolatilePtr() and !dest_ty.isVolatilePtr()) break :src_array_ptr;
+                if (inst_ty.isVolatilePtr() and !dest_info.@"volatile") break :src_array_ptr;
-                if (inst_ty.ptrAddressSpace() != dest_ty.ptrAddressSpace()) break :src_array_ptr;
+                if (inst_ty.ptrAddressSpace() != dest_info.@"addrspace") break :src_array_ptr;
-                const dst_elem_type = dest_ty.childType();
+                const dst_elem_type = dest_info.pointee_type;
                 switch (coerceInMemoryAllowed(dst_elem_type, array_elem_type, dest_is_mut, target)) {
                     .ok => {},
                     .no_match => break :src_array_ptr,
                 }
-                switch (dest_ty.ptrSize()) {
+                switch (dest_info.size) {
                     .Slice => {
                         // *[N]T to []T
                         return sema.coerceArrayPtrToSlice(block, dest_ty, inst, inst_src);
 @@ -12036,7 +12051,7 @@ fn coerce(
                         // *[N]T to [*]T
                         // *[N:s]T to [*:s]T
                         // *[N:s]T to [*]T
-                        if (dest_ty.sentinel()) |dst_sentinel| {
+                        if (dest_info.sentinel) |dst_sentinel| {
                             if (array_ty.sentinel()) |src_sentinel| {
                                 if (src_sentinel.eql(dst_sentinel, dst_elem_type)) {
                                     return sema.coerceCompatiblePtrs(block, dest_ty, inst, inst_src);
 @@ -12051,9 +12066,24 @@ fn coerce(
             }
             // coercion to C pointer
-            if (dest_ty.ptrSize() == .C) {
+            if (dest_info.size == .C) {
-                if (inst_ty.zigTypeTag() == .Null) {
+                switch (inst_ty.zigTypeTag()) {
-                    return sema.addConstant(dest_ty, Value.@"null");
+                    .Null => {
+                        return sema.addConstant(dest_ty, Value.@"null");
+                    },
+                    .ComptimeInt => {
+                        const addr = try sema.coerce(block, Type.usize, inst, inst_src);
+                        return sema.coerceCompatiblePtrs(block, dest_ty, addr, inst_src);
+                    },
+                    .Int => {
+                        const ptr_size_ty = switch (inst_ty.intInfo(target).signedness) {
+                            .signed => Type.isize,
+                            .unsigned => Type.usize,
+                        };
+                        const addr = try sema.coerce(block, ptr_size_ty, inst, inst_src);
+                        return sema.coerceCompatiblePtrs(block, dest_ty, addr, inst_src);
+                    },
+                    else => {},
                 }
             }
         },
 @@ -13632,6 +13662,19 @@ fn resolvePeerTypes(
             continue;
         }
+        if (chosen_ty_tag == .Pointer and chosen_ty.ptrSize() == .C and
+            (candidate_ty_tag == .Int or candidate_ty_tag == .ComptimeInt))
+        {
+            continue;
+        }
+        if (candidate_ty_tag == .Pointer and candidate_ty.ptrSize() == .C and
+            (chosen_ty_tag == .Int or chosen_ty_tag == .ComptimeInt))
+        {
+            chosen = candidate;
+            chosen_i = candidate_i + 1;
+            continue;
+        }
         if (chosen_ty_tag == .ComptimeFloat and candidate_ty_tag == .ComptimeInt)
             continue;
         if (chosen_ty_tag == .ComptimeInt and candidate_ty_tag == .ComptimeFloat) {

src/codegen/llvm.zig+4-3

...	@@ -1106,7 +1106,7 @@ pub const DeclGen = struct {	...	@@ -1106,7 +1106,7 @@ pub const DeclGen = struct {
1106	return parent_ptr.constInBoundsGEP(&indices, indices.len);	1106	return parent_ptr.constInBoundsGEP(&indices, indices.len);
1107	}	1107	}
1108	},	1108	},
1109	.null_value => {	1109	.null_value, .zero => {
1110	const llvm_type = try self.llvmType(tv.ty);	1110	const llvm_type = try self.llvmType(tv.ty);
1111	return llvm_type.constNull();	1111	return llvm_type.constNull();
1112	},	1112	},
...	@@ -3180,8 +3180,9 @@ pub const FuncGen = struct {	...	@@ -3180,8 +3180,9 @@ pub const FuncGen = struct {
3180	const inst_ty = self.air.typeOfIndex(inst);	3180	const inst_ty = self.air.typeOfIndex(inst);
3181	const llvm_dest_ty = try self.dg.llvmType(inst_ty);	3181	const llvm_dest_ty = try self.dg.llvmType(inst_ty);
3182		3182
3183	// TODO look into pulling this logic out into a different AIR instruction than bitcast	3183	if (operand_ty.zigTypeTag() == .Int and inst_ty.zigTypeTag() == .Pointer) {
3184	if (operand_ty.zigTypeTag() == .Vector and inst_ty.zigTypeTag() == .Array) {	3184	return self.builder.buildIntToPtr(operand, llvm_dest_ty, "");
		3185	} else if (operand_ty.zigTypeTag() == .Vector and inst_ty.zigTypeTag() == .Array) {
3185	const target = self.dg.module.getTarget();	3186	const target = self.dg.module.getTarget();
3186	const elem_ty = operand_ty.childType();	3187	const elem_ty = operand_ty.childType();
3187	if (!isByRef(inst_ty)) {	3188	if (!isByRef(inst_ty)) {

src/type.zig+1

...	@@ -4006,6 +4006,7 @@ pub const Type = extern union {	...	@@ -4006,6 +4006,7 @@ pub const Type = extern union {
4006	pub const @"u8" = initTag(.u8);	4006	pub const @"u8" = initTag(.u8);
4007	pub const @"bool" = initTag(.bool);	4007	pub const @"bool" = initTag(.bool);
4008	pub const @"usize" = initTag(.usize);	4008	pub const @"usize" = initTag(.usize);
		4009	pub const @"isize" = initTag(.isize);
4009	pub const @"comptime_int" = initTag(.comptime_int);	4010	pub const @"comptime_int" = initTag(.comptime_int);
4010	pub const @"void" = initTag(.void);	4011	pub const @"void" = initTag(.void);
4011	pub const @"type" = initTag(.type);	4012	pub const @"type" = initTag(.type);

src/value.zig+14-8

 @@ -937,9 +937,10 @@ pub const Value = extern union {
         }
     }
-    /// Asserts the value is an integer and it fits in a u64
+    /// If the value fits in a u64, return it, otherwise null.
-    pub fn toUnsignedInt(self: Value) u64 {
+    /// Asserts not undefined.
-        switch (self.tag()) {
+    pub fn getUnsignedInt(val: Value) ?u64 {
+        switch (val.tag()) {
             .zero,
             .bool_false,
             .the_only_possible_value, // i0, u0
 @@ -949,16 +950,21 @@ pub const Value = extern union {
             .bool_true,
             => return 1,
-            .int_u64 => return self.castTag(.int_u64).?.data,
+            .int_u64 => return val.castTag(.int_u64).?.data,
-            .int_i64 => return @intCast(u64, self.castTag(.int_i64).?.data),
+            .int_i64 => return @intCast(u64, val.castTag(.int_i64).?.data),
-            .int_big_positive => return self.castTag(.int_big_positive).?.asBigInt().to(u64) catch unreachable,
+            .int_big_positive => return val.castTag(.int_big_positive).?.asBigInt().to(u64) catch null,
-            .int_big_negative => return self.castTag(.int_big_negative).?.asBigInt().to(u64) catch unreachable,
+            .int_big_negative => return val.castTag(.int_big_negative).?.asBigInt().to(u64) catch null,
             .undef => unreachable,
-            else => unreachable,
+            else => return null,
         }
     }
+    /// Asserts the value is an integer and it fits in a u64
+    pub fn toUnsignedInt(val: Value) u64 {
+        return getUnsignedInt(val).?;
+    }
     /// Asserts the value is an integer and it fits in a i64
     pub fn toSignedInt(self: Value) i64 {
         switch (self.tag()) {

test/behavior/pointers.zig+35

...	@@ -58,3 +58,38 @@ test "initialize const optional C pointer to null" {	...	@@ -58,3 +58,38 @@ test "initialize const optional C pointer to null" {
58	try expect(a == null);	58	try expect(a == null);
59	comptime try expect(a == null);	59	comptime try expect(a == null);
60	}	60	}
		61
		62	test "assigning integer to C pointer" {
		63	var x: i32 = 0;
		64	var ptr: [*c]u8 = 0;
		65	var ptr2: [*c]u8 = x;
		66	if (false) {
		67	ptr;
		68	ptr2;
		69	}
		70	}
		71
		72	test "C pointer comparison and arithmetic" {
		73	const S = struct {
		74	fn doTheTest() !void {
		75	var ptr1: [*c]u32 = 0;
		76	var ptr2 = ptr1 + 10;
		77	try expect(ptr1 == 0);
		78	try expect(ptr1 >= 0);
		79	try expect(ptr1 <= 0);
		80	// expect(ptr1 < 1);
		81	// expect(ptr1 < one);
		82	// expect(1 > ptr1);
		83	// expect(one > ptr1);
		84	try expect(ptr1 < ptr2);
		85	try expect(ptr2 > ptr1);
		86	try expect(ptr2 >= 40);
		87	try expect(ptr2 == 40);
		88	try expect(ptr2 <= 40);
		89	ptr2 -= 10;
		90	try expect(ptr1 == ptr2);
		91	}
		92	};
		93	try S.doTheTest();
		94	comptime try S.doTheTest();
		95	}

test/behavior/pointers_stage1.zig-35

...	@@ -19,41 +19,6 @@ fn testDerefPtrOneVal() !void {	...	@@ -19,41 +19,6 @@ fn testDerefPtrOneVal() !void {
19	try expect(@TypeOf(y.x) == void);	19	try expect(@TypeOf(y.x) == void);
20	}	20	}
21		21
22	test "assigning integer to C pointer" {
23	var x: i32 = 0;
24	var ptr: [*c]u8 = 0;
25	var ptr2: [*c]u8 = x;
26	if (false) {
27	ptr;
28	ptr2;
29	}
30	}
31
32	test "C pointer comparison and arithmetic" {
33	const S = struct {
34	fn doTheTest() !void {
35	var ptr1: [*c]u32 = 0;
36	var ptr2 = ptr1 + 10;
37	try expect(ptr1 == 0);
38	try expect(ptr1 >= 0);
39	try expect(ptr1 <= 0);
40	// expect(ptr1 < 1);
41	// expect(ptr1 < one);
42	// expect(1 > ptr1);
43	// expect(one > ptr1);
44	try expect(ptr1 < ptr2);
45	try expect(ptr2 > ptr1);
46	try expect(ptr2 >= 40);
47	try expect(ptr2 == 40);
48	try expect(ptr2 <= 40);
49	ptr2 -= 10;
50	try expect(ptr1 == ptr2);
51	}
52	};
53	try S.doTheTest();
54	comptime try S.doTheTest();
55	}
56
57	test "peer type resolution with C pointers" {	22	test "peer type resolution with C pointers" {
58	var ptr_one: *u8 = undefined;	23	var ptr_one: *u8 = undefined;
59	var ptr_many: [*]u8 = undefined;	24	var ptr_many: [*]u8 = undefined;

author	Andrew Kelley <andrew@ziglang.org> 2021-10-23 19:46:48-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-10-23 19:47:32-07:00
log	22b4c9e1a9595bd94ada4c500a430e2668ffcd07
tree	325e312f063422e19b0427373194b703b8cc3b53
parent	ee98d8700818aa667137e3aa580b16df2ba6d680

stage2: implement more C pointer Sema and comptime ptr arith