[Mlir-commits] [mlir] [mlirbc][builtin] Add regression test. (PR #186078)
Jacques Pienaar
llvmlistbot at llvm.org
Thu Mar 12 05:04:16 PDT 2026
https://github.com/jpienaar updated https://github.com/llvm/llvm-project/pull/186078
>From 761d1a4765d16b65ed42fb566bf14afb3ae3096a 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 | 448 ++++++++++++++++++
.../Builtin/Bytecode/builtin_fixed.mlirbc | Bin 0 -> 5019 bytes
2 files changed, 448 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..435762e6b835b
--- /dev/null
+++ b/mlir/test/Dialect/Builtin/Bytecode/builtin_fixed.mlir
@@ -0,0 +1,448 @@
+// 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
+ // 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)
+
+//===----------------------------------------------------------------------===//
+// 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..852a0dcf9f77bd22c916cb973c7d1c8354a94938
GIT binary patch
literal 5019
zcmZ`-4U7~;7VfI*N7J-T+w={Sr85k}q?sGW-C=fNSwwyo1P^feS^iXlbF(u&>%jcr
z`~Ztl<OmWqV$`Tnqn?`6ct(wS>Zt+rj2boKsZmdjdTQ>B691z{iSE7X-tFmGyqZ+k
zd*6Fi^{V>SSDooQ`>TF6U)XKu1fl@}Mwr5$ge$}Y<O)$zG)0pXEC=|*Em~Aj3`5h<
zq?ia9_(Mn;QG>3RYf)D55tPl`s3~Feyd}6f7*@0-2NpRfw~YRR$`;3~OX<Qfmn!Q~
zyHZ)BB(bN7GH=65LNTvSD(0Fbdhv3P5;PQ?m)p3Psi6|(aq)Q#9?^R4hvlH#G at tWF
z#Dvo>Qj}g4Y-O$sYbHj9i__+hM3`_|6IY+mVp>om`!xwS2p<|&$uKp`vO=MGR(q&D
z9>BPapb^Ak;EqX}iMtZs65bNTR*QzC+- at +oj2@d321zIPf~*tJKmk=HYABP>7s__J
zl-Y5{?{l+Go0dz(r?oGfHYzU^&{YQm0uY3 at 1b_)42<r+kDVdVG7A%4YAq3{kBOuS!
ziA>mhov0ASHw+eoWoNBe1u;e-&RE|XNHC_#(9Wcdo3(SdY=tDGpbO?ma|z62khP@(
z%$EmYfwCP+7s4XB0=;q#mclXyL;6JqoCPaj6=VAp=z}#(KY00-S6zM0b#VQSH{EjU
z?RVS->vUOw^}0-8qaFr<3V-Zhd&<9V6b4S5BPS1UI|!TMTwNN5ExH<lt-5~dr^CaG
zAgvp;4KmCM-rIJcd4K4^haL$(`uG!19gZA*=Go_7c=6>|UVZJ2H{X8ez4t%-=o2F#
zevPjigkiTF6*{|k`EjqIiT`E>`{#}YlTL-K5upYMZu!HdU>ni#Flbn(7;V@!op;LL
zh8Yx$*euv?#CxD*B+h|~(cS|W8p*{_Gg4<j!{}NJyNo$|VaS*(J{^XOnEu)EFTVQb
zyYGMe>BKL?l#Zhl=tK$^M`cMO0)f3z{yz3a8R&v==^_kZG3<{5)58ajulxH{c`+P_
z&I36o^bEtnD3RI-x=^ePD_kB`AhLLghO!_$efVo<jc{cY({94FVYrIvQ|MGWoz9>$
zX$S43-Sl+2kS?Li=}Nkq_R~!iuD0e!{9}rI+-oee8P0Xq0tRrswMd%qyQy%a)hqKz
z;U;S-`nUydv6iu6xYasKp2_>)&R~G%X_fAza7TQ_Hd?0Es at _rW(Uwok3ttW|R-eux
z{u<z}_?kWR5^Ak;g5y at cU|yWirr}_J?uEZF=?Z#?UQ44l&?wx4`F=0l2lunUo%C+{
zBt1g^L7%5D(PQ*=`WAhcen7vZ-_i+eBAdh}v+0=U4+j29AEu!PD1nE9k5NT}N8r&Q
z3+V88JCg%?n+#82{-Xd-xquFb+u&pRUm8+L at N<ega}=I2;RpIF9mhgH<3P`bD31Ib
zyZ|qTECMfwtSKxwl`#gdz^m{YQ-d9>t&^GEEOa^xFJzG=Obw_(Ra2P?Y8$-4^wq4N
zZDQxK^O-)t@@yL`vnt!k_OMIXpV(y#-o#`1wz?kPf%jAi-d9!lP~8Y0sXBb38t at +`
zUCVA at H?!N=o$PJ~pQ at YTGxc0Ju5N)Z7(C1#V^6Xp48Bsg!Z&IfzGL!B>==u^#olE`
z`~wExtC?E8TFBYCGq!Y{HZ8Svp`d2rN7Zg+pHb$CBkTOcq}Z42TlNF{nf=PtK{%ln
z;1_i}3<IT%O%x}IFpjDvn1EZRO%>zQMYW<{2ooujI>b(~TRdG{C at v9U5>;z3nW_z#
zLe*U`72Q{h{o*F^JQ1c-bqHoq^&*&wW9G$eB6QHm#RNLhYp1wJyhQwy2;DTcm$-Qj
z%V}&MTS;LxC6p>E=|#$;B9qBDN+yVsu9-|`0gzP|Aas0w_Oi~t)biCrz8i%uSLo{N
z<U-G~uD;p4ncdel(kw}#@5b{+G}j5Oqu89jPHw_x6zS=kg`!Z;cXbM6p9!)|Ok`NB
z5-KV)Sp-Z*$IB+ at Ix#`z4_Q_)NOTOKT~-KP+y+P){9cyvY6gaEZxCk<uj5iiiEh{v
zSRj~Sy7VzKB at f%@Nz8=aeGtM;=><!QNYR88=i}?T7Ly_oDx!)!6^XDg2}=Z2j1~h@
z_nS=L9~l^`+u2Ia?%?@S9u&kQB9OI&NaD>RBQ{w_ at brihLy}uZmVzg)mpm~ed*Uv|
z6Zfi~ctG>Sdvs6y)bPZ~G~mhS)1W6`M%z63HfnnEOcwIwl`QPZhgiguA7D{Wex6yL
z{5gwx@&qyN$y3CHC(jhyJ$a>=^yC3C<;hjC%azAzgs^_vD?qQFdf6#sd2y8agz}6{
zRGp{BWLb_autJGM*b28NlU71YM#2%S;b<xr4~IgbaGM!!v#h8Q4`~2#2*=}bGoV?~
za5$8VMdrt>Sj at 8U8Hw@|!|#(=JQBB(kqCaQU`0bb7B at p?!m{wQ&IpCoa2t!o)I>ZK
z2`8hfi3R6 at NI*06fkvTNFO-GRbP!6FT%%|UwMwI!wL7v|&(cx0Yjymv%ruc5#f-0O
z$3Q;S-8AM?ojrcdZ^BbFI$=k?d$v#MnI)7nC7i~y=Y|j{_~O`As9%sS*`?Z!OxAAt
z*`*!zp{82Hq{ek at z@U4p)yz<Dy<Tlv9p`kekgYc{cYQ8cD3|T3)A>yFDOAdt>TiyK
zher at Du#3gYv|W{I(HC}oXa}yseexjIJIAawihMCs7x*Jx8!8FaN~JDjFDMjqDYxl#
z0$4v(8mJWe?R;xrK61L?-$)0+eW}`cr{f0nXzkM|7wV2_BMPmifl8&A&S#1>-;O$1
zz1r|W1$?RLVx~Ii$GSSxJ2S=RMizR~WqZ)4mvi>+R+kz^-ikB|-LoBpZ`O)(-5#{7
zts#0G at 1=%E_I|`={U+klzhCF~z!-h>LKp+%&2SQe*M=YCcf}apxitLP$nD`l&Naf<
zxx84({ML)eR8Pv)76`AQbSr?H*8&t$-D7~UUHE>tcIk0+9 at m+6xn}pCd~9+YPj~v#
z+(r1c=&jC$3aOJ2A05<?I_l|`ZX=MN4P3}S(g=dnd0}F%tf?+vyR2xJ>~g)<nls1|
zRewsmdODSJkCtQo?Vh<pKHpqH4LQlTAg+#tP^ck&X2-n5Y^GSO73#LY1$(5awy<fw
z=%X}L($!3P&_9QV`L@=>{0ZEsak^~An&$u#WIZG77KVh<(ArF`)--c^ZPn5a>A0NJ
z5 at Vyhy<FK<cJ}J*N;boZkneBJL3)ctCx1E5_{R6Yu0m>7r;puR=&ImLhXQ8^Ur?2@
zFGS82O&jM4XZj_XS|K}TZkN{cjk14lQNzR@^o7VB(xnDoeCaBN?wmw~`11IG&B?Oq
zmfI=o5H5FLS}E-)+Pho5N4~L(nW0L<cdyh6+}D|<&n_X6xAv;labJD$I at g<B#&0wJ
zSvHcue9rz%dApt4fJd-WZ5^Uf#^gbpGsnge#plR-kHWtd0w!s?hN+qvz&O2g?Ea7B
zsh$HLZIhj?kB!3J{Ca~g*6UT`e at 3NUkayg`&8^YnD{wwGoai0q=^sJ<&&hO1h~K>V
zN<|pRAXR4eG-q at vf}0(wIjVaDw~kq?45WndFU;ZJ&HD-5Mc^ob;{;9+X(A=k4ZJcU
x%@B$77}jw>q;9OM#}Vle*2xl)HetOC>oKeo#}lao>uRirupYts0oI8!`5*n at A4vcJ
literal 0
HcmV?d00001
More information about the Mlir-commits
mailing list