Resolve peer types for C pointers

Author: FnControlOption

src/analysis.zig

@@ -3134,6 +3134,7 @@ pub const Type = struct {
                     const b_type = b.pointer;
                     if (a_type.size != b_type.size) return false;
                     if (a_type.sentinel != b_type.sentinel) return false;
+                    if (a_type.is_const != b_type.is_const) return false;
                     if (!a_type.elem_ty.eql(b_type.elem_ty.*)) return false;
                 },
                 .array => |a_type| {
@@ -4057,6 +4058,62 @@ pub const Type = struct {
         };
     }
 
+    const PointerInfo = struct {
+        elem_ty: Type,
+        sentinel: InternPool.Index,
+        flags: InternPool.Key.Pointer.Flags,
+    };
+
+    fn pointerInfo(ty: Type, analyser: *Analyser) ?PointerInfo {
+        if (!ty.is_type_val) return null;
+        return blk: switch (ty.data) {
+            .pointer => |info| .{
+                .elem_ty = info.elem_ty.*,
+                .sentinel = info.sentinel,
+                .flags = .{
+                    .size = info.size,
+                    .is_const = info.is_const,
+                },
+            },
+            .ip_index => |payload| switch (analyser.ip.indexToKey(payload.index orelse return null)) {
+                .pointer_type => |info| .{
+                    .elem_ty = Type.fromIP(analyser, .type_type, info.elem_type),
+                    .sentinel = info.sentinel,
+                    .flags = info.flags,
+                },
+                else => null,
+            },
+            .optional => |child| switch (child.data) {
+                .pointer => continue :blk child.data,
+                .ip_index => |payload| switch (analyser.ip.indexToKey(payload.index orelse return null)) {
+                    .pointer_type => continue :blk child.data,
+                    else => null,
+                },
+                else => null,
+            },
+            else => null,
+        };
+    }
+
+    fn isPointerAtRuntime(ty: Type, analyser: *Analyser) bool {
+        if (ty.pointerInfo(analyser)) |info| {
+            return switch (info.flags.size) {
+                .slice => false,
+                .one, .many, .c => true,
+            };
+        }
+        switch (ty.data) {
+            .optional => |child| {
+                const p = child.pointerInfo(analyser) orelse return false;
+                return switch (p.flags.size) {
+                    .slice, .c => false,
+                    .many, .one => !p.flags.is_allowzero,
+                };
+            },
+            else => return false,
+        }
+    }
+
     pub fn stringifyTypeOf(ty: Type, analyser: *Analyser, options: FormatOptions) error{OutOfMemory}![]const u8 {
         const typeof = try ty.typeOf(analyser);
         var aw: std.io.Writer.Allocating = .init(analyser.arena);
@@ -6660,7 +6717,64 @@ fn resolvePeerTypesInner(analyser: *Analyser, peer_tys: []?Type) !?Type {
 
         .vector => return null, // TODO
 
-        .c_ptr => return null, // TODO
+        .c_ptr => {
+            var opt_ptr_info: ?Type.PointerInfo = null;
+            for (peer_tys) |opt_ty| {
+                const ty = opt_ty orelse continue;
+                switch (ty.zigTypeTag(analyser).?) {
+                    .comptime_int => continue,
+                    .int => {
+                        const ptr_bits = builtin.target.ptrBitWidth();
+                        const bits = analyser.ip.intInfo(ty.data.ip_index.index.?, builtin.target).bits;
+                        if (bits >= ptr_bits) continue;
+                    },
+                    .null => continue,
+                    else => {},
+                }
+
+                if (!ty.isPointerAtRuntime(analyser)) {
+                    return null;
+                }
+
+                const peer_info = ty.pointerInfo(analyser).?;
+
+                var ptr_info = opt_ptr_info orelse {
+                    opt_ptr_info = peer_info;
+                    continue;
+                };
+
+                if (!ptr_info.elem_ty.eql(peer_info.elem_ty)) {
+                    // TODO: coerce C pointer types
+                    return null;
+                }
+
+                if (ptr_info.flags.alignment != ptr_info.flags.alignment) {
+                    // TODO: find minimum C pointer alignment
+                    return null;
+                }
+
+                if (ptr_info.flags.address_space != peer_info.flags.address_space) {
+                    return null;
+                }
+
+                ptr_info.flags.is_const = ptr_info.flags.is_const or peer_info.flags.is_const;
+                ptr_info.flags.is_volatile = ptr_info.flags.is_volatile or peer_info.flags.is_volatile;
+
+                opt_ptr_info = ptr_info;
+            }
+            const info = opt_ptr_info.?;
+            return .{
+                .data = .{
+                    .pointer = .{
+                        .elem_ty = try analyser.allocType(info.elem_ty),
+                        .sentinel = .none,
+                        .size = .c,
+                        .is_const = info.flags.is_const,
+                    },
+                },
+                .is_type_val = true,
+            };
+        },
 
         .ptr => return null, // TODO
 

tests/analysis/pointer.zig

@@ -65,6 +65,13 @@ const one_minus_slice = one_u32 - slice_u32;
 const one_minus_c = one_u32 - c_u32;
 //    ^^^^^^^^^^^ (usize)()
 
+//
+// array pointer *[n]T
+//
+
+const array_u32: *const [2]u32 = &[_]u32{ 1, 2 };
+//    ^^^^^^^^^ (*const [2]u32)()
+
 //
 // many item pointer [*]T
 //
@@ -234,6 +241,21 @@ const c_minus_slice = c_u32 - slice_u32;
 const c_minus_c = c_u32 - c_u32;
 //    ^^^^^^^^^ (usize)()
 
+const c_u32_or_one_u32 = if (runtime_bool) c_u32 else one_u32;
+//    ^^^^^^^^^^^^^^^^ ([*c]const u32)()
+
+const c_u32_or_array_u32 = if (runtime_bool) c_u32 else array_u32;
+//    ^^^^^^^^^^^^^^^^^^ (either type)()
+
+const c_u32_or_many_u32 = if (runtime_bool) c_u32 else many_u32;
+//    ^^^^^^^^^^^^^^^^^ ([*c]const u32)()
+
+const c_u32_or_slice_u32 = if (runtime_bool) c_u32 else slice_u32;
+//    ^^^^^^^^^^^^^^^^^^ (either type)()
+
+const c_u32_or_c_u32 = if (runtime_bool) c_u32 else c_u32;
+//    ^^^^^^^^^^^^^^ ([*c]const u32)()
+
 var runtime_index: usize = 5;
 var runtime_u8: u8 = 1;
 var runtime_i8: i8 = -1;