[Mlir-commits] [mlir] [mlirbc][builtin] Add regression test. (PR #186078)
Jacques Pienaar
llvmlistbot at llvm.org
Thu Mar 12 04:49:26 PDT 2026
https://github.com/jpienaar updated https://github.com/llvm/llvm-project/pull/186078
>From e389def39fe03efd215427b81b507c019e5a26f0 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 | 444 ++++++++++++++++++
.../Builtin/Bytecode/builtin_fixed.mlirbc | Bin 0 -> 5129 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..b62ae39afc0b8
--- /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]]
+} {} 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
+ // 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
+} {} 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)
+
+{-#
+ 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>
+} {} loc(unknown)
+
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..3fb31b4633c0f9c429db8656996657f4f92fe5be
GIT binary patch
literal 5129
zcmZ`-4U7~;7VfU<N7J-z+w={Sr87GWlV)xhcZb=9WdZrwMeqPuVEI!B%=OOntPS(C
z&JVB{MI>mHs8ORvjd-3>qehMAsiy{iqsAlZsZmdjdTP|1#{Z~MqkFG<W_x-TuQt{7
z-uGTry?XuXy`CL7{i{JG=j^q!9IpZol&3O%8m<x!@mC3=tjek=V>`qi^``1_RF-vJ
zRZ%D#2<rHUklbK{b-lVoUc=Uqw=kh9hf(v!;Fe%mR+9`^>Y_|C{uh)pu2#3)jcYEK
zHz0RdUMnYYrhzmY!*W74u1Lzp+9YbRc846)W!#s^n3ka;6J>U>eRXEh2BwGY;`-2h
zE^3eocU&sVeMs2ye3w;K11-bDsf!vGCfw1$(<juJ8dUj%s)#Pahl*X)4b?QwP-ubK
z5$cEs&@Mfw2eIksF;O+pE8%V7Z9yE>XgJE`I;AVfx6{KQYW$rbX*{SPgQD<C$jarM
zqMa^SBd7c^JLlvX*;IT+$C4T2^b!tLHP9gdL1;?=7!ZQ6CPOgE^AMq8_dIca-*SlZ
z$SzpSgS1HFC7v$Tcm+&+(-5PuYR$k}h*KUCl&;?Z9h52(B&m4THg$X2f)sSaJeV&o
z;9(JkVMi>$VrdsFl}m6=4f>=CESL7c3OJ3zdD?y*R>2w=p!ARoYhgXr4qtY~l~-SL
z9bA9oO*h|i>uq<y22J8%lP2-7MGFH*xIYiBJK^8gaYMhHDJ75Yyco`cZJIa++chNw
zX-zxn)3LFoU}-vOgA6r;_q5$-+#h=2!H2_-Ja+Vnry|ch`}_;XUVQnL*Is|~t#{si
z|AUV{{!|YLU*k&$Zmiy(;JUh5`*FXn3jd)x{nyCisV9N0M~Dtwz5VF|7}lec!O_hV
z^fsKD&bjUHV-$Aju{luC<GoPQ6KBFXdPgr*^yD(A>8Vp-kKVluM)i67;aq*b at MIXy
zquLi=ee>P-KmPQ~uVaKvB2&nTWGb0PV1HB+MV{l~fcr)cMk#0<cfnFLVHq5X0 at cEY
zK41Tjc4--099;lXmg^mZOQO8k#-j?sPO-z`s0@*1{VLKN_vF#9-BZG4Q4GH+GsfTw
zs?8*`$ZXO{x=0UMNS2U(vXZPOXOKa%nQSFH2wZ6{iul(Q*t%DnM$?>Y%*7PoI&-Nw
z<qz#}z1b%*OW{UyIqK9K++?nxV{o&1nlziuzlFk1QY8Dx`2=o_uPT$>#9Y%iu01}o
zZCPW-Va*)S7{p!#+!kMZA-RZ{>s{lRlpUBg*R&b9*kAhK4k}(nt|d2+=n)cyJ2CF>
zhI`;X8n}zxOP(grk$;kx$gAWH at -}&od`LbaKaiivR631Lr|on$M*97MzmZ2t=pn+x
z1Hs3MEW(5EaF7Nxc%*|$0j*7f$2zEp1RSjc8a&YkpOG&~Na2Iu67<Yd at QeY!kxBGK
z8X~ynv!N;Yd>&qaV<D4=7enSu8k|Kbg_q$Kc#SH-9@@5$8cS%XpN3b`$ZDztl%S$2
zQ~{+8UZ>h-x|QyrLo`RVowP{HbT{2c&!-pCi|D2Fatd$a#e7TI0Pn!NiU{v33Vfh!
zf{zppK2~)2l!`adBlNHIc6t}Rm%@LQE%3Q=7JQ*>gRdw&N*||B)8{CBqil!olr(%#
zrB~@2H1;0-km~VIDEz2cm1^0^+SyaKb)P&VwS5VvWZ);oZp}jD87Pj~=NBr*exN_o
z-zX6#3Cb}1syHyF>;ghy5}|aOFkOHtL at B_D=reVe5T7k5CFLBLN~qW)EEJXq{lZFN
zwE)wIQi172sX;qY_P|V3-z;nub_hcP%p%Gt%qGgY(1~jng|Yx$Byt`PJ*aiQaG`LK
zaH#+bNo+q~4|P~gVh89M1O^FDh^+8^nDvN2C4Lg&rwF2^8dRbIkQ5r=$>iMJ6<q_V
zm1l6d9wfT!ME5`!BYIbK56or5+=1 at K(4RuxO<NmWT?wV**t~%*Cc<GH=^dDZBv;LK
zcX9jy10;zzFv(&Ukx{5YBVbT6Su#M=cmovnkR%z6M8yEgC7CD7+5odSE71~GX`q<)
zb>2P0+jx}mTsP(sG!RTsP5g`+qK6&uC~8380SHYIXdjqjM2sfHI9p%S)R-8F5CK_C
zRFMb`^I?$(1+7Jcl!FG<4n~GXt9GW8wL4kB6o)zCaRK;s9lR*qAW+`s*YhbV3L?e2
zvz|W<JaUWZk+$TK=gJ;=Q1Qr1RFAw{^T^M2k8CFakIs>xM_*3bJo<KGcyt#HdGsI+
zd-Sz5;?WP$s7Jp<O^^PT#yone5clYrLc*iFgbt4$6p|jjQ%HIAKB2o#Pf~fFZYF))
zp+4;xHZ8 at T$Bs?Rj^p`{`!KeZC<~OBBuTNwW+;&eo8gXR(oCqyNH~H$98JaI;ZP_P
zZZpDdrWw`aAr&AF;dnf51XME`4u_Jl$fB4Ti<u at qBT?33__Y#?N8)BO62VUw>?nxG
z;zr0wm?nPY>7lR^Zlkf7l8A>Q;YX5D#lVIeK_sB++EC5OSDhj^9u!=ml&$4$u2QO%
zGj?Yt<4HP;cBP76npP7T$y>guokO`)Pg9snb at lo=zX<Qr_=cUip1D4zcMeyy3b>6Y
z&yFJC`0Uu at RL@Qq>_TP4%Gg|TQ^hV<k~>EnyJ%VE<nmHs#L3&0WIn&U&@oaj?X)x1
zWFhaAlT|!G@>IvlGo-(M at MM4EHY6LKNW0(DooqtW2D>m)9c{7|yf)~gjksQ4xonO0
zRjU(~(^)4|ZO*9st`0iIqFr_;pNcw8sc4mdcLltj9Cx;z&zENGDV6g+msCeb&_nen
zGh%~#kz1|E<*h2m9_h+xfh(6vRW5V3lh3B=Lzip7hS9=MDL-iETIaHr(~kcoxd{5a
zZ0FpG8&RWmPOa!vUC|~aT17*pQa+ut@)f)35ErYKYd*-qfJx`A@~|K4?n>{r^38cp
zZ at Op?`}ktk-rK5DLCaf_n$t7aMVPZz6|45JU2Zket0G?5dF8~9)ayzUsTUYO&nnFX
ze!S#NfU))*hhSmyW2_oY;N7z1#~Ss?gWN*J&bcyQvVQMHSmonlwFSaLmu>~nc`bmG
z>X`scoWlIwI;Gd;nO&#a#fsf`{I$t4Jl*9B^E$!`uXnmS<fM*6e5s~_X{nlSnbv^(
znWhf;S85=*oo6P-%G&bEbu03A!7f%Stucf7r|b{uI-gEu>sQN_{{GCYlgl+vP{DlX
zI}l?VCO8#L&6x==F=OTP6{l)*jIbL+xg}HQ^1gJ5OuB3phy8nan9sEy<`3Xng{9)A
ztvLo@@~v9jUT%~tjIOgPm8O`b?p7}CCY^fDX|b_Z+*K^?DZ0Koy_B(7B4qxpxJX|<
z at 5V37Grslxuggiz>GD;MmUQL#!ogt~!e>;e=rfV!il&U^33vN`tKwuP?CsWobgowP
z`xZG2>|vjYOd(yUVNp$&(RBAFBE*iz7Hn>oNw-wKjGJ(oI;&uLdvB|D<1;>Qjh1S@
zx>9kNuDi>CUBE=%I;&DezxwQTOQ&7LuRr$T*9c&?=b%;GWoI|y6)crom#7sncu?l<
zv8loM6xr-?`1ee}AWc^=RIMSj)4Rv at e_DC0r@&U*jOBTv6?NxVYwWPztOEPbSGo?e
zi5r=?)p~pd?uU$Py_<Ok8_55;nQjtdl{Z%^aYGiSN^4(p$9jrjVwY;JTCc#ZYvxNs
zDQ at x$^Vpa9VIJ<rADBFR$BXzgMr_A^JL{CkpHjT|9QJ9ziz~73n8b at mu+I{CF^BzH
a?C)W3pUjI(u<yWr1p7<azr@}y@&5yg&`7}m
literal 0
HcmV?d00001
More information about the Mlir-commits
mailing list