[Mlir-commits] [mlir] [mlirbc][builtin] Add regression test. (PR #186078)
Jacques Pienaar
llvmlistbot at llvm.org
Thu Mar 12 05:05:43 PDT 2026
https://github.com/jpienaar updated https://github.com/llvm/llvm-project/pull/186078
>From 17442e35d81d48816bce49d150a32bd24b415cf8 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 (as discussed in RFC).
---
.../Builtin/Bytecode/builtin_fixed.mlir | 424 ++++++++++++++++++
.../Builtin/Bytecode/builtin_fixed.mlirbc | Bin 0 -> 4527 bytes
2 files changed, 424 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..2fd30b2b41454
--- /dev/null
+++ b/mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlir
@@ -0,0 +1,424 @@
+// 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.
+
+module {
+
+//===----------------------------------------------------------------------===//
+// 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]]
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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}}
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// UnitAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestUnitAttr
+module @TestUnitAttr attributes {
+ // CHECK-DAG: bytecode.unit
+ bytecode.unit
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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
+ 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
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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)
+} {} 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
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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)
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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">
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// UnrankedTensorType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestUnrankedTensorType
+module @TestUnrankedTensorType attributes {
+ // CHECK-DAG: bytecode.unranked = tensor<*xi8>
+ bytecode.unranked = tensor<*xi8>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// DenseResourceElementsAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestDenseResourceElementsAttr
+module @TestDenseResourceElementsAttr attributes {
+ // CHECK-DAG: bytecode.resource = dense_resource<blob1> : tensor<3xi64>
+ bytecode.resource = dense_resource<blob1> : tensor<3xi64>
+} {} loc(unknown)
+
+//===----------------------------------------------------------------------===//
+// 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>
+} {} loc(unknown)
+
+} loc(unknown)
+
+{-#
+ dialect_resources: {
+ builtin: {
+ blob1: "0x08000000010000000000000002000000000000000300000000000000"
+ }
+ }
+#-}
+
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..ba0d91e122a399880a61483dd803a3524d0e31e2
GIT binary patch
literal 4527
zcmZ`-4U8Mr5#IO4bDPa}vus?)a#lXav5f1Oobes`Ye+6mNN5^DlDqsAqTu at M^|73P
z4%?UHKm|gTMt}%{svtl>0ksGaAfSZ;3Mn9p01*lZXhA>$Ap{Zs0t8XH&RgHD*GKxS
z_jcx+dGqGIH#58P#xp(}&`S1Rt0*xY83F?p7T^M3g)Q*Os;=s?N^QRwT1}6ss^72c
zBvMU+{PZJ8on(V8t(HXHAS|dmgiu!_q`5q}BN$2dlR$8N^oyx$)Is7lsGHO at VJ6Yy
z8BtTJc~x39H>F8Sv^&(GUnToOCbUeQn3z~!*!PQ-2ZbKB1Fc7UTs}#roM*qPW{I%W
zC6lmlS8SqF%~W+gr6=^D&PH^Z4uS at qy6iV~^2HzY2dVk#G-TZ*6Oo;fok4o)u}DnF
z{QztEx?lulgWZXW!B9sPHH~TEe5qtttz0EPdg{-LC!aL0m`ToCxN_bUy;34o1N|7l
zAcj(iCWbL$s0ea8BloT7$0%bA7cFC`EHRkEV7b9GjM4339B}RF>o;Hm7$yNWZo(9R
zrr<)5x9!l++PMqUn87|=BrjpO46tCyHZE6&afLd9mGiM*sbN-W;2K;DIBs0%$J22=
zZUES);zryA#(~SOxbmv2e~*8-?)n>Vy5-i}af_iyIA|ygw;2(Xxb*9R%|H3qb<)tW
zUn%KB=N-Tuc$Ohg;7&se<1WKE;lqiEe#{wu9>P3m!8=2DoA-q8i`*Z5&>!%9PFIQ2
zM5`T^dizBC_F}*8`w#fxpQ9^gpWsKS)qZh_KSa8 at lGFY&LAwFtk;e`le&VU8pLzEA
z7hZhnl~-R!E2hXYlNb)i#HraaKtqx)=_ebja3qFcMD`!u^0#hf6;@(VREpBl39QAK
z9Ac!xsRMO9Kc- at I)oPt+N&5St&m9l35u<>ZId1~Tz<BGOci;cu!;g-B^4S+(ef{ls
z$8b+P7WLZj2|MF)v%UO<ak?-3O*|pb{Ao8{98W63Gu#(Xkxr}OZ{rJL0{6$$$^tR}
z03hdGd^VrM at v>xQCZEOQec37Psi#<0G~vEz at kNG!#L3|m$t81nH;*rKoD)*9LD3x7
z=8>^KX7Ngp7w{h5%VUdq46mXnyc+4&A+VaS<7e}8_z*Ag^LUll`EGszzla~?*YLae
zz5D_G5Py<0ye{xdKET6g5_x at aJ6C1A5pN1Yz`$D;f)X%73f at XlNd(^B0u2092ruQo
z<6(^jFXwbJci^2SUdwOhf9ByE$k5&4+i1K8 at 5B4UafT0u<B#&-;~W70iVx!>6ir8X
z=w)uc#=~#$$lE;n9 at hd|P}4QgPz&K>V0_BI<lpe``48OS&;>JL7R-h at Fc-REKAZ@6
zh?3>7wj7_pr!*O#)--%ZTY=AN20pL(@dc23VKMw1R>Epn2l%4ak1uIid_`M>uL2Ih
zb~qc(0eoFsi~rV6$2UPa52}#Z4Htkvc at f}S+WJPbZWpcMsXO~lnwQzNQqnfyJKDz1
znlM!ll2i-c1vzmLu7PXe2DlltP58dH1wYUR at k9Iw;9htD at Tj&8KLOMqhvbu>?a<D`
z&p<u`FT-o_2D}aL0e+$F#ILkn__db9Zvj7rFX0>b9`HLYkH at qE{uiLjH`9j`QHxQ4
z0nYKw^>zE^`>=~AhM5Sn*&OHagbi~!c5}wLs<A8;AMOK%b#XS+CmXs63ItHmAi($x
zw$DUGVJ6id>M}7Jm=Hx1_zcBF!(b+AVo(&7CX!-+<ciApst{7DiZ_x%FC_%3g?{GP
zt&{nw at -X2N5D2EgkS_&OcCmdf1tw<qVfZ$HEXL)i981YbVc#(HgdB}>AF)&)qEU#j
zh|EwUZ^<ET!~|m`IyBz23bmruBkrv_EcqVtA=}KD?7PMX%wk&@MX^r?DlS{t8g$7)
z*(LLeOYTu!@?y;;_v<cshvAYB`(5(QfJ;sUUGhX8a_N=abm`}K*rh+_5tr_Ps7s#-
zF_$hu+@&vvgiGHANtb>UQZD@*EOhCQA??!KmvQOYzP=XSr85Tec~-)#k$K)})2q`|
z{gK|De<IhGX$eJ95-Z~2R4NjWEKH~4DLoyHM5#w&nM5)Y4u>NlGZKo&WBz1VM@(WQ
znM|4iJsyih!s$eGc_N-j#N#wZW1=PE;V7}uSTd0`!)7WTr%xDvIHE;DkVt5$WH=g0
z$25}~*~Vx<_ZvfFcDZR+rKtdrDz)NR*^(Nyv3kMkDHL2uPt|HP=_4xNMn=nd&(xlw
zQf6^mSjzM+^>SWOU#~~9_!JMb^kk`;uh2464)qkr39vnW?6I5Y<|<aDF`6$}Z9S_p
z+8l4Q4GLr0$5wJWTd(KGv(09`Ep?Q0MZ3^!W3BzQK)YJC>dxfTNXM>K^Y!CepmdR>
zbFFf at Hg8X@UiP@%93Q1!v_|2?pp#ggUX;rDrX+ at 3W4t2OYqh3SIM*&0Gp$Fj<G|o}
zWvEsjuu7eCh2@;>JxB+kbE#V;XW~}U=$tcFwVRG;8xftNp<1n+E9J`#&xtx%vp(j5
zY`WB3IbR?4Vtu{2-T89+Anm2Osx|E4t3_*Xr%Ho7??lGz#iuxkIIQ*6rZsHU9Tx?^
zu3XC>&*6OiM|au*m1vbtfEMWh?9Ae6!1O7?ug)n;9bWi#npJIB*&l~jQQ)~=PdKy?
z@~3?)Ey&LN2=Sy%gHo)S>zFnPd9$Vkc`Z#Mw4CcEo$03fy3K3LR>i6|8=corxm5RF
zeT&a!imecIq{p9Gv`eM-4jPoZo(&0h(gnLgWu`Fg5)1iqxnVagNf6fLqux<<N at Y*#
z6O*gwtHa(kT+DN{F4os}tu)pUWn~&bg`}C6_DbVYWqfnK(P)cB8S3P6PI9(#v%|-+
z>PWS=r|O*58MQ)Q6bx~`4F}1V%TD}?eDv7&UYDIYxz|$#JJQ<rgo7<I$>UV5>Tyxz
zR9hzU$yt7NzF`-pt=%errLn5_Y>A`59`?8>6mpd at dO_ss<hqlI1c~hlgYCr%xso>?
z3r=AY>T7D1(XzF-Q+x6&u$&*Sjd|*C!xp;EDjTf|6}-+_jV7I|$6x0)U{&d>MSQSK
z2C!IjAYUD^id!iKYxPbOV^s<sk~wQ^n`AtSV)hh#JQpZPa}5gB{1Ex+zMxwFEx4?!
zAgpb-3eD+Wv<|;HCN}HNs)#=*axG9y+$zMK-qRI0FJ;Gjr}7L;BL62dogyUOP^DT;
z8p>0t%wN!6u~j03*rD21TW_jPo8{V2Mw;==BJoA}TZXqYJk0PY!(&XI#hH99_1CDE
vfXUxbU*}`;Zt4e-$w#Pf?;;)Q|DZlgX7ZWTtJDutKSKQn>fJL4pTYhIBi5sS
literal 0
HcmV?d00001
More information about the Mlir-commits
mailing list