tiny.choir.OperationEquivalence

1pub const OperationEquivalence = struct {2    pub const ValueMapper = *const fn (?*const anyopaque, *Value) *Value;34    pub const AttributeFilter = *const fn (?*const anyopaque, *Operation, NamedAttribute) bool;56    pub const Options = struct {7        value_mapper: ?ValueMapper = null,8        value_mapper_context: ?*const anyopaque = null,9        attribute_filter: ?AttributeFilter = null,10        attribute_filter_context: ?*const anyopaque = null,11        commute_operands: bool = false,12        include_locations: bool = false,13    };1415    pub fn computeHash(16        op: *Operation,17        options: Options,18    ) u64 {19        var hasher = std.hash.Wyhash.init(0);2021        updateBytes(&hasher, op.name.name);22        updateU64(&hasher, op.regions.items.len);23        updateU64(&hasher, op.successors.items.len);24        updateU64(&hasher, op.result_types.len);25        for (op.result_types) |typ| {26            updateU64(&hasher, typ.uniqueId());27        }2829        if (options.include_locations) {30            updateLocation(&hasher, op.location);31        }3233        const operands = op.operand_values;34        updateU64(&hasher, operands.len);35        if (options.commute_operands and operands.len > 1) {36            var operand_hash: u64 = 0;37            for (operands) |operand| {38                operand_hash +%= valueHash(options, operand);39            }40            updateU64(&hasher, operand_hash);41        } else {42            for (operands) |operand| {43                updateU64(&hasher, valueHash(options, operand));44            }45        }4647        var hash_iter = op.getAttrs();48        while (hash_iter.next()) |attr| {49            if (!attributeIncluded(options, op, attr)) continue;50            updateBytes(&hasher, attr.name);51            updateAttribute(&hasher, attr.value);52        }5354        return hasher.final();55    }5657    pub fn isEquivalentTo(58        lhs: *Operation,59        rhs: *Operation,60        options: Options,61    ) bool {62        if (lhs == rhs) return true;63        if (!sameName(lhs.name.name, rhs.name.name)) return false;64        if (lhs.regions.items.len != rhs.regions.items.len) return false;65        if (lhs.successors.items.len != rhs.successors.items.len) return false;66        if (lhs.operands.items.len != rhs.operands.items.len) return false;67        if (lhs.result_types.len != rhs.result_types.len) return false;68        if (options.include_locations and !lhs.location.eql(rhs.location)) return false;6970        for (lhs.result_types, rhs.result_types) |lhs_type, rhs_type| {71            if (!lhs_type.eql(rhs_type)) return false;72        }7374        if (!operandsEquivalent(lhs.operand_values, rhs.operand_values, options)) {75            return false;76        }7778        return attrsEquivalent(lhs, rhs, options);79    }8081    pub fn exactValueMapper(_: ?*const anyopaque, value: *Value) *Value {82        return value;83    }8485    fn valueHash(options: Options, value: *Value) u64 {86        return @intFromPtr(mapValue(options, value));87    }8889    fn mapValue(options: Options, value: *Value) *Value {90        if (options.value_mapper) |mapper| {91            return mapper(options.value_mapper_context, value);92        }93        return value;94    }9596    fn attributeIncluded(options: Options, op: *Operation, attr: NamedAttribute) bool {97        if (options.attribute_filter) |filter| {98            return filter(options.attribute_filter_context, op, attr);99        }100        return true;101    }102};

1pub const OperationEquivalence = ir.OperationEquivalence;