tiny.choir.StableHasher

1pub const StableHasher = struct {2    pub const claim: alloc_phase.capacity.Declaration = .{3        .source = .{4            .id = "choir.stable_hasher",5            .kind = .phase_static,6            .limit_source = .caller,7            .storage = .{8                .covered = &.{9                    .{10                        .id = "the_complete_stablevaluenumbering_claim_plus_inline_d8f50bb9374f",11                        .lifetime = .steady,12                        .detail = "the complete StableValueNumbering claim plus inline Wyhash and scalar state",13                    },14                },15                .excluded = &.{16                    "borrowed mutable IR and referenced type and attribute payloads",17                },18            },19            .capacity = .{20                .inputs = &.{21                    alloc_phase.capacity.bindInput(Limits, "facts_value_count", "facts.value_count"),22                    alloc_phase.capacity.bindInput(Limits, "facts_operation_depth", "facts.operation_depth"),23                    alloc_phase.capacity.bindInput(Limits, "facts_attribute_depth", "facts.attribute_depth"),24                },25                .type_selectors = &.{26                    alloc_phase.capacity.bindType(capacity_model.ValueEntry, "valueentry"),27                    alloc_phase.capacity.bindType(capacity_model.OperationFrame, "operationframe"),28                    alloc_phase.capacity.bindType(capacity_model.AttributeFrame, "attributeframe"),29                    alloc_phase.capacity.bindType(std.hash.Wyhash, "hasher"),30                },31                .nodes = &.{32                    .{ .input = 0 },33                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },34                    .{ .input = 1 },35                    .{ .scale = .{ .node = 2, .coefficient = .{ .size_of_concrete_type = 1 } } },36                    .{ .input = 2 },37                    .{ .scale = .{ .node = 4, .coefficient = .{ .size_of_concrete_type = 2 } } },38                    .{ .constant = 1 },39                    .{ .scale = .{ .node = 6, .coefficient = .{ .size_of_concrete_type = 3 } } },40                    .{ .add = .{ .left = 1, .right = 3 } },41                    .{ .add = .{ .left = 8, .right = 5 } },42                    .{ .add = .{ .left = 9, .right = 7 } },43                },44                .assertions = &.{.{45                    .scope = .closure_total,46                    .measure = .retained,47                    .relation = .exact,48                    .expression = 10,49                }},50            },51            .overload = .{52                .kind = .reject_before_seal,53                .detail = "nesting, arithmetic, OOM, stale facts, or definition drift rejects before activation",54            },55            .risks = .{56                .transitive = .{57                    .status = .open,58                    .detail = "fingerprint reaches the indirect OperationPropertiesModel.getInherentAttr hook",59                },60                .foreign = .{61                    .status = .open,62                    .detail = "property hook implementations may reacquire allocator policy or cross foreign boundaries",63                },64            },65            .dependencies = &.{"choir.stable_value_numbering"},66            .obligations = &.{67                .{ .key = "hasher_capacity", .role = .capacity_model },68                .{ .key = "hasher_sealed_fingerprint_transitive_risk", .role = .transitive_risk },69                .{ .key = "hasher_sealed_fingerprint_foreign_risk", .role = .foreign_risk },70                .{ .key = "hasher_oom_retry", .role = .overload },71                .{ .key = "hasher_stale_limits", .role = .overload },72            },73        },74        .bindings = .{75            .owner = @This(),76            .seal = .{77                .family = alloc_phase.capacity.selector(@This().activate),78                .premise = .{79                    .class = .checked_semantic_fact,80                    .authority = .checker,81                },82            },83            .teardown = .{84                .family = alloc_phase.capacity.selector(@This().deinit),85                .premise = .{86                    .class = .checked_semantic_fact,87                    .authority = .checker,88                },89            },90        },91    };92    phase: alloc_phase.capacity.Phase,93    capacity: Capacity,94    numbering: numbering.StableValueNumbering,95    hasher: std.hash.Wyhash,96    definitions_seen: u64,9798    pub const Limits = capacity_model.Limits;99    pub const Capacity = capacity_model.Capacity;100101    const Self = @This();102103    pub fn init(allocator: Allocator, limits: Limits) !Self {104        const value_numbering = try numbering.StableValueNumbering.init(allocator, limits);105        return .{106            .phase = .initialization,107            .capacity = value_numbering.capacity,108            .numbering = value_numbering,109            .hasher = std.hash.Wyhash.init(0),110            .definitions_seen = 0,111        };112    }113114    pub fn activate(self: *Self) error{ AlreadyActive, InputChanged }!void {115        if (self.phase != .initialization) return error.AlreadyActive;116        try self.numbering.activate();117        self.phase = .steady;118    }119120    pub fn fingerprint(self: *Self) u64 {121        self.requireSteady();122        self.hasher = std.hash.Wyhash.init(0);123        self.definitions_seen = 0;124        var iterator = walk.Iterator.init(125            self.numbering.operation_frames,126            self.numbering.root,127        );128        while (iterator.next()) |event| switch (event) {129            .operation => |operation| self.visitOperation(operation),130            .region => {},131            .block => |block| self.visitBlock(block),132        };133        if (self.definitions_seen != self.capacity.facts.value_count) {134            @panic("stable hashing definitions changed after activation");135        }136        return self.hasher.final();137    }138139    pub fn deinit(self: *Self, allocator: Allocator) void {140        if (self.phase == .teardown) @panic("stable hasher teardown is terminal");141        self.phase = .teardown;142        self.numbering.deinit(allocator);143        self.hasher = undefined;144        self.definitions_seen = undefined;145    }146147    fn visitOperation(self: *Self, operation: *ir.Operation) void {148        self.update(operation.getName().name);149150        var attrs = operation.getAttrs();151        while (attrs.next()) |attr| {152            self.update(attr.name);153            self.visitAttribute(attr.value);154        }155156        self.updateU64(operation.getNumResults());157        for (operation.results.items) |*result| {158            self.visitType(result.type);159            self.registerValue(result);160        }161162        self.updateU64(operation.getNumOperands());163        for (operation.operands.items) |operand| self.visitValueUse(operand.value);164        self.updateU64(operation.getNumRegions());165    }166167    fn visitBlock(self: *Self, block: *ir.Block) void {168        self.updateU64(block.getNumArguments());169        for (block.arguments.items) |argument| {170            self.visitType(argument.type);171            self.registerValue(argument);172        }173    }174175    fn registerValue(self: *Self, value: *const ir.Value) void {176        const id = self.numbering.valueId(value) orelse177            @panic("stable hashing definition was not indexed");178        if (id != self.definitions_seen) {179            @panic("stable hashing definition order changed after activation");180        }181        self.definitions_seen += 1;182    }183184    fn visitValueUse(self: *Self, value: *const ir.Value) void {185        if (self.numbering.valueId(value)) |id| {186            if (id < self.definitions_seen) {187                self.updateU64(id);188                return;189            }190        }191        self.updateU64(std.math.maxInt(u64));192    }193194    fn visitType(self: *Self, typ: ir.Type) void {195        if (typ.getDialectStorage()) |storage| {196            self.update(storage.name);197            if (storage.param_key.len > 0) self.update(storage.param_key);198            return;199        }200        self.updateU64(@intFromPtr(typ.impl));201    }202203    fn visitAttribute(self: *Self, root: ir.Attribute) void {204        var current: ?ir.Attribute = root;205        var depth: usize = 0;206        const frames = self.numbering.attribute_frames;207        while (true) {208            if (current) |attr| {209                self.update(attr.abstract.name);210211                if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.integer)) {212                    if (attr.cast(ir.Attribute.IntegerAttr)) |integer| {213                        self.updateU64(@bitCast(integer.value));214                        self.update(&[_]u8{integer.width});215                        self.update(&[_]u8{if (integer.is_signed) 1 else 0});216                    } else {217                        self.updateU64(@intFromPtr(attr.impl));218                    }219                } else if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.float_)) {220                    if (attr.cast(ir.Attribute.FloatAttr)) |float| {221                        self.updateU64(@bitCast(float.value));222                        self.update(&[_]u8{float.width});223                    } else {224                        self.updateU64(@intFromPtr(attr.impl));225                    }226                } else if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.bool_)) {227                    if (attr.cast(ir.Attribute.BoolAttr)) |boolean| {228                        self.update(&[_]u8{if (boolean.value) 1 else 0});229                    } else {230                        self.updateU64(@intFromPtr(attr.impl));231                    }232                } else if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.string)) {233                    if (attr.cast(ir.Attribute.StringAttr)) |string| {234                        self.update(string.value);235                    } else {236                        self.updateU64(@intFromPtr(attr.impl));237                    }238                } else if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.symbol_ref)) {239                    if (attr.cast(ir.Attribute.SymbolRefAttr)) |symbol| {240                        self.updateU64(@intCast(symbol.root_reference.len));241                        self.update(symbol.root_reference);242                        self.updateU64(@intCast(symbol.nested_references.len));243                        for (symbol.nested_references) |nested| {244                            self.updateU64(@intCast(nested.len));245                            self.update(nested);246                        }247                    } else {248                        self.updateU64(@intFromPtr(attr.impl));249                    }250                } else if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.string_list)) {251                    if (attr.cast(ir.Attribute.StringListAttr)) |list| {252                        self.updateU64(@intCast(list.values.len));253                        for (list.values) |value| {254                            self.updateU64(@intCast(value.len));255                            self.update(value);256                        }257                    } else {258                        self.updateU64(@intFromPtr(attr.impl));259                    }260                } else if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.type_list)) {261                    if (attr.cast(ir.Attribute.TypeListAttr)) |list| {262                        self.updateU64(@intCast(list.values.len));263                        for (list.values) |typ| self.visitType(typ);264                    } else {265                        self.updateU64(@intFromPtr(attr.impl));266                    }267                } else if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.array)) {268                    if (attr.cast(ir.Attribute.ArrayAttr)) |array| {269                        self.updateU64(@intCast(array.values.len));270                        if (array.values.len > 0) {271                            if (depth >= frames.len) {272                                @panic("attribute traversal exceeded inspected depth");273                            }274                            frames[depth] = .{ .values = array.values, .next_index = 1 };275                            depth += 1;276                            current = array.values[0];277                            continue;278                        }279                    } else {280                        self.updateU64(@intFromPtr(attr.impl));281                    }282                } else if (attr.cast(ir.Attribute.DialectAttr)) |dialect| {283                    self.update(dialect.payload);284                } else {285                    self.updateU64(@intFromPtr(attr.impl));286                }287            }288289            current = null;290            while (depth > 0) {291                const frame = &frames[depth - 1];292                if (frame.next_index < frame.values.len) {293                    current = frame.values[frame.next_index];294                    frame.next_index += 1;295                    break;296                }297                depth -= 1;298            }299            if (current == null) return;300        }301    }302303    fn update(self: *Self, bytes: []const u8) void {304        self.hasher.update(bytes);305    }306307    fn updateU64(self: *Self, value: u64) void {308        self.hasher.update(std.mem.asBytes(&value));309    }310311    fn requireSteady(self: *const Self) void {312        if (self.phase != .steady) @panic("stable hasher used outside its steady phase");313    }314};

1pub const StableHasher = product.StableHasher;