1//===- TestAttributes.cpp - MLIR Test Dialect Attributes --------*- C++ -*-===//
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// This file contains attributes defined by the TestDialect for testing various
10// features of MLIR.
11//
12//===----------------------------------------------------------------------===//
13
14#include "TestAttributes.h"
15#include "TestDialect.h"
16#include "TestTypes.h"
17#include "mlir/IR/Attributes.h"
18#include "mlir/IR/DialectImplementation.h"
19#include "mlir/IR/ExtensibleDialect.h"
20#include "mlir/IR/OpImplementation.h"
21#include "mlir/IR/Types.h"
22#include "llvm/ADT/APFloat.h"
23#include "llvm/ADT/Hashing.h"
24#include "llvm/ADT/bit.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/raw_ostream.h"
27
28using namespace mlir;
29using namespace test;
30
31//===----------------------------------------------------------------------===//
32// CompoundAAttr
33//===----------------------------------------------------------------------===//
34
35Attribute CompoundAAttr::parse(AsmParser &parser, Type type) {
36 int widthOfSomething;
37 Type oneType;
38 SmallVector<int, 4> arrayOfInts;
39 if (parser.parseLess() || parser.parseInteger(widthOfSomething) ||
40 parser.parseComma() || parser.parseType(oneType) || parser.parseComma() ||
41 parser.parseLSquare())
42 return Attribute();
43
44 int intVal;
45 while (!*parser.parseOptionalInteger(intVal)) {
46 arrayOfInts.push_back(intVal);
47 if (parser.parseOptionalComma())
48 break;
49 }
50
51 if (parser.parseRSquare() || parser.parseGreater())
52 return Attribute();
53 return get(parser.getContext(), widthOfSomething, oneType, arrayOfInts);
54}
55
56void CompoundAAttr::print(AsmPrinter &printer) const {
57 printer << "<" << getWidthOfSomething() << ", " << getOneType() << ", [";
58 llvm::interleaveComma(getArrayOfInts(), printer);
59 printer << "]>";
60}
61
62//===----------------------------------------------------------------------===//
63// CompoundAAttr
64//===----------------------------------------------------------------------===//
65
66Attribute TestDecimalShapeAttr::parse(AsmParser &parser, Type type) {
67 if (parser.parseLess()) {
68 return Attribute();
69 }
70 SmallVector<int64_t> shape;
71 if (parser.parseOptionalGreater()) {
72 auto parseDecimal = [&]() {
73 shape.emplace_back();
74 auto parseResult = parser.parseOptionalDecimalInteger(shape.back());
75 if (!parseResult.has_value() || failed(*parseResult)) {
76 parser.emitError(parser.getCurrentLocation()) << "expected an integer";
77 return failure();
78 }
79 return success();
80 };
81 if (failed(parseDecimal())) {
82 return Attribute();
83 }
84 while (failed(parser.parseOptionalGreater())) {
85 if (failed(parser.parseXInDimensionList()) || failed(parseDecimal())) {
86 return Attribute();
87 }
88 }
89 }
90 return get(parser.getContext(), shape);
91}
92
93void TestDecimalShapeAttr::print(AsmPrinter &printer) const {
94 printer << "<";
95 llvm::interleave(getShape(), printer, "x");
96 printer << ">";
97}
98
99Attribute TestI64ElementsAttr::parse(AsmParser &parser, Type type) {
100 SmallVector<uint64_t> elements;
101 if (parser.parseLess() || parser.parseLSquare())
102 return Attribute();
103 uint64_t intVal;
104 while (succeeded(Result: *parser.parseOptionalInteger(result&: intVal))) {
105 elements.push_back(Elt: intVal);
106 if (parser.parseOptionalComma())
107 break;
108 }
109
110 if (parser.parseRSquare() || parser.parseGreater())
111 return Attribute();
112 return parser.getChecked<TestI64ElementsAttr>(
113 params: parser.getContext(), params: llvm::cast<ShapedType>(Val&: type), params&: elements);
114}
115
116void TestI64ElementsAttr::print(AsmPrinter &printer) const {
117 printer << "<[";
118 llvm::interleaveComma(getElements(), printer);
119 printer << "]>";
120}
121
122LogicalResult
123TestI64ElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
124 ShapedType type, ArrayRef<uint64_t> elements) {
125 if (type.getNumElements() != static_cast<int64_t>(elements.size())) {
126 return emitError()
127 << "number of elements does not match the provided shape type, got: "
128 << elements.size() << ", but expected: " << type.getNumElements();
129 }
130 if (type.getRank() != 1 || !type.getElementType().isSignlessInteger(width: 64))
131 return emitError() << "expected single rank 64-bit shape type, but got: "
132 << type;
133 return success();
134}
135
136LogicalResult TestAttrWithFormatAttr::verify(
137 function_ref<InFlightDiagnostic()> emitError, int64_t one, std::string two,
138 IntegerAttr three, ArrayRef<int> four, uint64_t five, ArrayRef<int> six,
139 ArrayRef<AttrWithTypeBuilderAttr> arrayOfAttrs) {
140 if (four.size() != static_cast<unsigned>(one))
141 return emitError() << "expected 'one' to equal 'four.size()'";
142 return success();
143}
144
145//===----------------------------------------------------------------------===//
146// Utility Functions for Generated Attributes
147//===----------------------------------------------------------------------===//
148
149static FailureOr<SmallVector<int>> parseIntArray(AsmParser &parser) {
150 SmallVector<int> ints;
151 if (parser.parseLSquare() || parser.parseCommaSeparatedList(parseElementFn: [&]() {
152 ints.push_back(Elt: 0);
153 return parser.parseInteger(result&: ints.back());
154 }) ||
155 parser.parseRSquare())
156 return failure();
157 return ints;
158}
159
160static void printIntArray(AsmPrinter &printer, ArrayRef<int> ints) {
161 printer << '[';
162 llvm::interleaveComma(c: ints, os&: printer);
163 printer << ']';
164}
165
166//===----------------------------------------------------------------------===//
167// TestSubElementsAccessAttr
168//===----------------------------------------------------------------------===//
169
170Attribute TestSubElementsAccessAttr::parse(::mlir::AsmParser &parser,
171 ::mlir::Type type) {
172 Attribute first, second, third;
173 if (parser.parseLess() || parser.parseAttribute(first) ||
174 parser.parseComma() || parser.parseAttribute(second) ||
175 parser.parseComma() || parser.parseAttribute(third) ||
176 parser.parseGreater()) {
177 return {};
178 }
179 return get(parser.getContext(), first, second, third);
180}
181
182void TestSubElementsAccessAttr::print(::mlir::AsmPrinter &printer) const {
183 printer << "<" << getFirst() << ", " << getSecond() << ", " << getThird()
184 << ">";
185}
186
187//===----------------------------------------------------------------------===//
188// TestExtern1DI64ElementsAttr
189//===----------------------------------------------------------------------===//
190
191ArrayRef<uint64_t> TestExtern1DI64ElementsAttr::getElements() const {
192 if (auto *blob = getHandle().getBlob())
193 return blob->getDataAs<uint64_t>();
194 return {};
195}
196
197//===----------------------------------------------------------------------===//
198// TestCustomAnchorAttr
199//===----------------------------------------------------------------------===//
200
201static ParseResult parseTrueFalse(AsmParser &p, std::optional<int> &result) {
202 bool b;
203 if (p.parseInteger(result&: b))
204 return failure();
205 result = b;
206 return success();
207}
208
209static void printTrueFalse(AsmPrinter &p, std::optional<int> result) {
210 p << (*result ? "true" : "false");
211}
212
213//===----------------------------------------------------------------------===//
214// TestCopyCountAttr Implementation
215//===----------------------------------------------------------------------===//
216
217LogicalResult TestCopyCountAttr::verify(
218 llvm::function_ref<::mlir::InFlightDiagnostic()> /*emitError*/,
219 CopyCount /*copy_count*/) {
220 return success();
221}
222
223//===----------------------------------------------------------------------===//
224// TestSymbolRefAttr
225//===----------------------------------------------------------------------===//
226
227LogicalResult
228TestSymbolRefAttr::verifySymbolUses(Operation *op,
229 SymbolTableCollection &symbolTable) const {
230 // Verify that the referenced symbol exists
231 if (!symbolTable.lookupNearestSymbolFrom<SymbolOpInterface>(op, getSymbol()))
232 return op->emitOpError()
233 << "TestSymbolRefAttr::verifySymbolUses: '" << getSymbol()
234 << "' does not reference a valid symbol";
235 return success();
236}
237
238//===----------------------------------------------------------------------===//
239// Generated Attribute Definitions
240//===----------------------------------------------------------------------===//
241
242//===----------------------------------------------------------------------===//
243// CopyCountAttr Implementation
244//===----------------------------------------------------------------------===//
245
246CopyCount::CopyCount(const CopyCount &rhs) : value(rhs.value) {
247 CopyCount::counter++;
248}
249
250CopyCount &CopyCount::operator=(const CopyCount &rhs) {
251 CopyCount::counter++;
252 value = rhs.value;
253 return *this;
254}
255
256int CopyCount::counter;
257
258static bool operator==(const test::CopyCount &lhs, const test::CopyCount &rhs) {
259 return lhs.value == rhs.value;
260}
261
262llvm::raw_ostream &test::operator<<(llvm::raw_ostream &os,
263 const test::CopyCount &value) {
264 return os << value.value;
265}
266
267template <>
268struct mlir::FieldParser<test::CopyCount> {
269 static FailureOr<test::CopyCount> parse(AsmParser &parser) {
270 std::string value;
271 if (parser.parseKeyword(keyword: value))
272 return failure();
273 return test::CopyCount(value);
274 }
275};
276namespace test {
277static llvm::hash_code hash_value(const test::CopyCount &copyCount) {
278 return llvm::hash_value(arg: copyCount.value);
279}
280} // namespace test
281
282//===----------------------------------------------------------------------===//
283// TestConditionalAliasAttr
284//===----------------------------------------------------------------------===//
285
286/// Attempt to parse the conditionally-aliased string attribute as a keyword or
287/// string, else try to parse an alias.
288static ParseResult parseConditionalAlias(AsmParser &p, StringAttr &value) {
289 std::string str;
290 if (succeeded(Result: p.parseOptionalKeywordOrString(result: &str))) {
291 value = StringAttr::get(context: p.getContext(), bytes: str);
292 return success();
293 }
294 return p.parseAttribute(result&: value);
295}
296
297/// Print the string attribute as an alias if it has one, otherwise print it as
298/// a keyword if possible.
299static void printConditionalAlias(AsmPrinter &p, StringAttr value) {
300 if (succeeded(Result: p.printAlias(attr: value)))
301 return;
302 p.printKeywordOrString(keyword: value);
303}
304
305//===----------------------------------------------------------------------===//
306// Custom Float Attribute
307//===----------------------------------------------------------------------===//
308
309static void printCustomFloatAttr(AsmPrinter &p, StringAttr typeStrAttr,
310 APFloat value) {
311 p << typeStrAttr << " : " << value;
312}
313
314static ParseResult parseCustomFloatAttr(AsmParser &p, StringAttr &typeStrAttr,
315 FailureOr<APFloat> &value) {
316
317 std::string str;
318 if (p.parseString(string: &str))
319 return failure();
320
321 typeStrAttr = StringAttr::get(context: p.getContext(), bytes: str);
322
323 if (p.parseColon())
324 return failure();
325
326 const llvm::fltSemantics *semantics;
327 if (str == "float")
328 semantics = &llvm::APFloat::IEEEsingle();
329 else if (str == "double")
330 semantics = &llvm::APFloat::IEEEdouble();
331 else if (str == "fp80")
332 semantics = &llvm::APFloat::x87DoubleExtended();
333 else
334 return p.emitError(loc: p.getCurrentLocation(), message: "unknown float type, expected "
335 "'float', 'double' or 'fp80'");
336
337 APFloat parsedValue(0.0);
338 if (p.parseFloat(semantics: *semantics, result&: parsedValue))
339 return failure();
340
341 value.emplace(args&: parsedValue);
342 return success();
343}
344
345//===----------------------------------------------------------------------===//
346// TestCustomStructAttr
347//===----------------------------------------------------------------------===//
348
349static void printCustomStructAttr(AsmPrinter &p, int64_t value) {
350 if (ShapedType::isDynamic(dValue: value)) {
351 p << "?";
352 } else {
353 p.printStrippedAttrOrType(attrOrType: value);
354 }
355}
356
357static ParseResult parseCustomStructAttr(AsmParser &p, int64_t &value) {
358 if (succeeded(Result: p.parseOptionalQuestion())) {
359 value = ShapedType::kDynamic;
360 return success();
361 }
362 return p.parseInteger(result&: value);
363}
364
365static void printCustomOptStructFieldAttr(AsmPrinter &p, ArrayAttr attr) {
366 if (attr && attr.size() == 1 && isa<IntegerAttr>(Val: attr[0])) {
367 p << cast<IntegerAttr>(Val: attr[0]).getInt();
368 } else {
369 p.printStrippedAttrOrType(attrOrType: attr);
370 }
371}
372
373static ParseResult parseCustomOptStructFieldAttr(AsmParser &p,
374 ArrayAttr &attr) {
375 int64_t value;
376 OptionalParseResult result = p.parseOptionalInteger(result&: value);
377 if (result.has_value()) {
378 if (failed(Result: result.value()))
379 return failure();
380 attr = ArrayAttr::get(
381 context: p.getContext(),
382 value: {IntegerAttr::get(type: IntegerType::get(context: p.getContext(), width: 64), value)});
383 return success();
384 }
385 return p.parseAttribute(result&: attr);
386}
387
388//===----------------------------------------------------------------------===//
389// TestOpAsmAttrInterfaceAttr
390//===----------------------------------------------------------------------===//
391
392::mlir::OpAsmDialectInterface::AliasResult
393TestOpAsmAttrInterfaceAttr::getAlias(::llvm::raw_ostream &os) const {
394 os << "op_asm_attr_interface_";
395 os << getValue().getValue();
396 return ::mlir::OpAsmDialectInterface::AliasResult::FinalAlias;
397}
398
399//===----------------------------------------------------------------------===//
400// TestConstMemorySpaceAttr
401//===----------------------------------------------------------------------===//
402
403bool TestConstMemorySpaceAttr::isValidLoad(
404 Type type, mlir::ptr::AtomicOrdering ordering,
405 std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout,
406 function_ref<InFlightDiagnostic()> emitError) const {
407 return true;
408}
409
410bool TestConstMemorySpaceAttr::isValidStore(
411 Type type, mlir::ptr::AtomicOrdering ordering,
412 std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout,
413 function_ref<InFlightDiagnostic()> emitError) const {
414 if (emitError)
415 emitError() << "memory space is read-only";
416 return false;
417}
418
419bool TestConstMemorySpaceAttr::isValidAtomicOp(
420 mlir::ptr::AtomicBinOp binOp, Type type, mlir::ptr::AtomicOrdering ordering,
421 std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout,
422 function_ref<InFlightDiagnostic()> emitError) const {
423 if (emitError)
424 emitError() << "memory space is read-only";
425 return false;
426}
427
428bool TestConstMemorySpaceAttr::isValidAtomicXchg(
429 Type type, mlir::ptr::AtomicOrdering successOrdering,
430 mlir::ptr::AtomicOrdering failureOrdering, std::optional<int64_t> alignment,
431 const ::mlir::DataLayout *dataLayout,
432 function_ref<InFlightDiagnostic()> emitError) const {
433 if (emitError)
434 emitError() << "memory space is read-only";
435 return false;
436}
437
438bool TestConstMemorySpaceAttr::isValidAddrSpaceCast(
439 Type tgt, Type src, function_ref<InFlightDiagnostic()> emitError) const {
440 if (emitError)
441 emitError() << "memory space doesn't allow addrspace casts";
442 return false;
443}
444
445bool TestConstMemorySpaceAttr::isValidPtrIntCast(
446 Type intLikeTy, Type ptrLikeTy,
447 function_ref<InFlightDiagnostic()> emitError) const {
448 if (emitError)
449 emitError() << "memory space doesn't allow int-ptr casts";
450 return false;
451}
452
453//===----------------------------------------------------------------------===//
454// TestAttrNewlineAndIndent
455//===----------------------------------------------------------------------===//
456
457Attribute TestAttrNewlineAndIndentAttr::parse(::mlir::AsmParser &parser,
458 ::mlir::Type type) {
459 Type indentType;
460 if (parser.parseLess() || parser.parseType(indentType) ||
461 parser.parseGreater()) {
462 return Attribute();
463 }
464 return get(parser.getContext(), indentType);
465}
466
467void TestAttrNewlineAndIndentAttr::print(::mlir::AsmPrinter &printer) const {
468 printer << "<";
469 printer.increaseIndent();
470 printer.printNewline();
471 printer << getIndentType();
472 printer.decreaseIndent();
473 printer.printNewline();
474 printer << ">";
475}
476
477//===----------------------------------------------------------------------===//
478// Tablegen Generated Definitions
479//===----------------------------------------------------------------------===//
480
481#include "TestAttrInterfaces.cpp.inc"
482#include "TestOpEnums.cpp.inc"
483#define GET_ATTRDEF_CLASSES
484#include "TestAttrDefs.cpp.inc"
485
486//===----------------------------------------------------------------------===//
487// Dynamic Attributes
488//===----------------------------------------------------------------------===//
489
490/// Define a singleton dynamic attribute.
491static std::unique_ptr<DynamicAttrDefinition>
492getDynamicSingletonAttr(TestDialect *testDialect) {
493 return DynamicAttrDefinition::get(
494 "dynamic_singleton", testDialect,
495 [](function_ref<InFlightDiagnostic()> emitError,
496 ArrayRef<Attribute> args) {
497 if (!args.empty()) {
498 emitError() << "expected 0 attribute arguments, but had "
499 << args.size();
500 return failure();
501 }
502 return success();
503 });
504}
505
506/// Define a dynamic attribute representing a pair or attributes.
507static std::unique_ptr<DynamicAttrDefinition>
508getDynamicPairAttr(TestDialect *testDialect) {
509 return DynamicAttrDefinition::get(
510 "dynamic_pair", testDialect,
511 [](function_ref<InFlightDiagnostic()> emitError,
512 ArrayRef<Attribute> args) {
513 if (args.size() != 2) {
514 emitError() << "expected 2 attribute arguments, but had "
515 << args.size();
516 return failure();
517 }
518 return success();
519 });
520}
521
522static std::unique_ptr<DynamicAttrDefinition>
523getDynamicCustomAssemblyFormatAttr(TestDialect *testDialect) {
524 auto verifier = [](function_ref<InFlightDiagnostic()> emitError,
525 ArrayRef<Attribute> args) {
526 if (args.size() != 2) {
527 emitError() << "expected 2 attribute arguments, but had " << args.size();
528 return failure();
529 }
530 return success();
531 };
532
533 auto parser = [](AsmParser &parser,
534 llvm::SmallVectorImpl<Attribute> &parsedParams) {
535 Attribute leftAttr, rightAttr;
536 if (parser.parseLess() || parser.parseAttribute(result&: leftAttr) ||
537 parser.parseColon() || parser.parseAttribute(result&: rightAttr) ||
538 parser.parseGreater())
539 return failure();
540 parsedParams.push_back(Elt: leftAttr);
541 parsedParams.push_back(Elt: rightAttr);
542 return success();
543 };
544
545 auto printer = [](AsmPrinter &printer, ArrayRef<Attribute> params) {
546 printer << "<" << params[0] << ":" << params[1] << ">";
547 };
548
549 return DynamicAttrDefinition::get("dynamic_custom_assembly_format",
550 testDialect, std::move(verifier),
551 std::move(parser), std::move(printer));
552}
553
554//===----------------------------------------------------------------------===//
555// SlashAttr
556//===----------------------------------------------------------------------===//
557
558Attribute SlashAttr::parse(AsmParser &parser, Type type) {
559 int lhs, rhs;
560
561 if (parser.parseLess() || parser.parseInteger(lhs) || parser.parseSlash() ||
562 parser.parseInteger(rhs) || parser.parseGreater())
563 return Attribute();
564
565 return SlashAttr::get(parser.getContext(), lhs, rhs);
566}
567
568void SlashAttr::print(AsmPrinter &printer) const {
569 printer << "<" << getLhs() << " / " << getRhs() << ">";
570}
571
572//===----------------------------------------------------------------------===//
573// TestCustomStorageCtorAttr
574//===----------------------------------------------------------------------===//
575
576test::detail::TestCustomStorageCtorAttrAttrStorage *
577test::detail::TestCustomStorageCtorAttrAttrStorage::construct(
578 mlir::StorageUniquer::StorageAllocator &, std::tuple<int> &&) {
579 // Note: this tests linker error ("undefined symbol"), the actual
580 // implementation is not important.
581 return nullptr;
582}
583
584//===----------------------------------------------------------------------===//
585// TestTensorEncodingAttr
586//===----------------------------------------------------------------------===//
587
588::llvm::LogicalResult TestTensorEncodingAttr::verifyEncoding(
589 mlir::ArrayRef<int64_t> shape, mlir::Type elementType,
590 llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const {
591 return mlir::success();
592}
593
594//===----------------------------------------------------------------------===//
595// TestMemRefLayoutAttr
596//===----------------------------------------------------------------------===//
597
598mlir::AffineMap TestMemRefLayoutAttr::getAffineMap() const {
599 return mlir::AffineMap::getMultiDimIdentityMap(1, getContext());
600}
601
602//===----------------------------------------------------------------------===//
603// TestDialect
604//===----------------------------------------------------------------------===//
605
606void TestDialect::registerAttributes() {
607 addAttributes<
608#define GET_ATTRDEF_LIST
609#include "TestAttrDefs.cpp.inc"
610 >();
611 registerDynamicAttr(getDynamicSingletonAttr(this));
612 registerDynamicAttr(getDynamicPairAttr(this));
613 registerDynamicAttr(getDynamicCustomAssemblyFormatAttr(this));
614}
615