[Mlir-commits] [mlir] [mlirbc][builtin] Add regression test. (PR #186078)
Jacques Pienaar
llvmlistbot at llvm.org
Thu Mar 12 03:14:51 PDT 2026
https://github.com/jpienaar created https://github.com/llvm/llvm-project/pull/186078
Add test to avoid accidental serialization changes.
>From 27b63917aff119d5cf839d9d3e5ab2b8374465a0 Mon Sep 17 00:00:00 2001
From: Jacques Pienaar <jpienaar at google.com>
Date: Thu, 12 Mar 2026 12:01:26 +0200
Subject: [PATCH] [mlirbc][builtin] Add regression test.
Add test to avoid accidental serialization changes.
---
.../Builtin/Bytecode/builtin_fixed.mlir | 444 ++++++++++++++++++
.../Builtin/Bytecode/builtin_fixed.mlirbc | Bin 0 -> 5297 bytes
2 files changed, 444 insertions(+)
create mode 100644 mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlir
create mode 100644 mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlirbc
diff --git a/mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlir b/mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlir
new file mode 100644
index 0000000000000..4f4828d4fba96
--- /dev/null
+++ b/mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlir
@@ -0,0 +1,444 @@
+// RUN: mlir-opt -allow-unregistered-dialect -emit-bytecode -emit-bytecode-producer=fixed %s -o %t
+// Verify unchanged.
+// RUN: cmp -s %t %p/builtin_fixed.mlirbc
+// Verify can read as expected.
+// RUN: mlir-opt -allow-unregistered-dialect -mlir-print-local-scope %t | FileCheck %s
+
+// Regression test for all builtin dialect bytecode attribute and
+// type encodings. Exercises every entry in BuiltinDialectAttributes and
+// BuiltinDialectTypes including special cases (splats, empty containers,
+// new float types, ranges, etc.) [to be confirmed].
+
+// allow-unregisterd-dialect is set to allow for the string constant types.
+
+//===----------------------------------------------------------------------===//
+// ArrayAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestArrayAttr
+module @TestArrayAttr attributes {
+ // CHECK-DAG: bytecode.empty = []
+ // CHECK-DAG: bytecode.single = [unit]
+ // CHECK-DAG: bytecode.nested = {{\[}}[1 : i32, 2 : i32], [3 : i32]]
+ bytecode.empty = [],
+ bytecode.single = [unit],
+ bytecode.nested = [[1 : i32, 2 : i32], [3 : i32]]
+} {}
+
+//===----------------------------------------------------------------------===//
+// DictionaryAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestDictionaryAttr
+module @TestDictionaryAttr attributes {
+ // CHECK-DAG: bytecode.empty_dict = {}
+ // CHECK-DAG: bytecode.nested_dict = {inner = {a = 1 : i32}}
+ bytecode.empty_dict = {},
+ bytecode.nested_dict = {inner = {a = 1 : i32}}
+} {}
+
+//===----------------------------------------------------------------------===//
+// StringAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestStringAttr
+module @TestStringAttr attributes {
+ // CHECK-DAG: bytecode.plain = "hello world"
+ // CHECK-DAG: bytecode.empty_str = ""
+ // CHECK-DAG: bytecode.typed = "typed" : i32
+ bytecode.plain = "hello world",
+ bytecode.empty_str = "",
+ bytecode.typed = "typed" : i32
+} {}
+
+//===----------------------------------------------------------------------===//
+// FlatSymbolRefAttr / SymbolRefAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestSymbolRefAttr
+module @TestSymbolRefAttr attributes {
+ // CHECK-DAG: bytecode.flat = @flat_sym
+ // CHECK-DAG: bytecode.nested = @root::@child1::@child2
+ bytecode.flat = @flat_sym,
+ bytecode.nested = @root::@child1::@child2
+} {}
+
+//===----------------------------------------------------------------------===//
+// TypeAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestTypeAttr
+module @TestTypeAttr attributes {
+ // CHECK-DAG: bytecode.type_i32 = i32
+ // CHECK-DAG: bytecode.type_memref = memref<2x3xf32>
+ bytecode.type_i32 = i32,
+ bytecode.type_memref = memref<2x3xf32>
+} {}
+
+//===----------------------------------------------------------------------===//
+// UnitAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestUnitAttr
+module @TestUnitAttr attributes {
+ // CHECK-DAG: bytecode.unit
+ bytecode.unit
+} {}
+
+//===----------------------------------------------------------------------===//
+// IntegerAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestIntegerAttr
+module @TestIntegerAttr attributes {
+ // CHECK-DAG: bytecode.bool_false = false
+ // CHECK-DAG: bytecode.bool_true = true
+ // CHECK-DAG: bytecode.i8_neg = -1 : i8
+ // CHECK-DAG: bytecode.i32_val = 42 : i32
+ // CHECK-DAG: bytecode.si32_val = -100 : si32
+ // CHECK-DAG: bytecode.ui64_val = 800 : ui64
+ // CHECK-DAG: bytecode.i128_large = 90000000000000000300000000000000000001 : i128
+ // CHECK-DAG: bytecode.index_val = 7 : index
+ bytecode.bool_false = false,
+ bytecode.bool_true = true,
+ bytecode.i8_neg = -1 : i8,
+ bytecode.i32_val = 42 : i32,
+ bytecode.si32_val = -100 : si32,
+ bytecode.ui64_val = 800 : ui64,
+ bytecode.i128_large = 90000000000000000300000000000000000001 : i128,
+ bytecode.index_val = 7 : index
+} {}
+
+//===----------------------------------------------------------------------===//
+// FloatAttr — all float types
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestFloatAttr
+module @TestFloatAttr attributes {
+ // CHECK-DAG: bytecode.bf16 = -5.000000e-01 : bf16
+ // CHECK-DAG: bytecode.f16 = 1.500000e+00 : f16
+ // CHECK-DAG: bytecode.f32 = 3.140000e+00 : f32
+ // CHECK-DAG: bytecode.f64 = 1.000000e+01 : f64
+ // CHECK-DAG: bytecode.f80 = 0.1{{.*}} : f80
+ // CHECK-DAG: bytecode.f128 = 0.1{{.*}} : f128
+ // CHECK-DAG: bytecode.tf32 = 1.000000e+00 : tf32
+ // CHECK-DAG: bytecode.f8E5M2 = 1.000000e+00 : f8E5M2
+ // CHECK-DAG: bytecode.f8E4M3 = 1.000000e+00 : f8E4M3
+ // CHECK-DAG: bytecode.f8E4M3FN = 1.000000e+00 : f8E4M3FN
+ // CHECK-DAG: bytecode.f8E5M2FNUZ = 1.000000e+00 : f8E5M2FNUZ
+ // CHECK-DAG: bytecode.f8E4M3FNUZ = 1.000000e+00 : f8E4M3FNUZ
+ // CHECK-DAG: bytecode.f8E4M3B11FNUZ = 1.000000e+00 : f8E4M3B11FNUZ
+ // CHECK-DAG: bytecode.f8E3M4 = 1.000000e+00 : f8E3M4
+ // CHECK-DAG: bytecode.f4E2M1FN = 1.000000e+00 : f4E2M1FN
+ // CHECK-DAG: bytecode.f6E2M3FN = 1.000000e+00 : f6E2M3FN
+ // CHECK-DAG: bytecode.f6E3M2FN = 1.000000e+00 : f6E3M2FN
+ // CHECK-DAG: bytecode.f8E8M0FNU = 1.000000e+00 : f8E8M0FNU
+ bytecode.bf16 = -0.5 : bf16,
+ bytecode.f16 = 1.5 : f16,
+ bytecode.f32 = 3.14 : f32,
+ bytecode.f64 = 10.0 : f64,
+ bytecode.f80 = 0.1 : f80,
+ bytecode.f128 = 0.1 : f128,
+ bytecode.tf32 = 1.0 : tf32,
+ bytecode.f8E5M2 = 1.0 : f8E5M2,
+ bytecode.f8E4M3 = 1.0 : f8E4M3,
+ bytecode.f8E4M3FN = 1.0 : f8E4M3FN,
+ bytecode.f8E5M2FNUZ = 1.0 : f8E5M2FNUZ,
+ bytecode.f8E4M3FNUZ = 1.0 : f8E4M3FNUZ,
+ bytecode.f8E4M3B11FNUZ = 1.0 : f8E4M3B11FNUZ,
+ bytecode.f8E3M4 = 1.0 : f8E3M4,
+ bytecode.f4E2M1FN = 1.0 : f4E2M1FN,
+ bytecode.f6E2M3FN = 1.0 : f6E2M3FN,
+ bytecode.f6E3M2FN = 1.0 : f6E3M2FN,
+ bytecode.f8E8M0FNU = 1.0 : f8E8M0FNU
+} {}
+
+//===----------------------------------------------------------------------===//
+// DenseArrayAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestDenseArrayAttr
+module @TestDenseArrayAttr attributes {
+ // CHECK-DAG: bytecode.bool_arr = array<i1: true, false, true>
+ // CHECK-DAG: bytecode.i8_arr = array<i8: 10, 32, -1>
+ // CHECK-DAG: bytecode.i16_arr = array<i16: 100, -200>
+ // CHECK-DAG: bytecode.i32_arr = array<i32: 1, 2, 3>
+ // CHECK-DAG: bytecode.i64_arr = array<i64: 1000000, -1000000>
+ // CHECK-DAG: bytecode.f32_arr = array<f32: 1.000000e+00, 2.000000e+00>
+ // CHECK-DAG: bytecode.f64_arr = array<f64: 3.140000e+00>
+ // CHECK-DAG: bytecode.empty_arr = array<i32>
+ bytecode.bool_arr = array<i1: true, false, true>,
+ bytecode.i8_arr = array<i8: 10, 32, 255>,
+ bytecode.i16_arr = array<i16: 100, -200>,
+ bytecode.i32_arr = array<i32: 1, 2, 3>,
+ bytecode.i64_arr = array<i64: 1000000, -1000000>,
+ bytecode.f32_arr = array<f32: 1.0, 2.0>,
+ bytecode.f64_arr = array<f64: 3.14>,
+ bytecode.empty_arr = array<i32>
+} {}
+
+//===----------------------------------------------------------------------===//
+// DenseIntOrFPElementsAttr — including splats
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestDenseIntOrFPElementsAttr
+module @TestDenseIntOrFPElementsAttr attributes {
+ // Splats
+ // CHECK-DAG: bytecode.splat_i1 = dense<true> : tensor<256xi1>
+ // CHECK-DAG: bytecode.splat_i32 = dense<42> : tensor<4x4xi32>
+ // CHECK-DAG: bytecode.splat_f32 = dense<1.000000e+00> : tensor<2x3xf32>
+ // CHECK-DAG: bytecode.splat_f64 = dense<0.000000e+00> : tensor<8xf64>
+ // Non-splat
+ // CHECK-DAG: bytecode.dense_i1 = dense<[true, false, true]> : tensor<3xi1>
+ // CHECK-DAG: bytecode.dense_i8 = dense<[10, 20, 30]> : tensor<3xi8>
+ // CHECK-DAG: bytecode.dense_f32 = dense<[1.{{.*}}, 2.{{.*}}]> : tensor<2xf32>
+ // Multi-dimensional
+ // CHECK-DAG: bytecode.dense_2d = dense<{{\[}}[1, 2], [3, 4]]> : tensor<2x2xi32>
+ bytecode.splat_i1 = dense<true> : tensor<256xi1>,
+ bytecode.splat_i32 = dense<42> : tensor<4x4xi32>,
+ bytecode.splat_f32 = dense<1.0> : tensor<2x3xf32>,
+ bytecode.splat_f64 = dense<0.0> : tensor<8xf64>,
+ bytecode.dense_i1 = dense<[true, false, true]> : tensor<3xi1>,
+ bytecode.dense_i8 = dense<[10, 20, 30]> : tensor<3xi8>,
+ bytecode.dense_f32 = dense<[1.0, 2.0]> : tensor<2xf32>,
+ bytecode.dense_2d = dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
+} {}
+
+//===----------------------------------------------------------------------===//
+// SparseElementsAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestSparseElementsAttr
+module @TestSparseElementsAttr attributes {
+ // CHECK-LITERAL: bytecode.sparse = sparse<[[0, 0], [1, 2]], [1, 5]> : tensor<3x4xi32>
+ // CHECK-LITERAL: bytecode.sparse_1d = sparse<[1, 3], [10.0, 20.0]> : tensor<5xf32>
+ bytecode.sparse = sparse<[[0, 0], [1, 2]], [1, 5]> : tensor<3x4xi32>,
+ bytecode.sparse_1d = sparse<[1, 3], [10.0, 20.0]> : tensor<5xf32>
+} {}
+
+//===----------------------------------------------------------------------===//
+// DistinctAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestDistinctAttr
+module @TestDistinctAttr attributes {
+ // CHECK-DAG: bytecode.diff = distinct[0]<42 : i32>
+ // CHECK-DAG: bytecode.same1 = distinct[1]<42 : i32>
+ // CHECK-DAG: bytecode.same2 = distinct[1]<42 : i32>
+ bytecode.same1 = distinct[0]<42 : i32>,
+ bytecode.same2 = distinct[0]<42 : i32>,
+ bytecode.diff = distinct[1]<42 : i32>
+} {}
+
+//===----------------------------------------------------------------------===//
+// Location Attributes
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestLocationAttrs
+module @TestLocationAttrs attributes {
+ // CallSiteLoc
+ // CHECK-DAG: bytecode.callsite = loc(callsite("callee" at "caller.cc":5:3))
+ bytecode.callsite = loc(callsite("callee" at "caller.cc":5:3)),
+ // FileLineColLoc
+ // CHECK-DAG: bytecode.flc = loc("source.cc":10:8)
+ bytecode.flc = loc("source.cc":10:8),
+ // FileLineColRange
+ // CHECK-DAG: bytecode.flc_range1 = loc("source.cc":10:8 to 12:4)
+ // CHECK-DAG: bytecode.flc_range2 = loc("source.cc":10:8 to :12)
+ // CHECK-DAG: bytecode.flc_range3 = loc("source.cc":10:8 to 12:8)
+ bytecode.flc_range1 = loc("source.cc":10:8 to 12:4),
+ bytecode.flc_range2 = loc("source.cc":10:8 to :12),
+ bytecode.flc_range3 = loc("source.cc":10:8 to 12:8),
+ // FusedLoc (without metadata)
+ // CHECK-DAG: bytecode.fused = loc(fused["a", "b":1:2])
+ bytecode.fused = loc(fused["a", "b":1:2]),
+ // FusedLoc (with metadata)
+ // CHECK-DAG: bytecode.fused_meta = loc(fused<"myPass">["x", "y"])
+ bytecode.fused_meta = loc(fused<"myPass">["x", "y"]),
+ // NameLoc (without child)
+ // CHECK-DAG: bytecode.name = loc("named")
+ bytecode.name = loc("named"),
+ // NameLoc (with child)
+ // CHECK-DAG: bytecode.name_child = loc("named"("child.cc":1:1))
+ bytecode.name_child = loc("named"("child.cc":1:1)),
+ // UnknownLoc
+ // CHECK-DAG: bytecode.unknown = loc(unknown)
+ bytecode.unknown = loc(unknown)
+} {}
+
+//===----------------------------------------------------------------------===//
+// All Float Types (type-level roundtrip)
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestAllFloatTypes
+module @TestAllFloatTypes attributes {
+ // CHECK-DAG: bytecode.bf16 = bf16
+ // CHECK-DAG: bytecode.f16 = f16
+ // CHECK-DAG: bytecode.f32 = f32
+ // CHECK-DAG: bytecode.f64 = f64
+ // CHECK-DAG: bytecode.f80 = f80
+ // CHECK-DAG: bytecode.f128 = f128
+ bytecode.bf16 = bf16,
+ bytecode.f16 = f16,
+ bytecode.f32 = f32,
+ bytecode.f64 = f64,
+ bytecode.f80 = f80,
+ bytecode.f128 = f128
+} {}
+
+//===----------------------------------------------------------------------===//
+// IntegerType, IndexType, NoneType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestBasicTypes
+module @TestBasicTypes attributes {
+ // CHECK-DAG: bytecode.i1 = i1
+ // CHECK-DAG: bytecode.i8 = i8
+ // CHECK-DAG: bytecode.i32 = i32
+ // CHECK-DAG: bytecode.i1024 = i1024
+ // CHECK-DAG: bytecode.si32 = si32
+ // CHECK-DAG: bytecode.ui64 = ui64
+ // CHECK-DAG: bytecode.index = index
+ // CHECK-DAG: bytecode.none = none
+ bytecode.i1 = i1,
+ bytecode.i8 = i8,
+ bytecode.i32 = i32,
+ bytecode.i1024 = i1024,
+ bytecode.si32 = si32,
+ bytecode.ui64 = ui64,
+ bytecode.index = index,
+ bytecode.none = none
+} {}
+
+//===----------------------------------------------------------------------===//
+// FunctionType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestFunctionType
+module @TestFunctionType attributes {
+ // CHECK-DAG: bytecode.empty_func = () -> ()
+ // CHECK-DAG: bytecode.func_args = (i32, f64) -> i1
+ // CHECK-DAG: bytecode.func_multi_res = (i32) -> (f32, f64)
+ bytecode.empty_func = () -> (),
+ bytecode.func_args = (i32, f64) -> (i1),
+ bytecode.func_multi_res = (i32) -> (f32, f64)
+} {}
+
+//===----------------------------------------------------------------------===//
+// ComplexType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestComplexType
+module @TestComplexType attributes {
+ // CHECK-DAG: bytecode.c_i32 = complex<i32>
+ // CHECK-DAG: bytecode.c_f64 = complex<f64>
+ bytecode.c_i32 = complex<i32>,
+ bytecode.c_f64 = complex<f64>
+} {}
+
+//===----------------------------------------------------------------------===//
+// MemRefType (with/without memory space, layout)
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestMemRefType
+module @TestMemRefType attributes {
+ // CHECK-DAG: bytecode.simple = memref<2x3xf32>
+ // CHECK-DAG: bytecode.with_memspace = memref<4xi8, 1>
+ // CHECK-DAG: bytecode.dynamic = memref<?x?xf32>
+ // CHECK-DAG: bytecode.affine_layout = memref<2x3xf32, strided<[3, 1]>>
+ bytecode.simple = memref<2x3xf32>,
+ bytecode.with_memspace = memref<4xi8, 1>,
+ bytecode.dynamic = memref<?x?xf32>,
+ bytecode.affine_layout = memref<2x3xf32, strided<[3, 1], offset: 0>>
+} {}
+
+//===----------------------------------------------------------------------===//
+// RankedTensorType (with/without encoding, dynamic dims)
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestRankedTensorType
+module @TestRankedTensorType attributes {
+ // CHECK-DAG: bytecode.static = tensor<16x32xf64>
+ // CHECK-DAG: bytecode.dynamic = tensor<?x32x?xf32>
+ // CHECK-DAG: bytecode.with_encoding = tensor<16xf64, "sparse">
+ bytecode.static = tensor<16x32xf64>,
+ bytecode.dynamic = tensor<?x32x?xf32>,
+ bytecode.with_encoding = tensor<16xf64, "sparse">
+} {}
+
+//===----------------------------------------------------------------------===//
+// UnrankedTensorType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestUnrankedTensorType
+module @TestUnrankedTensorType attributes {
+ // CHECK-DAG: bytecode.unranked = tensor<*xi8>
+ bytecode.unranked = tensor<*xi8>
+} {}
+
+//===----------------------------------------------------------------------===//
+// UnrankedMemRefType (with/without memory space)
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestUnrankedMemRefType
+module @TestUnrankedMemRefType attributes {
+ // CHECK-DAG: bytecode.plain = memref<*xi8>
+ // CHECK-DAG: bytecode.with_memspace = memref<*xi8, 1>
+ bytecode.plain = memref<*xi8>,
+ bytecode.with_memspace = memref<*xi8, 1>
+} {}
+
+//===----------------------------------------------------------------------===//
+// VectorType (with/without scalable dims)
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestVectorType
+module @TestVectorType attributes {
+ // CHECK-DAG: bytecode.fixed = vector<8x8x128xi8>
+ // CHECK-DAG: bytecode.scalable = vector<8x[8]xf32>
+ // CHECK-DAG: bytecode.all_scalable = vector<[4]x[4]xf16>
+ bytecode.fixed = vector<8x8x128xi8>,
+ bytecode.scalable = vector<8x[8]xf32>,
+ bytecode.all_scalable = vector<[4]x[4]xf16>
+} {}
+
+//===----------------------------------------------------------------------===//
+// TupleType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestTupleType
+module @TestTupleType attributes {
+ // CHECK-DAG: bytecode.empty_tuple = tuple<>
+ // CHECK-DAG: bytecode.mixed_tuple = tuple<i32, f64, index>
+ bytecode.empty_tuple = tuple<>,
+ bytecode.mixed_tuple = tuple<i32, f64, index>
+} {}
+
+//===----------------------------------------------------------------------===//
+// DenseResourceElementsAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestDenseResourceElementsAttr
+module @TestDenseResourceElementsAttr attributes {
+ // CHECK-DAG: bytecode.resource = dense_resource<blob1> : tensor<3xi64>
+ bytecode.resource = dense_resource<blob1> : tensor<3xi64>
+} {}
+
+{-#
+ dialect_resources: {
+ builtin: {
+ blob1: "0x08000000010000000000000002000000000000000300000000000000"
+ }
+ }
+#-}
+
+//===----------------------------------------------------------------------===//
+// DenseStringElementsAttr — splat and non-splat
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestDenseStringElementsAttr
+module @TestDenseStringElementsAttr attributes {
+ bytecode.splat_str = dense<"splat"> : tensor<4x!bytecode.string>,
+ bytecode.dense_str = dense<["foo", "bar", "baz"]> : tensor<3x!bytecode.string>
+} {}
+
diff --git a/mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlirbc b/mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlirbc
new file mode 100644
index 0000000000000000000000000000000000000000..eded616237c783da84cb3929076c6caefb4b6b20
GIT binary patch
literal 5297
zcmZ`-4U7~;7Vi3a+ca&{HhoKHnHz?2(##F(?l8NsEFwR<$a<j5&m#UnbZ&OH2OH*R
zotXt!qZ|?>CsA`6F=EtHqehJw^-fQX|52kvJvHKq5l at U5C7yp#qek~$^=!}ftXxg1
z`@QeIs`{$B>b=_SJ at d;xE$d$F3`#@?0*o+~&1(3b?;_uGRaSLXmsKpg#G_htGp4Gh
zsq1J{%@Bg7_#vqJfK~OZ8clRKLv*B`BOG)!BHVAb&aon at o)pLu4;Ci>XQ}2+&#zr=
zS7YijbscKf9(A>v#Ks|1#2cYzHFRxK4XsY9R=YQ-b&qP9DiRQ8;TY0Ui3y4xJweS{
zSLLT#yT^pu%UbB0nmxf<qN-geIjS|^19aUAAxjIVt6K}l_*%`LfEF}2>v7%EEwWRW
zap~}(W0lR2ZrgS^yufY=w<H>oq-mKJ7893J)<d|Ck&Tg!7QXdZBqr=8W6SB$--8?h
z#US^BY7o#t16?CpIFrq~1t*=)44wLi!8s?-984u<wk)3M%Znv2z=TGypb0|FGK3)l
zQ9}ib5W?j4dCL5*We`IJ7Azv5E;NWj*b;+iU=yZ6+#+$t;EdkYYazi1G&8ntJ+v^U
ztB|zFGREZd(?({%ffTgEJeV&pAh6IP8?jNosFY!mauF<1hhf{L(4~yPGUYN at 4yRjW
z8#?SVcQ?WcI0JeuaxG)*S`AjiT8rGnm~rDxH{WvG?RUy|-E;5#4?OtLBe2d;Bv@}K
z1kN!cAW`X0eQQqm_l;8j&*v)1r#A0~^I)SPkHYze7KXH8ocQVJ=n}{nCT)TNi#*Ag
z-SlMWsqizA=U#X*`tmCWUV9_<=G*VQ``-H>eE8AFpM3h+u`j;-`rGf!M*fv*S|E*9
z%QI42yC^?wH+B9WX0m?`Et+~FIA)ZZAXUpB{|uYV*d%aG`vkKIo2Ii~`THn?EoOWU
z<jq7U6wT&y;Ucr86Ut_CDGZybQ(>Fgz7$5xdE4Pqb3T7I0+(6j7|#BeQA!)=WIBaT
zrPJtiI)k1>XVKZTmA26i3fp6fEE9>q4)4qDj4?1I>Ca1$&QjPF17<{a9b5a)8Ol=F
z9a{j(pwu}Ee~A&fiJ%L`%CN$om<rLQ-8#yW^z2h#c{7HqW4KKx&m4toEpjDAGCg!9
zT}Auo*>nTFfcDcY-AoI#M7PpQ=;ibZ3V*d1MuQ!5(fRduXq?jx_96ywqrF6){JR-&
zlij5Vx^T0-41KBvZn2lMQMk=MU70P~-)@nkI67QM_tHD)-4yOjtk_3yrS=(JeiQ#K
z#ui0POccA<5Rmvha93jWeRMyy*Ln<vRZLwJkKat}>~CFgk45@$1Ika+=jlt-ewEsA
zFCLcr;Q at HiB3GcP@en;szoFmLpXjfYvIaJpO<_~nG&YOPX5FlZtz at g%2ITut;}QBf
z4I_7W#QHB)W%vg?W<jF?kGFu*Xf!GCWDCeBz*AMgfM=RuI-9}5I<ro~F5o$MAq1_g
zgDqy^HUwS_pMuYq;T1R#jx%^I9PeY+*~kjsfH&c7i#&m{*0h<03M^b=k*zFx35#9M
zv_{R+bPdn3)&%cZWF^PXc at 4Xc?PdGet<1cG-OcV}``N?nQT7CTnmx~6V(_k}z<b&{
zcppB{WcX0i;3I84e5 at JpiDts57TJfr$OqXWc9<PuN7?5LKGV*DW7>J}g|-pCw8&5B
z06(!`8RZQezSho%Z?!ahXOT8wOqs@~^TbJf7H at 2x&EW?vQ?8WUL1*yPjqNATOr5`2
z(gxs1&8ZJ;eo#wbK>OJu{n(M5Sj at Y54`0bwacvX)qPZ}tZ2?N5fm-Aa^kDrw%V9Fr
z at -PLVLkNMfl{a6)wW4+rOht?~U`JQ+Yxs41FW<*+<uHwEWtdL2VVFU+ZEzAgwV at O2
z=MVEo`4b#wQEdcfQ|(e{McZbyu~+%)9NK8~G6Efl?Gyfo`4N7Uf6n0)8sAP9({9>B
zVI__4V5=zfq1TZHMkrM^(uE<Ha;A_5N+xsJ&_hgNji6`@`Ay2sUEbE4>RBaaJ5Xq^
z3hljZLg-xH-aA*k=JvLay}DEAyMDu%R&_$FkIn0C6DEB5NN4XH6s1bGy-gxJLZB!l
z#54t~jEcrWED9k;Cn+H?3=#rOJQPJmlIYloc10z0X%k=y5f=vq?+(B)=a|Hs!wlY7
z3#OxfR2^lO)xr$9m51aSwxcGo5OnQ;a35z~V9QZC)*>fF|AwK*<!F?0R5AKRqbx!q
zG64<QA|Y*Oh#5Ph{Ua4;pg8EXij7s+Byozw)+C9{4|7Hwvi9^8lex?=>8(9)1^A-7
zQTD|hTNGd1vs3lO>#x>)@v$3pU;OcL!xtCRpG{xB3O{(GuRKbxp_Z?_MW3KezS7SQ
z(vYuQ$+9f$E3dPwSj1PpVQ;ahuT0_JvzV`R at TuJPl@0t99`}_3zknxv<qBTn&AxIs
zzmm83%Jcj_p7fQ2{3V|9m2dbV-d<H2bi6H`O}nIBUB&@XjFk5}FfsJ{!BsjE-$1nm
zT3k_-_#!*p+#InZEy<+atS6(9DAq_U6;DLM;c%oW6lt>Un3)Lc011dB5{XcwZpR{#
za55fU7`Nkb+s0=!CQ2MHPw_-FVJD+eyh&k2Ln59Cg+tA at jh9g~9MK|8EFRaI6X9qi
z8Ph^oa2$v>KCYWa|FD~@xCP1ICQ`mQIGl5&<odExDknD&xlSRIDJ7Q`^FwaVDJOHe
zt@)OrQgO30P)X)<ZYf!D%9Z44ZYC#??rML@?y+r`92+3*U8h?`1F2jbE)6)X0|T{D
zTMO6+-nKL2$WSg5pw-%+O?8YLv#GYupcXXY$@M4Gn(deyP&(&Gg-jlYso4id5O4!L
zwz-uH(|IRf9>QDPxSx|Bs*H at QWjsi@MrR at Eu2Ly8(p9OH#;u-nde9xHjAPaLRYA8<
za7td|)6mB)7BZ#d_J9Xgk}h;|x#G-i#ZoRnyD~C_v#34=iFMx5u4j?WWh#<*q{}0D
zsZ=ahq=5_F++eEuYV!!J8_D+<bA3*>zOCpv?FJXpLvUS6PS$I97JAgT87{aL&$J$e
zdQ*R~m`i6fxpH7dJ*-k14nQt`)O0RW+7!gv+tOPzx$%W`JJSVcQ$Q~aIv3Zwl#zKo
zGVFHD^$@XGD+(27lT)gvSj#K5tx-!bL8O{##*u2u3F;#EOwj!#Gy%qJ^cw_IRS*;T
zX at c%0svtI&v1*W)y2Lzta>dN?K18PUo4r~GVd_iQ1Gso~fSc-=08DHm*1Nt*r>6^E
zr#XeP)Aie9Gbr$MTVR`45s`{(v#UaG>NiLr9F#G1RMK_L#-Ly{s6xS>#t<B?MickS
z>Qc{|<vAzs6e{KVJ%cf#6x`BPJ)Ih?9xcy${FZ}mHak9pGRCC9goHXq!7XEG9+>bE
z2Qs-_*{wK|5S+1BsV<skbAgbCO1hLOYzmH1!vafN!-5-lxGciuIM=KIFhEu^(#6t<
zlpk4>DVN91BD~gXX)owhV@@5%;lh?eaa+M#t22uO84(D@`j$PUE0^>3uZS~&{)3;(
zP0eWwMEAOI<p#EcD<VXIRIw1CC}PF9O~eUr`0h;E9hfk7HLPcc3&FKT4LA0t07c=D
z&JSZ!O_z|mcM=g2(-R$z4>pjl%T5Dcz!mNy)#jXw>%GVR0LW!Vio=1tQg(%}H%hOQ
z$3R}+s$9W!4e<5Sn^VC1ptuT-ZD28GU#76d89WP*V6jx+#c%;P58Avj){iLxN734c
zk4FJFX}XMCHPeqgYv;K7&$XIba}d3qjrWL&EUJrN85WbRwaSbC(50)OXn2+|*R#h@
z;9WL6_Fm-a8$<rj$@GGd$h_HNQR>fNsLWh4K4LXQ2(u at R_gc-s^?l}w{V8eEEAzx%
zeGh>L3A{mIl*qFvk$bQn#Cn(!c`GOK6d-aI>#bOyZXj}lOys>-4`ZD+32j*SV?BuV
RSFAk>kuS%3H`c=n`5#e>Zp#1w
literal 0
HcmV?d00001
More information about the Mlir-commits
mailing list