1//===- BuiltinDialectBytecode.cpp - Builtin Bytecode Implementation -------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "BuiltinDialectBytecode.h"
10#include "AttributeDetail.h"
11#include "mlir/Bytecode/BytecodeImplementation.h"
12#include "mlir/IR/BuiltinAttributes.h"
13#include "mlir/IR/BuiltinDialect.h"
14#include "mlir/IR/BuiltinTypes.h"
15#include "mlir/IR/Diagnostics.h"
16#include "mlir/IR/DialectResourceBlobManager.h"
17#include "mlir/IR/Location.h"
18#include "mlir/Support/LLVM.h"
19#include "llvm/ADT/TypeSwitch.h"
20#include <cstdint>
21
22using namespace mlir;
23
24//===----------------------------------------------------------------------===//
25// BuiltinDialectBytecodeInterface
26//===----------------------------------------------------------------------===//
27
28namespace {
29
30//===----------------------------------------------------------------------===//
31// Utility functions
32//===----------------------------------------------------------------------===//
33
34// TODO: Move these to separate file.
35
36// Returns the bitwidth if known, else return 0.
37static unsigned getIntegerBitWidth(DialectBytecodeReader &reader, Type type) {
38 if (auto intType = dyn_cast<IntegerType>(type)) {
39 return intType.getWidth();
40 }
41 if (llvm::isa<IndexType>(Val: type)) {
42 return IndexType::kInternalStorageBitWidth;
43 }
44 reader.emitError()
45 << "expected integer or index type for IntegerAttr, but got: " << type;
46 return 0;
47}
48
49static LogicalResult readAPIntWithKnownWidth(DialectBytecodeReader &reader,
50 Type type, FailureOr<APInt> &val) {
51 unsigned bitWidth = getIntegerBitWidth(reader, type);
52 val = reader.readAPIntWithKnownWidth(bitWidth);
53 return val;
54}
55
56static LogicalResult
57readAPFloatWithKnownSemantics(DialectBytecodeReader &reader, Type type,
58 FailureOr<APFloat> &val) {
59 auto ftype = dyn_cast<FloatType>(type);
60 if (!ftype)
61 return failure();
62 val = reader.readAPFloatWithKnownSemantics(semantics: ftype.getFloatSemantics());
63 return success();
64}
65
66LogicalResult
67readPotentiallySplatString(DialectBytecodeReader &reader, ShapedType type,
68 bool isSplat,
69 SmallVectorImpl<StringRef> &rawStringData) {
70 rawStringData.resize(isSplat ? 1 : type.getNumElements());
71 for (StringRef &value : rawStringData)
72 if (failed(Result: reader.readString(result&: value)))
73 return failure();
74 return success();
75}
76
77static void writePotentiallySplatString(DialectBytecodeWriter &writer,
78 DenseStringElementsAttr attr) {
79 bool isSplat = attr.isSplat();
80 if (isSplat)
81 return writer.writeOwnedString(str: attr.getRawStringData().front());
82
83 for (StringRef str : attr.getRawStringData())
84 writer.writeOwnedString(str);
85}
86
87static FileLineColRange getFileLineColRange(MLIRContext *context,
88 StringAttr filename,
89 ArrayRef<uint64_t> lineCols) {
90 switch (lineCols.size()) {
91 case 0:
92 return FileLineColRange::get(filename);
93 case 1:
94 return FileLineColRange::get(filename, lineCols[0]);
95 case 2:
96 return FileLineColRange::get(filename, lineCols[0], lineCols[1]);
97 case 3:
98 return FileLineColRange::get(filename, lineCols[0], lineCols[1],
99 lineCols[2]);
100 case 4:
101 return FileLineColRange::get(filename, lineCols[0], lineCols[1],
102 lineCols[2], lineCols[3]);
103 default:
104 return {};
105 }
106}
107
108static LogicalResult
109readFileLineColRangeLocs(DialectBytecodeReader &reader,
110 SmallVectorImpl<uint64_t> &lineCols) {
111 return reader.readList(
112 result&: lineCols, callback: [&reader](uint64_t &val) { return reader.readVarInt(result&: val); });
113}
114
115static void writeFileLineColRangeLocs(DialectBytecodeWriter &writer,
116 FileLineColRange range) {
117 if (range.getStartLine() == 0 && range.getStartColumn() == 0 &&
118 range.getEndLine() == 0 && range.getEndColumn() == 0) {
119 writer.writeVarInt(value: 0);
120 return;
121 }
122 if (range.getStartColumn() == 0 &&
123 range.getStartLine() == range.getEndLine()) {
124 writer.writeVarInt(value: 1);
125 writer.writeVarInt(value: range.getStartLine());
126 return;
127 }
128 // The single file:line:col is handled by other writer, but checked here for
129 // completeness.
130 if (range.getEndColumn() == range.getStartColumn() &&
131 range.getStartLine() == range.getEndLine()) {
132 writer.writeVarInt(value: 2);
133 writer.writeVarInt(value: range.getStartLine());
134 writer.writeVarInt(value: range.getStartColumn());
135 return;
136 }
137 if (range.getStartLine() == range.getEndLine()) {
138 writer.writeVarInt(value: 3);
139 writer.writeVarInt(value: range.getStartLine());
140 writer.writeVarInt(value: range.getStartColumn());
141 writer.writeVarInt(value: range.getEndColumn());
142 return;
143 }
144 writer.writeVarInt(value: 4);
145 writer.writeVarInt(value: range.getStartLine());
146 writer.writeVarInt(value: range.getStartColumn());
147 writer.writeVarInt(value: range.getEndLine());
148 writer.writeVarInt(value: range.getEndColumn());
149}
150
151#include "mlir/IR/BuiltinDialectBytecode.cpp.inc"
152
153/// This class implements the bytecode interface for the builtin dialect.
154struct BuiltinDialectBytecodeInterface : public BytecodeDialectInterface {
155 BuiltinDialectBytecodeInterface(Dialect *dialect)
156 : BytecodeDialectInterface(dialect) {}
157
158 //===--------------------------------------------------------------------===//
159 // Attributes
160
161 Attribute readAttribute(DialectBytecodeReader &reader) const override {
162 return ::readAttribute(getContext(), reader);
163 }
164
165 LogicalResult writeAttribute(Attribute attr,
166 DialectBytecodeWriter &writer) const override {
167 return ::writeAttribute(attr, writer);
168 }
169
170 //===--------------------------------------------------------------------===//
171 // Types
172
173 Type readType(DialectBytecodeReader &reader) const override {
174 return ::readType(getContext(), reader);
175 }
176
177 LogicalResult writeType(Type type,
178 DialectBytecodeWriter &writer) const override {
179 return ::writeType(type, writer);
180 }
181};
182} // namespace
183
184void builtin_dialect_detail::addBytecodeInterface(BuiltinDialect *dialect) {
185 dialect->addInterfaces<BuiltinDialectBytecodeInterface>();
186}
187

source code of mlir/lib/IR/BuiltinDialectBytecode.cpp