1#include "llvm/ADT/TypeSwitch.h"
2#include "mlir/Bytecode/BytecodeImplementation.h"
3
4static ::mlir::Attribute readAffineMapAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
5 AffineMap value;
6 if (succeeded(Result: readAffineMap(reader, context, map&: value))) {
7 return ::mlir::getChecked<AffineMapAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: value);
8 }
9 return AffineMapAttr();
10}
11
12static ::llvm::LogicalResult write(AffineMapAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
13 writer.writeVarInt(/* AffineMapAttr */ value: 23);
14 writeAffineMap(writer, attr: attribute);
15 return ::mlir::success();
16 return ::mlir::failure();
17}
18
19static ::mlir::Attribute readArrayAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
20 ::llvm::SmallVector<::mlir::Attribute> value;
21 if (::mlir::succeeded(Result: reader.readAttributes(attrs&: value))) {
22 return ::mlir::getChecked<ArrayAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: value);
23 }
24 return ArrayAttr();
25}
26
27static ::llvm::LogicalResult write(ArrayAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
28 writer.writeVarInt(/* ArrayAttr */ value: 0);
29 writer.writeAttributes(attrs: attribute.getValue());
30 return ::mlir::success();
31 return ::mlir::failure();
32}
33
34static ::mlir::Attribute readCallSiteLoc(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
35 LocationAttr callee, caller;
36 if (::mlir::succeeded(Result: reader.readAttribute(result&: callee)) &&
37 ::mlir::succeeded(Result: reader.readAttribute(result&: caller))) {
38 return ::mlir::getChecked<CallSiteLoc>(emitError: [&]() { return reader.emitError(); }, context, params&: callee, params&: caller);
39 }
40 return CallSiteLoc();
41}
42
43static ::llvm::LogicalResult write(CallSiteLoc attribute, ::mlir::DialectBytecodeWriter &writer) {
44 writer.writeVarInt(/* CallSiteLoc */ value: 10);
45 writer.writeAttribute(attr: attribute.getCallee());
46 writer.writeAttribute(attr: attribute.getCaller());
47 return ::mlir::success();
48 return ::mlir::failure();
49}
50
51static ::mlir::Attribute readDenseArrayAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
52 ::mlir::Type elementType;
53 uint64_t size;
54 ::llvm::ArrayRef<char> rawData;
55 if (::mlir::succeeded(Result: reader.readType(result&: elementType)) &&
56 ::mlir::succeeded(Result: reader.readVarInt(result&: size)) &&
57 ::mlir::succeeded(Result: reader.readBlob(result&: rawData))) {
58 return ::mlir::getChecked<DenseArrayAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: elementType, params&: size, params&: rawData);
59 }
60 return DenseArrayAttr();
61}
62
63static ::llvm::LogicalResult write(DenseArrayAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
64 writer.writeVarInt(/* DenseArrayAttr */ value: 17);
65 writer.writeType(type: attribute.getElementType());
66 writer.writeVarInt(value: attribute.getSize());
67 writer.writeOwnedBlob(blob: attribute.getRawData());
68 return ::mlir::success();
69 return ::mlir::failure();
70}
71
72static ::mlir::Attribute readDenseResourceElementsAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
73 ShapedType type;
74 ::mlir::FailureOr<DenseResourceElementsHandle> rawHandle;
75 if (::mlir::succeeded(Result: reader.readType(result&: type)) &&
76 ::mlir::succeeded(Result: ::mlir::readResourceHandle<DenseResourceElementsHandle>(reader, value&: rawHandle))) {
77 return getChecked<DenseResourceElementsAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: type, params&: *rawHandle);
78 }
79 return DenseResourceElementsAttr();
80}
81
82static ::llvm::LogicalResult write(DenseResourceElementsAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
83 writer.writeVarInt(/* DenseResourceElementsAttr */ value: 16);
84 writer.writeType(type: attribute.getType());
85 writer.writeResourceHandle(resource: attribute.getRawHandle());
86 return ::mlir::success();
87 return ::mlir::failure();
88}
89
90static ::mlir::Attribute readDenseStringElementsAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
91 ShapedType type;
92 uint64_t _isSplat;
93 SmallVector<StringRef> rawStringData;
94 if (::mlir::succeeded(Result: reader.readType(result&: type)) &&
95 ::mlir::succeeded(Result: reader.readVarInt(result&: _isSplat)) &&
96 succeeded(Result: readPotentiallySplatString(reader, type, isSplat: _isSplat, rawStringData))) {
97 return ::mlir::getChecked<DenseStringElementsAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: type, params&: rawStringData);
98 }
99 return DenseStringElementsAttr();
100}
101
102static ::llvm::LogicalResult write(DenseStringElementsAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
103 writer.writeVarInt(/* DenseStringElementsAttr */ value: 19);
104 writer.writeType(type: attribute.getType());
105 writer.writeVarInt(value: attribute.isSplat());
106 writePotentiallySplatString(writer, attr: attribute);
107 return ::mlir::success();
108 return ::mlir::failure();
109}
110
111static ::mlir::Attribute readDenseTypedElementsAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
112 ShapedType type;
113 SmallVector<char> rawData;
114 if (::mlir::succeeded(Result: reader.readType(result&: type)) &&
115 succeeded(Result: readDenseTypedElementsAttr(reader, type, rawData))) {
116 return ::mlir::getChecked<DenseTypedElementsAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: type, params&: rawData);
117 }
118 return DenseTypedElementsAttr();
119}
120
121static ::llvm::LogicalResult write(DenseTypedElementsAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
122 writer.writeVarInt(/* DenseTypedElementsAttr */ value: 18);
123 writer.writeType(type: attribute.getType());
124 writeDenseTypedElementsAttr(writer, attr: attribute);
125 return ::mlir::success();
126 return ::mlir::failure();
127}
128
129static ::mlir::Attribute readDictionaryAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
130 ::llvm::SmallVector<NamedAttribute> value;
131 auto readValue = [&]() -> ::mlir::FailureOr<NamedAttribute> {
132 StringAttr name;
133 ::mlir::Attribute value;
134 if (::mlir::succeeded(Result: reader.readAttribute<StringAttr>(result&: name)) &&
135 ::mlir::succeeded(Result: reader.readAttribute(result&: value))) {
136 return NamedAttribute(name, value);
137 }
138 return ::mlir::failure();
139 };
140 if (::mlir::succeeded(Result: reader.readList(result&: value, callback&: readValue))) {
141 return ::mlir::getChecked<DictionaryAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: value);
142 }
143 return DictionaryAttr();
144}
145
146static ::llvm::LogicalResult write(DictionaryAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
147 writer.writeVarInt(/* DictionaryAttr */ value: 1);
148 writer.writeList(range: attribute.getValue(), callback: [&](NamedAttribute attribute) {
149 writer.writeAttribute(attr: attribute.getName());
150 writer.writeAttribute(attr: attribute.getValue());
151 });
152 return ::mlir::success();
153 return ::mlir::failure();
154}
155
156static ::mlir::Attribute readDistinctAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
157 ::mlir::Attribute referencedAttr;
158 if (::mlir::succeeded(Result: reader.readAttribute(result&: referencedAttr))) {
159 return ::mlir::getChecked<DistinctAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: referencedAttr);
160 }
161 return DistinctAttr();
162}
163
164static ::llvm::LogicalResult write(DistinctAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
165 writer.writeVarInt(/* DistinctAttr */ value: 21);
166 writer.writeAttribute(attr: attribute.getReferencedAttr());
167 return ::mlir::success();
168 return ::mlir::failure();
169}
170
171static ::mlir::Attribute readFileLineColLoc(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
172 StringAttr filename;
173 uint64_t start_line, start_column;
174 if (::mlir::succeeded(Result: reader.readAttribute<StringAttr>(result&: filename)) &&
175 ::mlir::succeeded(Result: reader.readVarInt(result&: start_line)) &&
176 ::mlir::succeeded(Result: reader.readVarInt(result&: start_column))) {
177 return ::mlir::getChecked<FileLineColRange>(emitError: [&]() { return reader.emitError(); }, context, params&: filename, params&: start_line, params&: start_column);
178 }
179 return FileLineColRange();
180}
181
182static ::mlir::Attribute readFileLineColRange(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
183 StringAttr filename;
184 SmallVector<uint64_t> rawLocData;
185 if (::mlir::succeeded(Result: reader.readAttribute<StringAttr>(result&: filename)) &&
186 succeeded(Result: readFileLineColRangeLocs(reader, lineCols&: rawLocData))) {
187 return getFileLineColRange(context, filename, lineCols: rawLocData);
188 }
189 return FileLineColRange();
190}
191
192static ::llvm::LogicalResult write(FileLineColRange attribute, ::mlir::DialectBytecodeWriter &writer) {
193 if (isStrictFileLineColLoc(loc: attribute)) {
194 writer.writeVarInt(/* FileLineColLoc */ value: 11);
195 writer.writeAttribute(attr: attribute.getFilename());
196 writer.writeVarInt(value: attribute.getStartLine());
197 writer.writeVarInt(value: attribute.getStartColumn());
198 return ::mlir::success();
199 }
200 if (!isStrictFileLineColLoc(loc: attribute)) {
201 writer.writeVarInt(/* FileLineColRange */ value: 22);
202 writer.writeAttribute(attr: attribute.getFilename());
203 writeFileLineColRangeLocs(writer, range: attribute);
204 return ::mlir::success();
205 }
206 return ::mlir::failure();
207}
208
209static ::mlir::Attribute readFlatSymbolRefAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
210 StringAttr rootReference;
211 if (::mlir::succeeded(Result: reader.readAttribute<StringAttr>(result&: rootReference))) {
212 return ::mlir::getChecked<FlatSymbolRefAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: rootReference);
213 }
214 return FlatSymbolRefAttr();
215}
216
217static ::llvm::LogicalResult write(FlatSymbolRefAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
218 writer.writeVarInt(/* FlatSymbolRefAttr */ value: 4);
219 writer.writeAttribute(attr: attribute.getRootReference());
220 return ::mlir::success();
221 return ::mlir::failure();
222}
223
224static ::mlir::Attribute readFloatAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
225 ::mlir::Type type;
226 ::mlir::FailureOr<::llvm::APFloat> value;
227 if (::mlir::succeeded(Result: reader.readType(result&: type)) &&
228 ::mlir::succeeded(Result: readAPFloatWithKnownSemantics(reader, type, val&: value))) {
229 return getChecked<FloatAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: type, params&: *value);
230 }
231 return FloatAttr();
232}
233
234static ::llvm::LogicalResult write(FloatAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
235 writer.writeVarInt(/* FloatAttr */ value: 9);
236 writer.writeType(type: attribute.getType());
237 writer.writeAPFloatWithKnownSemantics(value: attribute.getValue());
238 return ::mlir::success();
239 return ::mlir::failure();
240}
241
242static ::mlir::Attribute readFusedLoc(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
243 ::llvm::SmallVector<Location> locations;
244 auto readLocations = [&]() -> ::mlir::FailureOr<Location> {
245 LocationAttr value;
246 if (::mlir::succeeded(Result: reader.readAttribute(result&: value))) {
247 return Location(value);
248 }
249 return ::mlir::failure();
250 };
251 if (::mlir::succeeded(Result: reader.readList(result&: locations, callback&: readLocations))) {
252 return cast<FusedLoc>(Val: getChecked<FusedLoc>(emitError: [&]() { return reader.emitError(); }, context, params&: locations, params: Attribute()));
253 }
254 return FusedLoc();
255}
256
257static ::mlir::Attribute readFusedLocWithMetadata(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
258 ::llvm::SmallVector<Location> locations;
259 ::mlir::Attribute metadata;
260 auto readLocations = [&]() -> ::mlir::FailureOr<Location> {
261 LocationAttr value;
262 if (::mlir::succeeded(Result: reader.readAttribute(result&: value))) {
263 return Location(value);
264 }
265 return ::mlir::failure();
266 };
267 if (::mlir::succeeded(Result: reader.readList(result&: locations, callback&: readLocations)) &&
268 ::mlir::succeeded(Result: reader.readAttribute(result&: metadata))) {
269 return cast<FusedLoc>(Val: getChecked<FusedLoc>(emitError: [&]() { return reader.emitError(); }, context, params&: locations, params&: metadata));
270 }
271 return FusedLoc();
272}
273
274static ::llvm::LogicalResult write(FusedLoc attribute, ::mlir::DialectBytecodeWriter &writer) {
275 if (!attribute.getMetadata()) {
276 writer.writeVarInt(/* FusedLoc */ value: 12);
277 writer.writeList(range: attribute.getLocations(), callback: [&](Location attribute) {
278 writer.writeAttribute(attr: (LocationAttr)attribute);
279 });
280 return ::mlir::success();
281 }
282 if (attribute.getMetadata()) {
283 writer.writeVarInt(/* FusedLocWithMetadata */ value: 13);
284 writer.writeList(range: attribute.getLocations(), callback: [&](Location attribute) {
285 writer.writeAttribute(attr: (LocationAttr)attribute);
286 });
287 writer.writeAttribute(attr: attribute.getMetadata());
288 return ::mlir::success();
289 }
290 return ::mlir::failure();
291}
292
293static ::mlir::Attribute readIntegerAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
294 ::mlir::Type type;
295 ::mlir::FailureOr<::llvm::APInt> value;
296 if (::mlir::succeeded(Result: reader.readType(result&: type)) &&
297 ::mlir::succeeded(Result: readAPIntWithKnownWidth(reader, type, val&: value))) {
298 return getChecked<IntegerAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: type, params&: *value);
299 }
300 return IntegerAttr();
301}
302
303static ::llvm::LogicalResult write(IntegerAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
304 writer.writeVarInt(/* IntegerAttr */ value: 8);
305 writer.writeType(type: attribute.getType());
306 writer.writeAPIntWithKnownWidth(value: attribute.getValue());
307 return ::mlir::success();
308 return ::mlir::failure();
309}
310
311static ::mlir::Attribute readIntegerSetAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
312 uint64_t numDims, numSymbols;
313 ::llvm::SmallVector<AffineExpr> constraints;
314 ::llvm::SmallVector<bool> eqFlags;
315 auto readConstraints = [&]() -> ::mlir::FailureOr<AffineExpr> {
316 AffineExpr temp;
317 if (succeeded(Result: readAffineExpr(reader, context, expr&: temp))) {
318 return temp;
319 }
320 return ::mlir::failure();
321 };
322 auto readEqFlags = [&]() -> ::mlir::FailureOr<bool> {
323 bool temp;
324 if (::mlir::succeeded(Result: reader.readBool(result&: temp))) {
325 return temp;
326 }
327 return ::mlir::failure();
328 };
329 if (::mlir::succeeded(Result: reader.readVarInt(result&: numDims)) &&
330 ::mlir::succeeded(Result: reader.readVarInt(result&: numSymbols)) &&
331 ::mlir::succeeded(Result: reader.readList(result&: constraints, callback&: readConstraints)) &&
332 ::mlir::succeeded(Result: reader.readListWithKnownSize(result&: eqFlags, size: constraints.size(), callback&: readEqFlags))) {
333 return IntegerSetAttr::get(value: IntegerSet::get(dimCount: numDims, symbolCount: numSymbols, constraints, eqFlags));
334 }
335 return IntegerSetAttr();
336}
337
338static ::llvm::LogicalResult write(IntegerSetAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
339 writer.writeVarInt(/* IntegerSetAttr */ value: 24);
340 writer.writeVarInt(value: attribute.getValue().getNumDims());
341 writer.writeVarInt(value: attribute.getValue().getNumSymbols());
342 writer.writeList(range: attribute.getValue().getConstraints(), callback: [&](AffineExpr attribute) {
343 writeAffineExpr(writer, expr: attribute);
344 });
345 writer.writeListWithKnownSize(range: attribute.getValue().getEqFlags(), callback: [&](bool attribute) {
346 writer.writeOwnedBool(value: attribute);
347 });
348 return ::mlir::success();
349 return ::mlir::failure();
350}
351
352static ::mlir::Attribute readNameLoc(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
353 StringAttr name;
354 LocationAttr childLoc;
355 if (::mlir::succeeded(Result: reader.readAttribute<StringAttr>(result&: name)) &&
356 ::mlir::succeeded(Result: reader.readAttribute(result&: childLoc))) {
357 return ::mlir::getChecked<NameLoc>(emitError: [&]() { return reader.emitError(); }, context, params&: name, params&: childLoc);
358 }
359 return NameLoc();
360}
361
362static ::llvm::LogicalResult write(NameLoc attribute, ::mlir::DialectBytecodeWriter &writer) {
363 writer.writeVarInt(/* NameLoc */ value: 14);
364 writer.writeAttribute(attr: attribute.getName());
365 writer.writeAttribute(attr: attribute.getChildLoc());
366 return ::mlir::success();
367 return ::mlir::failure();
368}
369
370static ::mlir::Attribute readSparseElementsAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
371 ShapedType type;
372 DenseIntElementsAttr indices;
373 DenseElementsAttr values;
374 if (::mlir::succeeded(Result: reader.readType(result&: type)) &&
375 ::mlir::succeeded(Result: reader.readAttribute(result&: indices)) &&
376 ::mlir::succeeded(Result: reader.readAttribute(result&: values))) {
377 return ::mlir::getChecked<SparseElementsAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: type, params&: indices, params&: values);
378 }
379 return SparseElementsAttr();
380}
381
382static ::llvm::LogicalResult write(SparseElementsAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
383 writer.writeVarInt(/* SparseElementsAttr */ value: 20);
384 writer.writeType(type: attribute.getType());
385 writer.writeAttribute(attr: attribute.getIndices());
386 writer.writeAttribute(attr: attribute.getValues());
387 return ::mlir::success();
388 return ::mlir::failure();
389}
390
391static ::mlir::Attribute readStridedLayoutAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
392 int64_t offset;
393 ::llvm::SmallVector<int64_t> strides;
394 auto readStrides = [&]() -> ::mlir::FailureOr<int64_t> {
395 int64_t temp;
396 if (::mlir::succeeded(Result: reader.readSignedVarInt(result&: temp))) {
397 return temp;
398 }
399 return ::mlir::failure();
400 };
401 if (::mlir::succeeded(Result: reader.readSignedVarInt(result&: offset)) &&
402 ::mlir::succeeded(Result: reader.readList(result&: strides, callback&: readStrides))) {
403 return ::mlir::getChecked<StridedLayoutAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: offset, params&: strides);
404 }
405 return StridedLayoutAttr();
406}
407
408static ::llvm::LogicalResult write(StridedLayoutAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
409 writer.writeVarInt(/* StridedLayoutAttr */ value: 25);
410 writer.writeSignedVarInt(value: attribute.getOffset());
411 writer.writeList(range: attribute.getStrides(), callback: [&](int64_t attribute) {
412 writer.writeSignedVarInt(value: attribute);
413 });
414 return ::mlir::success();
415 return ::mlir::failure();
416}
417
418static ::mlir::Attribute readStringAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
419 StringRef value;
420 if (succeeded(Result: reader.readString(result&: value))) {
421 return ::mlir::getChecked<StringAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: value);
422 }
423 return StringAttr();
424}
425
426static ::mlir::Attribute readStringAttrWithType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
427 StringRef value;
428 ::mlir::Type type;
429 if (succeeded(Result: reader.readString(result&: value)) &&
430 ::mlir::succeeded(Result: reader.readType(result&: type))) {
431 return ::mlir::getChecked<StringAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: value, params&: type);
432 }
433 return StringAttr();
434}
435
436static ::llvm::LogicalResult write(StringAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
437 if (::llvm::isa<NoneType>(Val: attribute.getType())) {
438 writer.writeVarInt(/* StringAttr */ value: 2);
439 writer.writeOwnedString(str: attribute);
440 return ::mlir::success();
441 }
442 if (!::llvm::isa<NoneType>(Val: attribute.getType())) {
443 writer.writeVarInt(/* StringAttrWithType */ value: 3);
444 writer.writeOwnedString(str: attribute);
445 writer.writeType(type: attribute.getType());
446 return ::mlir::success();
447 }
448 return ::mlir::failure();
449}
450
451static ::mlir::Attribute readSymbolRefAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
452 StringAttr rootReference;
453 ::llvm::SmallVector<FlatSymbolRefAttr> nestedReferences;
454 if (::mlir::succeeded(Result: reader.readAttribute<StringAttr>(result&: rootReference)) &&
455 ::mlir::succeeded(Result: reader.readAttributes(attrs&: nestedReferences))) {
456 return ::mlir::getChecked<SymbolRefAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: rootReference, params&: nestedReferences);
457 }
458 return SymbolRefAttr();
459}
460
461static ::llvm::LogicalResult write(SymbolRefAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
462 writer.writeVarInt(/* SymbolRefAttr */ value: 5);
463 writer.writeAttribute(attr: attribute.getRootReference());
464 writer.writeAttributes(attrs: attribute.getNestedReferences());
465 return ::mlir::success();
466 return ::mlir::failure();
467}
468
469static ::mlir::Attribute readTypeAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
470 ::mlir::Type value;
471 if (::mlir::succeeded(Result: reader.readType(result&: value))) {
472 return ::mlir::getChecked<TypeAttr>(emitError: [&]() { return reader.emitError(); }, context, params&: value);
473 }
474 return TypeAttr();
475}
476
477static ::llvm::LogicalResult write(TypeAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
478 writer.writeVarInt(/* TypeAttr */ value: 6);
479 writer.writeType(type: attribute.getValue());
480 return ::mlir::success();
481 return ::mlir::failure();
482}
483
484static ::mlir::Attribute readUnitAttr(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
485 return ::mlir::getChecked<UnitAttr>(emitError: [&]() { return reader.emitError(); }, context);
486}
487
488static ::llvm::LogicalResult write(UnitAttr attribute, ::mlir::DialectBytecodeWriter &writer) {
489 writer.writeVarInt(/* UnitAttr */ value: 7);
490 return ::mlir::success();
491 return ::mlir::failure();
492}
493
494static ::mlir::Attribute readUnknownLoc(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
495 return ::mlir::getChecked<UnknownLoc>(emitError: [&]() { return reader.emitError(); }, context);
496}
497
498static ::llvm::LogicalResult write(UnknownLoc attribute, ::mlir::DialectBytecodeWriter &writer) {
499 writer.writeVarInt(/* UnknownLoc */ value: 15);
500 return ::mlir::success();
501 return ::mlir::failure();
502}
503
504static ::mlir::Attribute readAttribute(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
505 uint64_t kind;
506 if (::mlir::failed(Result: reader.readVarInt(result&: kind)))
507 return ::mlir::Attribute();
508 switch (kind) {
509 case 0:
510 return readArrayAttr(context, reader);
511 case 1:
512 return readDictionaryAttr(context, reader);
513 case 2:
514 return readStringAttr(context, reader);
515 case 3:
516 return readStringAttrWithType(context, reader);
517 case 4:
518 return readFlatSymbolRefAttr(context, reader);
519 case 5:
520 return readSymbolRefAttr(context, reader);
521 case 6:
522 return readTypeAttr(context, reader);
523 case 7:
524 return readUnitAttr(context, reader);
525 case 8:
526 return readIntegerAttr(context, reader);
527 case 9:
528 return readFloatAttr(context, reader);
529 case 10:
530 return readCallSiteLoc(context, reader);
531 case 11:
532 return readFileLineColLoc(context, reader);
533 case 12:
534 return readFusedLoc(context, reader);
535 case 13:
536 return readFusedLocWithMetadata(context, reader);
537 case 14:
538 return readNameLoc(context, reader);
539 case 15:
540 return readUnknownLoc(context, reader);
541 case 16:
542 return readDenseResourceElementsAttr(context, reader);
543 case 17:
544 return readDenseArrayAttr(context, reader);
545 case 18:
546 return readDenseTypedElementsAttr(context, reader);
547 case 19:
548 return readDenseStringElementsAttr(context, reader);
549 case 20:
550 return readSparseElementsAttr(context, reader);
551 case 21:
552 return readDistinctAttr(context, reader);
553 case 22:
554 return readFileLineColRange(context, reader);
555 case 23:
556 return readAffineMapAttr(context, reader);
557 case 24:
558 return readIntegerSetAttr(context, reader);
559 case 25:
560 return readStridedLayoutAttr(context, reader);
561 default:
562 reader.emitError() << "unknown attribute code: " << kind;
563 return ::mlir::Attribute();
564 }
565 return ::mlir::Attribute();
566}
567
568static ::llvm::LogicalResult writeAttribute(::mlir::Attribute attribute,
569 ::mlir::DialectBytecodeWriter &writer) {
570 return ::llvm::TypeSwitch<::mlir::Attribute, ::llvm::LogicalResult>(attribute)
571 .Case(caseFn: [&](AffineMapAttr t) {
572 return write(attribute: t, writer);
573 })
574 .Case(caseFn: [&](ArrayAttr t) {
575 return write(attribute: t, writer);
576 })
577 .Case(caseFn: [&](CallSiteLoc t) {
578 return write(attribute: t, writer);
579 })
580 .Case(caseFn: [&](DenseArrayAttr t) {
581 return write(attribute: t, writer);
582 })
583 .Case(caseFn: [&](DenseResourceElementsAttr t) {
584 return write(attribute: t, writer);
585 })
586 .Case(caseFn: [&](DenseStringElementsAttr t) {
587 return write(attribute: t, writer);
588 })
589 .Case(caseFn: [&](DenseTypedElementsAttr t) {
590 return write(attribute: t, writer);
591 })
592 .Case(caseFn: [&](DictionaryAttr t) {
593 return write(attribute: t, writer);
594 })
595 .Case(caseFn: [&](DistinctAttr t) {
596 return write(attribute: t, writer);
597 })
598 .Case(caseFn: [&](FileLineColRange t) {
599 return write(attribute: t, writer);
600 })
601 .Case(caseFn: [&](FlatSymbolRefAttr t) {
602 return write(attribute: t, writer);
603 })
604 .Case(caseFn: [&](FloatAttr t) {
605 return write(attribute: t, writer);
606 })
607 .Case(caseFn: [&](FusedLoc t) {
608 return write(attribute: t, writer);
609 })
610 .Case(caseFn: [&](IntegerAttr t) {
611 return write(attribute: t, writer);
612 })
613 .Case(caseFn: [&](IntegerSetAttr t) {
614 return write(attribute: t, writer);
615 })
616 .Case(caseFn: [&](NameLoc t) {
617 return write(attribute: t, writer);
618 })
619 .Case(caseFn: [&](SparseElementsAttr t) {
620 return write(attribute: t, writer);
621 })
622 .Case(caseFn: [&](StridedLayoutAttr t) {
623 return write(attribute: t, writer);
624 })
625 .Case(caseFn: [&](StringAttr t) {
626 return write(attribute: t, writer);
627 })
628 .Case(caseFn: [&](SymbolRefAttr t) {
629 return write(attribute: t, writer);
630 })
631 .Case(caseFn: [&](TypeAttr t) {
632 return write(attribute: t, writer);
633 })
634 .Case(caseFn: [&](UnitAttr t) {
635 return write(attribute: t, writer);
636 })
637 .Case(caseFn: [&](UnknownLoc t) {
638 return write(attribute: t, writer);
639 })
640 .Default(defaultFn: [&](::mlir::Attribute) { return ::mlir::failure(); });
641}
642
643static ::mlir::Type readBFloat16Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
644 return ::mlir::getChecked<BFloat16Type>(emitError: [&]() { return reader.emitError(); }, context);
645}
646
647static ::llvm::LogicalResult write(BFloat16Type type, ::mlir::DialectBytecodeWriter &writer) {
648 writer.writeVarInt(/* BFloat16Type */ value: 3);
649 return ::mlir::success();
650 return ::mlir::failure();
651}
652
653static ::mlir::Type readComplexType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
654 ::mlir::Type elementType;
655 if (::mlir::succeeded(Result: reader.readType(result&: elementType))) {
656 return ::mlir::getChecked<ComplexType>(emitError: [&]() { return reader.emitError(); }, context, params&: elementType);
657 }
658 return ComplexType();
659}
660
661static ::llvm::LogicalResult write(ComplexType type, ::mlir::DialectBytecodeWriter &writer) {
662 writer.writeVarInt(/* ComplexType */ value: 9);
663 writer.writeType(type: type.getElementType());
664 return ::mlir::success();
665 return ::mlir::failure();
666}
667
668static ::mlir::Type readFloat128Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
669 return ::mlir::getChecked<Float128Type>(emitError: [&]() { return reader.emitError(); }, context);
670}
671
672static ::llvm::LogicalResult write(Float128Type type, ::mlir::DialectBytecodeWriter &writer) {
673 writer.writeVarInt(/* Float128Type */ value: 8);
674 return ::mlir::success();
675 return ::mlir::failure();
676}
677
678static ::mlir::Type readFloat16Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
679 return ::mlir::getChecked<Float16Type>(emitError: [&]() { return reader.emitError(); }, context);
680}
681
682static ::llvm::LogicalResult write(Float16Type type, ::mlir::DialectBytecodeWriter &writer) {
683 writer.writeVarInt(/* Float16Type */ value: 4);
684 return ::mlir::success();
685 return ::mlir::failure();
686}
687
688static ::mlir::Type readFloat32Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
689 return ::mlir::getChecked<Float32Type>(emitError: [&]() { return reader.emitError(); }, context);
690}
691
692static ::llvm::LogicalResult write(Float32Type type, ::mlir::DialectBytecodeWriter &writer) {
693 writer.writeVarInt(/* Float32Type */ value: 5);
694 return ::mlir::success();
695 return ::mlir::failure();
696}
697
698static ::mlir::Type readFloat4E2M1FNType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
699 return ::mlir::getChecked<Float4E2M1FNType>(emitError: [&]() { return reader.emitError(); }, context);
700}
701
702static ::llvm::LogicalResult write(Float4E2M1FNType type, ::mlir::DialectBytecodeWriter &writer) {
703 writer.writeVarInt(/* Float4E2M1FNType */ value: 29);
704 return ::mlir::success();
705 return ::mlir::failure();
706}
707
708static ::mlir::Type readFloat64Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
709 return ::mlir::getChecked<Float64Type>(emitError: [&]() { return reader.emitError(); }, context);
710}
711
712static ::llvm::LogicalResult write(Float64Type type, ::mlir::DialectBytecodeWriter &writer) {
713 writer.writeVarInt(/* Float64Type */ value: 6);
714 return ::mlir::success();
715 return ::mlir::failure();
716}
717
718static ::mlir::Type readFloat6E2M3FNType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
719 return ::mlir::getChecked<Float6E2M3FNType>(emitError: [&]() { return reader.emitError(); }, context);
720}
721
722static ::llvm::LogicalResult write(Float6E2M3FNType type, ::mlir::DialectBytecodeWriter &writer) {
723 writer.writeVarInt(/* Float6E2M3FNType */ value: 30);
724 return ::mlir::success();
725 return ::mlir::failure();
726}
727
728static ::mlir::Type readFloat6E3M2FNType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
729 return ::mlir::getChecked<Float6E3M2FNType>(emitError: [&]() { return reader.emitError(); }, context);
730}
731
732static ::llvm::LogicalResult write(Float6E3M2FNType type, ::mlir::DialectBytecodeWriter &writer) {
733 writer.writeVarInt(/* Float6E3M2FNType */ value: 31);
734 return ::mlir::success();
735 return ::mlir::failure();
736}
737
738static ::mlir::Type readFloat80Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
739 return ::mlir::getChecked<Float80Type>(emitError: [&]() { return reader.emitError(); }, context);
740}
741
742static ::llvm::LogicalResult write(Float80Type type, ::mlir::DialectBytecodeWriter &writer) {
743 writer.writeVarInt(/* Float80Type */ value: 7);
744 return ::mlir::success();
745 return ::mlir::failure();
746}
747
748static ::mlir::Type readFloat8E3M4Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
749 return ::mlir::getChecked<Float8E3M4Type>(emitError: [&]() { return reader.emitError(); }, context);
750}
751
752static ::llvm::LogicalResult write(Float8E3M4Type type, ::mlir::DialectBytecodeWriter &writer) {
753 writer.writeVarInt(/* Float8E3M4Type */ value: 28);
754 return ::mlir::success();
755 return ::mlir::failure();
756}
757
758static ::mlir::Type readFloat8E4M3B11FNUZType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
759 return ::mlir::getChecked<Float8E4M3B11FNUZType>(emitError: [&]() { return reader.emitError(); }, context);
760}
761
762static ::llvm::LogicalResult write(Float8E4M3B11FNUZType type, ::mlir::DialectBytecodeWriter &writer) {
763 writer.writeVarInt(/* Float8E4M3B11FNUZType */ value: 27);
764 return ::mlir::success();
765 return ::mlir::failure();
766}
767
768static ::mlir::Type readFloat8E4M3FNType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
769 return ::mlir::getChecked<Float8E4M3FNType>(emitError: [&]() { return reader.emitError(); }, context);
770}
771
772static ::llvm::LogicalResult write(Float8E4M3FNType type, ::mlir::DialectBytecodeWriter &writer) {
773 writer.writeVarInt(/* Float8E4M3FNType */ value: 24);
774 return ::mlir::success();
775 return ::mlir::failure();
776}
777
778static ::mlir::Type readFloat8E4M3FNUZType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
779 return ::mlir::getChecked<Float8E4M3FNUZType>(emitError: [&]() { return reader.emitError(); }, context);
780}
781
782static ::llvm::LogicalResult write(Float8E4M3FNUZType type, ::mlir::DialectBytecodeWriter &writer) {
783 writer.writeVarInt(/* Float8E4M3FNUZType */ value: 26);
784 return ::mlir::success();
785 return ::mlir::failure();
786}
787
788static ::mlir::Type readFloat8E4M3Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
789 return ::mlir::getChecked<Float8E4M3Type>(emitError: [&]() { return reader.emitError(); }, context);
790}
791
792static ::llvm::LogicalResult write(Float8E4M3Type type, ::mlir::DialectBytecodeWriter &writer) {
793 writer.writeVarInt(/* Float8E4M3Type */ value: 23);
794 return ::mlir::success();
795 return ::mlir::failure();
796}
797
798static ::mlir::Type readFloat8E5M2FNUZType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
799 return ::mlir::getChecked<Float8E5M2FNUZType>(emitError: [&]() { return reader.emitError(); }, context);
800}
801
802static ::llvm::LogicalResult write(Float8E5M2FNUZType type, ::mlir::DialectBytecodeWriter &writer) {
803 writer.writeVarInt(/* Float8E5M2FNUZType */ value: 25);
804 return ::mlir::success();
805 return ::mlir::failure();
806}
807
808static ::mlir::Type readFloat8E5M2Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
809 return ::mlir::getChecked<Float8E5M2Type>(emitError: [&]() { return reader.emitError(); }, context);
810}
811
812static ::llvm::LogicalResult write(Float8E5M2Type type, ::mlir::DialectBytecodeWriter &writer) {
813 writer.writeVarInt(/* Float8E5M2Type */ value: 22);
814 return ::mlir::success();
815 return ::mlir::failure();
816}
817
818static ::mlir::Type readFloat8E8M0FNUType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
819 return ::mlir::getChecked<Float8E8M0FNUType>(emitError: [&]() { return reader.emitError(); }, context);
820}
821
822static ::llvm::LogicalResult write(Float8E8M0FNUType type, ::mlir::DialectBytecodeWriter &writer) {
823 writer.writeVarInt(/* Float8E8M0FNUType */ value: 32);
824 return ::mlir::success();
825 return ::mlir::failure();
826}
827
828static ::mlir::Type readFloatTF32Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
829 return ::mlir::getChecked<FloatTF32Type>(emitError: [&]() { return reader.emitError(); }, context);
830}
831
832static ::llvm::LogicalResult write(FloatTF32Type type, ::mlir::DialectBytecodeWriter &writer) {
833 writer.writeVarInt(/* FloatTF32Type */ value: 21);
834 return ::mlir::success();
835 return ::mlir::failure();
836}
837
838static ::mlir::Type readFunctionType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
839 ::llvm::SmallVector<::mlir::Type> inputs, results;
840 if (::mlir::succeeded(Result: reader.readTypes(types&: inputs)) &&
841 ::mlir::succeeded(Result: reader.readTypes(types&: results))) {
842 return ::mlir::getChecked<FunctionType>(emitError: [&]() { return reader.emitError(); }, context, params&: inputs, params&: results);
843 }
844 return FunctionType();
845}
846
847static ::llvm::LogicalResult write(FunctionType type, ::mlir::DialectBytecodeWriter &writer) {
848 writer.writeVarInt(/* FunctionType */ value: 2);
849 writer.writeTypes(types: type.getInputs());
850 writer.writeTypes(types: type.getResults());
851 return ::mlir::success();
852 return ::mlir::failure();
853}
854
855static ::mlir::Type readGraphType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
856 ::llvm::SmallVector<::mlir::Type> inputs, results;
857 if (::mlir::succeeded(Result: reader.readTypes(types&: inputs)) &&
858 ::mlir::succeeded(Result: reader.readTypes(types&: results))) {
859 return ::mlir::getChecked<GraphType>(emitError: [&]() { return reader.emitError(); }, context, params&: inputs, params&: results);
860 }
861 return GraphType();
862}
863
864static ::llvm::LogicalResult write(GraphType type, ::mlir::DialectBytecodeWriter &writer) {
865 writer.writeVarInt(/* GraphType */ value: 34);
866 writer.writeTypes(types: type.getInputs());
867 writer.writeTypes(types: type.getResults());
868 return ::mlir::success();
869 return ::mlir::failure();
870}
871
872static ::mlir::Type readIndexType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
873 return ::mlir::getChecked<IndexType>(emitError: [&]() { return reader.emitError(); }, context);
874}
875
876static ::llvm::LogicalResult write(IndexType type, ::mlir::DialectBytecodeWriter &writer) {
877 writer.writeVarInt(/* IndexType */ value: 1);
878 return ::mlir::success();
879 return ::mlir::failure();
880}
881
882static ::mlir::Type readIntegerType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
883 uint64_t _widthAndSignedness, width;
884 IntegerType::SignednessSemantics signedness;
885 if (succeeded(Result: reader.readVarInt(result&: _widthAndSignedness)) &&
886 ((width = _widthAndSignedness >> 2), true) &&
887 ((signedness = static_cast<IntegerType::SignednessSemantics>(_widthAndSignedness & 0x3)), true)) {
888 return ::mlir::getChecked<IntegerType>(emitError: [&]() { return reader.emitError(); }, context, params&: width, params&: signedness);
889 }
890 return IntegerType();
891}
892
893static ::llvm::LogicalResult write(IntegerType type, ::mlir::DialectBytecodeWriter &writer) {
894 writer.writeVarInt(/* IntegerType */ value: 0);
895 writer.writeVarInt(value: type.getWidth() << 2 | type.getSignedness());
896 return ::mlir::success();
897 return ::mlir::failure();
898}
899
900static ::mlir::Type readMXI8Type(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
901 return ::mlir::getChecked<MXI8Type>(emitError: [&]() { return reader.emitError(); }, context);
902}
903
904static ::llvm::LogicalResult write(MXI8Type type, ::mlir::DialectBytecodeWriter &writer) {
905 writer.writeVarInt(/* MXI8Type */ value: 35);
906 return ::mlir::success();
907 return ::mlir::failure();
908}
909
910static ::mlir::Type readMemRefType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
911 ::llvm::SmallVector<int64_t> shape;
912 ::mlir::Type elementType;
913 MemRefLayoutAttrInterface layout;
914 auto readShape = [&]() -> ::mlir::FailureOr<int64_t> {
915 int64_t temp;
916 if (::mlir::succeeded(Result: reader.readSignedVarInt(result&: temp))) {
917 return temp;
918 }
919 return ::mlir::failure();
920 };
921 if (::mlir::succeeded(Result: reader.readList(result&: shape, callback&: readShape)) &&
922 ::mlir::succeeded(Result: reader.readType(result&: elementType)) &&
923 ::mlir::succeeded(Result: reader.readAttribute(result&: layout))) {
924 return ::mlir::getChecked<MemRefType>(emitError: [&]() { return reader.emitError(); }, context, params&: shape, params&: elementType, params&: layout);
925 }
926 return MemRefType();
927}
928
929static ::mlir::Type readMemRefTypeWithMemSpace(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
930 ::mlir::Attribute memorySpace;
931 ::llvm::SmallVector<int64_t> shape;
932 ::mlir::Type elementType;
933 MemRefLayoutAttrInterface layout;
934 auto readShape = [&]() -> ::mlir::FailureOr<int64_t> {
935 int64_t temp;
936 if (::mlir::succeeded(Result: reader.readSignedVarInt(result&: temp))) {
937 return temp;
938 }
939 return ::mlir::failure();
940 };
941 if (::mlir::succeeded(Result: reader.readAttribute(result&: memorySpace)) &&
942 ::mlir::succeeded(Result: reader.readList(result&: shape, callback&: readShape)) &&
943 ::mlir::succeeded(Result: reader.readType(result&: elementType)) &&
944 ::mlir::succeeded(Result: reader.readAttribute(result&: layout))) {
945 return getChecked<MemRefType>(emitError: [&]() { return reader.emitError(); }, context, params&: shape, params&: elementType, params&: layout, params&: memorySpace);
946 }
947 return MemRefType();
948}
949
950static ::llvm::LogicalResult write(MemRefType type, ::mlir::DialectBytecodeWriter &writer) {
951 if (!type.getMemorySpace()) {
952 writer.writeVarInt(/* MemRefType */ value: 10);
953 writer.writeList(range: type.getShape(), callback: [&](int64_t type) {
954 writer.writeSignedVarInt(value: type);
955 });
956 writer.writeType(type: type.getElementType());
957 writer.writeAttribute(attr: type.getLayout());
958 return ::mlir::success();
959 }
960 if (!!type.getMemorySpace()) {
961 writer.writeVarInt(/* MemRefTypeWithMemSpace */ value: 11);
962 writer.writeAttribute(attr: type.getMemorySpace());
963 writer.writeList(range: type.getShape(), callback: [&](int64_t type) {
964 writer.writeSignedVarInt(value: type);
965 });
966 writer.writeType(type: type.getElementType());
967 writer.writeAttribute(attr: type.getLayout());
968 return ::mlir::success();
969 }
970 return ::mlir::failure();
971}
972
973static ::mlir::Type readNoneType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
974 return ::mlir::getChecked<NoneType>(emitError: [&]() { return reader.emitError(); }, context);
975}
976
977static ::llvm::LogicalResult write(NoneType type, ::mlir::DialectBytecodeWriter &writer) {
978 writer.writeVarInt(/* NoneType */ value: 12);
979 return ::mlir::success();
980 return ::mlir::failure();
981}
982
983static ::mlir::Type readRankedTensorType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
984 ::llvm::SmallVector<int64_t> shape;
985 ::mlir::Type elementType;
986 auto readShape = [&]() -> ::mlir::FailureOr<int64_t> {
987 int64_t temp;
988 if (::mlir::succeeded(Result: reader.readSignedVarInt(result&: temp))) {
989 return temp;
990 }
991 return ::mlir::failure();
992 };
993 if (::mlir::succeeded(Result: reader.readList(result&: shape, callback&: readShape)) &&
994 ::mlir::succeeded(Result: reader.readType(result&: elementType))) {
995 return ::mlir::getChecked<RankedTensorType>(emitError: [&]() { return reader.emitError(); }, context, params&: shape, params&: elementType);
996 }
997 return RankedTensorType();
998}
999
1000static ::mlir::Type readRankedTensorTypeWithEncoding(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1001 ::mlir::Attribute encoding;
1002 ::llvm::SmallVector<int64_t> shape;
1003 ::mlir::Type elementType;
1004 auto readShape = [&]() -> ::mlir::FailureOr<int64_t> {
1005 int64_t temp;
1006 if (::mlir::succeeded(Result: reader.readSignedVarInt(result&: temp))) {
1007 return temp;
1008 }
1009 return ::mlir::failure();
1010 };
1011 if (::mlir::succeeded(Result: reader.readAttribute(result&: encoding)) &&
1012 ::mlir::succeeded(Result: reader.readList(result&: shape, callback&: readShape)) &&
1013 ::mlir::succeeded(Result: reader.readType(result&: elementType))) {
1014 return getChecked<RankedTensorType>(emitError: [&]() { return reader.emitError(); }, context, params&: shape, params&: elementType, params&: encoding);
1015 }
1016 return RankedTensorType();
1017}
1018
1019static ::llvm::LogicalResult write(RankedTensorType type, ::mlir::DialectBytecodeWriter &writer) {
1020 if (!type.getEncoding()) {
1021 writer.writeVarInt(/* RankedTensorType */ value: 13);
1022 writer.writeList(range: type.getShape(), callback: [&](int64_t type) {
1023 writer.writeSignedVarInt(value: type);
1024 });
1025 writer.writeType(type: type.getElementType());
1026 return ::mlir::success();
1027 }
1028 if (type.getEncoding()) {
1029 writer.writeVarInt(/* RankedTensorTypeWithEncoding */ value: 14);
1030 writer.writeAttribute(attr: type.getEncoding());
1031 writer.writeList(range: type.getShape(), callback: [&](int64_t type) {
1032 writer.writeSignedVarInt(value: type);
1033 });
1034 writer.writeType(type: type.getElementType());
1035 return ::mlir::success();
1036 }
1037 return ::mlir::failure();
1038}
1039
1040static ::mlir::Type readTokenType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1041 return ::mlir::getChecked<TokenType>(emitError: [&]() { return reader.emitError(); }, context);
1042}
1043
1044static ::llvm::LogicalResult write(TokenType type, ::mlir::DialectBytecodeWriter &writer) {
1045 writer.writeVarInt(/* TokenType */ value: 33);
1046 return ::mlir::success();
1047 return ::mlir::failure();
1048}
1049
1050static ::mlir::Type readTupleType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1051 ::llvm::SmallVector<::mlir::Type> types;
1052 if (::mlir::succeeded(Result: reader.readTypes(types))) {
1053 return ::mlir::getChecked<TupleType>(emitError: [&]() { return reader.emitError(); }, context, params&: types);
1054 }
1055 return TupleType();
1056}
1057
1058static ::llvm::LogicalResult write(TupleType type, ::mlir::DialectBytecodeWriter &writer) {
1059 writer.writeVarInt(/* TupleType */ value: 15);
1060 writer.writeTypes(types: type.getTypes());
1061 return ::mlir::success();
1062 return ::mlir::failure();
1063}
1064
1065static ::mlir::Type readUnrankedMemRefType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1066 ::mlir::Type elementType;
1067 if (::mlir::succeeded(Result: reader.readType(result&: elementType))) {
1068 return getChecked<UnrankedMemRefType>(emitError: [&]() { return reader.emitError(); }, context, params&: elementType, params: Attribute());
1069 }
1070 return UnrankedMemRefType();
1071}
1072
1073static ::mlir::Type readUnrankedMemRefTypeWithMemSpace(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1074 ::mlir::Attribute memorySpace;
1075 ::mlir::Type elementType;
1076 if (::mlir::succeeded(Result: reader.readAttribute(result&: memorySpace)) &&
1077 ::mlir::succeeded(Result: reader.readType(result&: elementType))) {
1078 return getChecked<UnrankedMemRefType>(emitError: [&]() { return reader.emitError(); }, context, params&: elementType, params&: memorySpace);
1079 }
1080 return UnrankedMemRefType();
1081}
1082
1083static ::llvm::LogicalResult write(UnrankedMemRefType type, ::mlir::DialectBytecodeWriter &writer) {
1084 if (!type.getMemorySpace()) {
1085 writer.writeVarInt(/* UnrankedMemRefType */ value: 16);
1086 writer.writeType(type: type.getElementType());
1087 return ::mlir::success();
1088 }
1089 if (type.getMemorySpace()) {
1090 writer.writeVarInt(/* UnrankedMemRefTypeWithMemSpace */ value: 17);
1091 writer.writeAttribute(attr: type.getMemorySpace());
1092 writer.writeType(type: type.getElementType());
1093 return ::mlir::success();
1094 }
1095 return ::mlir::failure();
1096}
1097
1098static ::mlir::Type readUnrankedTensorType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1099 ::mlir::Type elementType;
1100 if (::mlir::succeeded(Result: reader.readType(result&: elementType))) {
1101 return ::mlir::getChecked<UnrankedTensorType>(emitError: [&]() { return reader.emitError(); }, context, params&: elementType);
1102 }
1103 return UnrankedTensorType();
1104}
1105
1106static ::llvm::LogicalResult write(UnrankedTensorType type, ::mlir::DialectBytecodeWriter &writer) {
1107 writer.writeVarInt(/* UnrankedTensorType */ value: 18);
1108 writer.writeType(type: type.getElementType());
1109 return ::mlir::success();
1110 return ::mlir::failure();
1111}
1112
1113static ::mlir::Type readVectorType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1114 ::llvm::SmallVector<int64_t> shape;
1115 ::mlir::Type elementType;
1116 auto readShape = [&]() -> ::mlir::FailureOr<int64_t> {
1117 int64_t temp;
1118 if (::mlir::succeeded(Result: reader.readSignedVarInt(result&: temp))) {
1119 return temp;
1120 }
1121 return ::mlir::failure();
1122 };
1123 if (::mlir::succeeded(Result: reader.readList(result&: shape, callback&: readShape)) &&
1124 ::mlir::succeeded(Result: reader.readType(result&: elementType))) {
1125 return VectorType::getChecked(emitError: [&]() { return reader.emitError(msg: "invalid vector type"); }, shape, elementType);
1126 }
1127 return VectorType();
1128}
1129
1130static ::mlir::Type readVectorTypeWithScalableDims(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1131 ::llvm::SmallVector<bool> scalableDims;
1132 ::llvm::SmallVector<int64_t> shape;
1133 ::mlir::Type elementType;
1134 auto readScalableDims = [&]() -> ::mlir::FailureOr<bool> {
1135 bool temp;
1136 if (::mlir::succeeded(Result: reader.readBool(result&: temp))) {
1137 return temp;
1138 }
1139 return ::mlir::failure();
1140 };
1141 auto readShape = [&]() -> ::mlir::FailureOr<int64_t> {
1142 int64_t temp;
1143 if (::mlir::succeeded(Result: reader.readSignedVarInt(result&: temp))) {
1144 return temp;
1145 }
1146 return ::mlir::failure();
1147 };
1148 if (::mlir::succeeded(Result: reader.readList(result&: scalableDims, callback&: readScalableDims)) &&
1149 ::mlir::succeeded(Result: reader.readList(result&: shape, callback&: readShape)) &&
1150 ::mlir::succeeded(Result: reader.readType(result&: elementType))) {
1151 return getChecked<VectorType>(emitError: [&]() { return reader.emitError(); }, context, params&: shape, params&: elementType, params&: scalableDims);
1152 }
1153 return VectorType();
1154}
1155
1156static ::llvm::LogicalResult write(VectorType type, ::mlir::DialectBytecodeWriter &writer) {
1157 if (!type.isScalable()) {
1158 writer.writeVarInt(/* VectorType */ value: 19);
1159 writer.writeList(range: type.getShape(), callback: [&](int64_t type) {
1160 writer.writeSignedVarInt(value: type);
1161 });
1162 writer.writeType(type: type.getElementType());
1163 return ::mlir::success();
1164 }
1165 if (type.isScalable()) {
1166 writer.writeVarInt(/* VectorTypeWithScalableDims */ value: 20);
1167 writer.writeList(range: type.getScalableDims(), callback: [&](bool type) {
1168 writer.writeOwnedBool(value: type);
1169 });
1170 writer.writeList(range: type.getShape(), callback: [&](int64_t type) {
1171 writer.writeSignedVarInt(value: type);
1172 });
1173 writer.writeType(type: type.getElementType());
1174 return ::mlir::success();
1175 }
1176 return ::mlir::failure();
1177}
1178
1179static ::mlir::Type readType(::mlir::MLIRContext* context, ::mlir::DialectBytecodeReader &reader) {
1180 uint64_t kind;
1181 if (::mlir::failed(Result: reader.readVarInt(result&: kind)))
1182 return ::mlir::Type();
1183 switch (kind) {
1184 case 0:
1185 return readIntegerType(context, reader);
1186 case 1:
1187 return readIndexType(context, reader);
1188 case 2:
1189 return readFunctionType(context, reader);
1190 case 3:
1191 return readBFloat16Type(context, reader);
1192 case 4:
1193 return readFloat16Type(context, reader);
1194 case 5:
1195 return readFloat32Type(context, reader);
1196 case 6:
1197 return readFloat64Type(context, reader);
1198 case 7:
1199 return readFloat80Type(context, reader);
1200 case 8:
1201 return readFloat128Type(context, reader);
1202 case 9:
1203 return readComplexType(context, reader);
1204 case 10:
1205 return readMemRefType(context, reader);
1206 case 11:
1207 return readMemRefTypeWithMemSpace(context, reader);
1208 case 12:
1209 return readNoneType(context, reader);
1210 case 13:
1211 return readRankedTensorType(context, reader);
1212 case 14:
1213 return readRankedTensorTypeWithEncoding(context, reader);
1214 case 15:
1215 return readTupleType(context, reader);
1216 case 16:
1217 return readUnrankedMemRefType(context, reader);
1218 case 17:
1219 return readUnrankedMemRefTypeWithMemSpace(context, reader);
1220 case 18:
1221 return readUnrankedTensorType(context, reader);
1222 case 19:
1223 return readVectorType(context, reader);
1224 case 20:
1225 return readVectorTypeWithScalableDims(context, reader);
1226 case 21:
1227 return readFloatTF32Type(context, reader);
1228 case 22:
1229 return readFloat8E5M2Type(context, reader);
1230 case 23:
1231 return readFloat8E4M3Type(context, reader);
1232 case 24:
1233 return readFloat8E4M3FNType(context, reader);
1234 case 25:
1235 return readFloat8E5M2FNUZType(context, reader);
1236 case 26:
1237 return readFloat8E4M3FNUZType(context, reader);
1238 case 27:
1239 return readFloat8E4M3B11FNUZType(context, reader);
1240 case 28:
1241 return readFloat8E3M4Type(context, reader);
1242 case 29:
1243 return readFloat4E2M1FNType(context, reader);
1244 case 30:
1245 return readFloat6E2M3FNType(context, reader);
1246 case 31:
1247 return readFloat6E3M2FNType(context, reader);
1248 case 32:
1249 return readFloat8E8M0FNUType(context, reader);
1250 case 33:
1251 return readTokenType(context, reader);
1252 case 34:
1253 return readGraphType(context, reader);
1254 case 35:
1255 return readMXI8Type(context, reader);
1256 default:
1257 reader.emitError() << "unknown type code: " << kind;
1258 return ::mlir::Type();
1259 }
1260 return ::mlir::Type();
1261}
1262
1263static ::llvm::LogicalResult writeType(::mlir::Type type,
1264 ::mlir::DialectBytecodeWriter &writer) {
1265 return ::llvm::TypeSwitch<::mlir::Type, ::llvm::LogicalResult>(type)
1266 .Case(caseFn: [&](BFloat16Type t) {
1267 return write(type: t, writer);
1268 })
1269 .Case(caseFn: [&](ComplexType t) {
1270 return write(type: t, writer);
1271 })
1272 .Case(caseFn: [&](Float128Type t) {
1273 return write(type: t, writer);
1274 })
1275 .Case(caseFn: [&](Float16Type t) {
1276 return write(type: t, writer);
1277 })
1278 .Case(caseFn: [&](Float32Type t) {
1279 return write(type: t, writer);
1280 })
1281 .Case(caseFn: [&](Float4E2M1FNType t) {
1282 return write(type: t, writer);
1283 })
1284 .Case(caseFn: [&](Float64Type t) {
1285 return write(type: t, writer);
1286 })
1287 .Case(caseFn: [&](Float6E2M3FNType t) {
1288 return write(type: t, writer);
1289 })
1290 .Case(caseFn: [&](Float6E3M2FNType t) {
1291 return write(type: t, writer);
1292 })
1293 .Case(caseFn: [&](Float80Type t) {
1294 return write(type: t, writer);
1295 })
1296 .Case(caseFn: [&](Float8E3M4Type t) {
1297 return write(type: t, writer);
1298 })
1299 .Case(caseFn: [&](Float8E4M3B11FNUZType t) {
1300 return write(type: t, writer);
1301 })
1302 .Case(caseFn: [&](Float8E4M3FNType t) {
1303 return write(type: t, writer);
1304 })
1305 .Case(caseFn: [&](Float8E4M3FNUZType t) {
1306 return write(type: t, writer);
1307 })
1308 .Case(caseFn: [&](Float8E4M3Type t) {
1309 return write(type: t, writer);
1310 })
1311 .Case(caseFn: [&](Float8E5M2FNUZType t) {
1312 return write(type: t, writer);
1313 })
1314 .Case(caseFn: [&](Float8E5M2Type t) {
1315 return write(type: t, writer);
1316 })
1317 .Case(caseFn: [&](Float8E8M0FNUType t) {
1318 return write(type: t, writer);
1319 })
1320 .Case(caseFn: [&](FloatTF32Type t) {
1321 return write(type: t, writer);
1322 })
1323 .Case(caseFn: [&](FunctionType t) {
1324 return write(type: t, writer);
1325 })
1326 .Case(caseFn: [&](GraphType t) {
1327 return write(type: t, writer);
1328 })
1329 .Case(caseFn: [&](IndexType t) {
1330 return write(type: t, writer);
1331 })
1332 .Case(caseFn: [&](IntegerType t) {
1333 return write(type: t, writer);
1334 })
1335 .Case(caseFn: [&](MXI8Type t) {
1336 return write(type: t, writer);
1337 })
1338 .Case(caseFn: [&](MemRefType t) {
1339 return write(type: t, writer);
1340 })
1341 .Case(caseFn: [&](NoneType t) {
1342 return write(type: t, writer);
1343 })
1344 .Case(caseFn: [&](RankedTensorType t) {
1345 return write(type: t, writer);
1346 })
1347 .Case(caseFn: [&](TokenType t) {
1348 return write(type: t, writer);
1349 })
1350 .Case(caseFn: [&](TupleType t) {
1351 return write(type: t, writer);
1352 })
1353 .Case(caseFn: [&](UnrankedMemRefType t) {
1354 return write(type: t, writer);
1355 })
1356 .Case(caseFn: [&](UnrankedTensorType t) {
1357 return write(type: t, writer);
1358 })
1359 .Case(caseFn: [&](VectorType t) {
1360 return write(type: t, writer);
1361 })
1362 .Default(defaultFn: [&](::mlir::Type) { return ::mlir::failure(); });
1363}
1364
1365