clang 24.0.0git
CIRAttrs.cpp
Go to the documentation of this file.
1//===- CIRAttrs.cpp - MLIR CIR Attributes ---------------------------------===//
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 defines the attributes in the CIR dialect.
10//
11//===----------------------------------------------------------------------===//
12
13#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h"
15
16#include "mlir/IR/Attributes.h"
17#include "mlir/IR/DialectImplementation.h"
18#include "llvm/Support/MathExtras.h"
19
20//===-----------------------------------------------------------------===//
21// RecordMembers
22//===-----------------------------------------------------------------===//
23
24static void printRecordMembers(mlir::AsmPrinter &p, mlir::ArrayAttr members);
25static mlir::ParseResult parseRecordMembers(mlir::AsmParser &parser,
26 mlir::ArrayAttr &members);
27
28//===-----------------------------------------------------------------===//
29// IntLiteral
30//===-----------------------------------------------------------------===//
31
32static void printIntLiteral(mlir::AsmPrinter &p, llvm::APInt value,
33 cir::IntTypeInterface ty);
34static mlir::ParseResult parseIntLiteral(mlir::AsmParser &parser,
35 llvm::APInt &value,
36 cir::IntTypeInterface ty);
37//===-----------------------------------------------------------------===//
38// FloatLiteral
39//===-----------------------------------------------------------------===//
40
41static void printFloatLiteral(mlir::AsmPrinter &p, llvm::APFloat value,
42 mlir::Type ty);
43static mlir::ParseResult
44parseFloatLiteral(mlir::AsmParser &parser,
45 mlir::FailureOr<llvm::APFloat> &value,
46 cir::FPTypeInterface fpType);
47
48static mlir::ParseResult parseConstPtr(mlir::AsmParser &parser,
49 mlir::IntegerAttr &value);
50
51static void printConstPtr(mlir::AsmPrinter &p, mlir::IntegerAttr value);
52
53static mlir::ParseResult
54parseDataMemberPath(mlir::AsmParser &parser,
55 mlir::DenseI32ArrayAttr &memberPath);
56
57static void printDataMemberPath(mlir::AsmPrinter &p,
58 mlir::DenseI32ArrayAttr memberPath);
59
60#define GET_ATTRDEF_CLASSES
61#include "clang/CIR/Dialect/IR/CIROpsAttributes.cpp.inc"
62
63using namespace mlir;
64using namespace cir;
65
66//===----------------------------------------------------------------------===//
67// MemorySpaceAttrInterface implementations for Lang and Target address space
68// attributes
69//===----------------------------------------------------------------------===//
70
71bool LangAddressSpaceAttr::isValidLoad(
72 mlir::Type type, mlir::ptr::AtomicOrdering ordering,
73 std::optional<int64_t> alignment, const mlir::DataLayout *dataLayout,
74 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
75 llvm_unreachable("isValidLoad for LangAddressSpaceAttr NYI");
76}
77
78bool LangAddressSpaceAttr::isValidStore(
79 mlir::Type type, mlir::ptr::AtomicOrdering ordering,
80 std::optional<int64_t> alignment, const mlir::DataLayout *dataLayout,
81 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
82 llvm_unreachable("isValidStore for LangAddressSpaceAttr NYI");
83}
84
85bool LangAddressSpaceAttr::isValidAtomicOp(
86 mlir::ptr::AtomicBinOp op, mlir::Type type,
87 mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment,
88 const mlir::DataLayout *dataLayout,
89 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
90 llvm_unreachable("isValidAtomicOp for LangAddressSpaceAttr NYI");
91}
92
93bool LangAddressSpaceAttr::isValidAtomicXchg(
94 mlir::Type type, mlir::ptr::AtomicOrdering successOrdering,
95 mlir::ptr::AtomicOrdering failureOrdering, std::optional<int64_t> alignment,
96 const mlir::DataLayout *dataLayout,
97 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
98 llvm_unreachable("isValidAtomicXchg for LangAddressSpaceAttr NYI");
99}
100
101bool LangAddressSpaceAttr::isValidAddrSpaceCast(
102 mlir::Type tgt, mlir::Type src,
103 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
104 llvm_unreachable("isValidAddrSpaceCast for LangAddressSpaceAttr NYI");
105}
106
107bool LangAddressSpaceAttr::isValidPtrIntCast(
108 mlir::Type intLikeTy, mlir::Type ptrLikeTy,
109 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
110 llvm_unreachable("isValidPtrIntCast for LangAddressSpaceAttr NYI");
111}
112
113bool TargetAddressSpaceAttr::isValidLoad(
114 mlir::Type type, mlir::ptr::AtomicOrdering ordering,
115 std::optional<int64_t> alignment, const mlir::DataLayout *dataLayout,
116 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
117 llvm_unreachable("isValidLoad for TargetAddressSpaceAttr NYI");
118}
119
120bool TargetAddressSpaceAttr::isValidStore(
121 mlir::Type type, mlir::ptr::AtomicOrdering ordering,
122 std::optional<int64_t> alignment, const mlir::DataLayout *dataLayout,
123 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
124 llvm_unreachable("isValidStore for TargetAddressSpaceAttr NYI");
125}
126
127bool TargetAddressSpaceAttr::isValidAtomicOp(
128 mlir::ptr::AtomicBinOp op, mlir::Type type,
129 mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment,
130 const mlir::DataLayout *dataLayout,
131 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
132 llvm_unreachable("isValidAtomicOp for TargetAddressSpaceAttr NYI");
133}
134
135bool TargetAddressSpaceAttr::isValidAtomicXchg(
136 mlir::Type type, mlir::ptr::AtomicOrdering successOrdering,
137 mlir::ptr::AtomicOrdering failureOrdering, std::optional<int64_t> alignment,
138 const mlir::DataLayout *dataLayout,
139 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
140 llvm_unreachable("isValidAtomicXchg for TargetAddressSpaceAttr NYI");
141}
142
143bool TargetAddressSpaceAttr::isValidAddrSpaceCast(
144 mlir::Type tgt, mlir::Type src,
145 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
146 llvm_unreachable("isValidAddrSpaceCast for TargetAddressSpaceAttr NYI");
147}
148
149bool TargetAddressSpaceAttr::isValidPtrIntCast(
150 mlir::Type intLikeTy, mlir::Type ptrLikeTy,
151 llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const {
152 llvm_unreachable("isValidPtrIntCast for TargetAddressSpaceAttr NYI");
153}
154
155//===----------------------------------------------------------------------===//
156// PtrSpecAttr definitions
157//===----------------------------------------------------------------------===//
158
159LogicalResult PtrSpecAttr::verify(function_ref<InFlightDiagnostic()> emitError,
160 uint32_t size, uint32_t abi,
161 uint32_t preferred, uint32_t index) {
162 constexpr unsigned kBitsInByte = 8;
163 if (size % kBitsInByte != 0)
164 return emitError() << "size entry must be divisible by 8";
165 if (abi % kBitsInByte != 0)
166 return emitError() << "abi entry must be divisible by 8";
167 if (preferred % kBitsInByte != 0)
168 return emitError() << "preferred entry must be divisible by 8";
169 if (index != kOptionalSpecValue && index % kBitsInByte != 0)
170 return emitError() << "index entry must be divisible by 8";
171 if (abi > preferred)
172 return emitError() << "preferred alignment is expected to be at least "
173 "as large as ABI alignment";
174 return success();
175}
176
177//===----------------------------------------------------------------------===//
178// BitIntSpecAttr definitions
179//===----------------------------------------------------------------------===//
180
181LogicalResult
182BitIntSpecAttr::verify(function_ref<InFlightDiagnostic()> emitError,
183 uint32_t maxAlign) {
184 // TargetInfo::getBitIntMaxAlign() is a power of two, at least the char
185 // width. Char width is 8 bits.
186 if (maxAlign < 8 || !llvm::isPowerOf2_32(maxAlign))
187 return emitError() << "max_align must be a power of two of at least 8";
188 return success();
189}
190
191//===----------------------------------------------------------------------===//
192// VectorSpecAttr definitions
193//===----------------------------------------------------------------------===//
194
195LogicalResult
196VectorSpecAttr::verify(function_ref<InFlightDiagnostic()> emitError,
197 uint32_t maxAlign) {
198 // TargetInfo::getMaxVectorAlign() is a power of two, at least the char
199 // width, when the target imposes a cap. Char width is 8 bits.
200 if (maxAlign < 8 || !llvm::isPowerOf2_32(maxAlign))
201 return emitError() << "max_align must be a power of two of at least 8";
202 return success();
203}
204
205//===----------------------------------------------------------------------===//
206// BitFieldDeclAttr definitions
207//===----------------------------------------------------------------------===//
208
209LogicalResult
210BitFieldDeclAttr::verify(function_ref<InFlightDiagnostic()> emitError,
211 mlir::Type declaredType, uint64_t width,
212 bool isUnnamed) {
213 if (width == 0 && !isUnnamed)
214 return emitError() << "zero-width bit-field cannot be named";
215 return success();
216}
217
218//===----------------------------------------------------------------------===//
219// General CIR parsing / printing
220//===----------------------------------------------------------------------===//
221
222static void printRecordMembers(mlir::AsmPrinter &printer,
223 mlir::ArrayAttr members) {
224 printer << '{';
225 llvm::interleaveComma(members, printer);
226 printer << '}';
227}
228
229static ParseResult parseRecordMembers(mlir::AsmParser &parser,
230 mlir::ArrayAttr &members) {
232
233 auto delimiter = AsmParser::Delimiter::Braces;
234 auto result = parser.parseCommaSeparatedList(delimiter, [&]() {
235 mlir::TypedAttr attr;
236 if (parser.parseAttribute(attr).failed())
237 return mlir::failure();
238 elts.push_back(attr);
239 return mlir::success();
240 });
241
242 if (result.failed())
243 return mlir::failure();
244
245 members = mlir::ArrayAttr::get(parser.getContext(), elts);
246 return mlir::success();
247}
248
249//===----------------------------------------------------------------------===//
250// ConstRecordAttr definitions
251//===----------------------------------------------------------------------===//
252
253static bool isValidFlexibleArrayInit(mlir::Type memberType,
254 mlir::Type initType) {
255 auto memberArrayType = mlir::dyn_cast<cir::ArrayType>(memberType);
256 auto initArrayType = mlir::dyn_cast<cir::ArrayType>(initType);
257 return memberArrayType && memberArrayType.getSize() == 0 && initArrayType &&
258 memberArrayType.getElementType() == initArrayType.getElementType();
259}
260
261LogicalResult
262ConstRecordAttr::verify(function_ref<InFlightDiagnostic()> emitError,
263 mlir::Type type, ArrayAttr members) {
264 auto sTy = mlir::dyn_cast_if_present<cir::RecordType>(type);
265 if (!sTy)
266 return emitError() << "expected !cir.struct or !cir.union type";
267
268 // union record initializer is just a single element that has to match one of
269 // the fields in the union (the new active member).
270 if (sTy.isUnion()) {
271 if (members.size() != 1)
272 return emitError() << "union constant must have exactly one element, got "
273 << members.size();
274 auto m = mlir::cast<mlir::TypedAttr>(members[0]);
275 // A bit-field variant is initialized as the access unit it owns.
276 if (!llvm::any_of(sTy.getMembers(), [&](mlir::Type memberTy) {
277 mlir::Type storageType = cir::memberStorageType(memberTy);
278 return storageType == m.getType() ||
279 isValidFlexibleArrayInit(storageType, m.getType());
280 }))
281 return emitError() << "union element type " << m.getType()
282 << " is not a member of " << sTy;
283 return success();
284 }
285
286 // A member that owns no bytes is not stored, so it takes no element. A
287 // bit-field's bits are packed into the element of the member that owns its
288 // access unit, and a zero-width bit-field has no bits to store at all.
289 llvm::SmallVector<mlir::Type> storedMembers;
290 for (mlir::Type memberTy : sTy.getMembers())
291 if (cir::memberOwnsBytes(memberTy))
292 storedMembers.push_back(cir::memberStorageType(memberTy));
293
294 if (storedMembers.size() != members.size())
295 return emitError() << "number of elements must match";
296
297 for (const auto &[attrIdx, member] : llvm::enumerate(storedMembers)) {
298 auto m = mlir::cast<mlir::TypedAttr>(members[attrIdx]);
299
300 // As a special case, we allow a flexible array member. This can only be the
301 // last element, the rest of the array type has to match (that is, the
302 // element type has to match), and the array member must be size zero.
303 if (attrIdx == storedMembers.size() - 1) {
304 auto memArrayTy = dyn_cast<cir::ArrayType>(member);
305 if (memArrayTy && memArrayTy.getSize() == 0) {
306
307 // The FAM must only match another array type initializer.
308 if (!isa<cir::ArrayType>(m.getType()))
309 return emitError()
310 << "element at index " << attrIdx << " has type "
311 << m.getType() << " but the expected type for this element is "
312 << member;
313
314 cir::ArrayType initArrayTy = cast<cir::ArrayType>(m.getType());
315 // The FAM only matches an equivalent array type.
316 if (initArrayTy.getElementType() != memArrayTy.getElementType())
317 return emitError()
318 << "flexible array member at index " << attrIdx << " has type "
319 << m.getType()
320 << " which doesn't match the expected element type of member "
321 << member;
322 continue;
323 }
324 }
325
326 if (member != m.getType())
327 return emitError() << "element at index " << attrIdx << " has type "
328 << m.getType()
329 << " but the expected type for this element is "
330 << member;
331 }
332
333 return success();
334}
335
336//===----------------------------------------------------------------------===//
337// OptInfoAttr definitions
338//===----------------------------------------------------------------------===//
339
340LogicalResult OptInfoAttr::verify(function_ref<InFlightDiagnostic()> emitError,
341 unsigned level, unsigned size) {
342 if (level > 3)
343 return emitError()
344 << "optimization level must be between 0 and 3 inclusive";
345 if (size > 2)
346 return emitError()
347 << "size optimization level must be between 0 and 2 inclusive";
348 return success();
349}
350
351//===----------------------------------------------------------------------===//
352// ConstPtrAttr definitions
353//===----------------------------------------------------------------------===//
354
355// TODO(CIR): Consider encoding the null value differently and use conditional
356// assembly format instead of custom parsing/printing.
357static ParseResult parseConstPtr(AsmParser &parser, mlir::IntegerAttr &value) {
358
359 if (parser.parseOptionalKeyword("null").succeeded()) {
360 value = parser.getBuilder().getI64IntegerAttr(0);
361 return success();
362 }
363
364 return parser.parseAttribute(value);
365}
366
367static void printConstPtr(AsmPrinter &p, mlir::IntegerAttr value) {
368 if (!value.getInt())
369 p << "null";
370 else
371 p << value;
372}
373
374static ParseResult parseDataMemberPath(AsmParser &parser,
375 mlir::DenseI32ArrayAttr &memberPath) {
376 if (parser.parseOptionalKeyword("null").succeeded())
377 return success();
378
379 auto parsed = mlir::FieldParser<mlir::DenseI32ArrayAttr>::parse(parser);
380 if (mlir::failed(parsed))
381 return failure();
382 memberPath = *parsed;
383 return success();
384}
385
386static void printDataMemberPath(AsmPrinter &p,
387 mlir::DenseI32ArrayAttr memberPath) {
388 if (!memberPath)
389 p << "null";
390 else
391 p.printStrippedAttrOrType(memberPath);
392}
393
394//===----------------------------------------------------------------------===//
395// IntAttr definitions
396//===----------------------------------------------------------------------===//
397
398mlir::ParseResult parseIntLiteral(mlir::AsmParser &parser, llvm::APInt &value,
399 cir::IntTypeInterface ty) {
400 llvm::SMLoc loc = parser.getCurrentLocation();
401 llvm::APInt parsed;
402 mlir::OptionalParseResult result = parser.parseOptionalInteger(parsed);
403 if (!result.has_value() || failed(*result))
404 return parser.emitError(loc, "expected integer value");
405
406 const unsigned width = ty.getWidth();
407 const bool fits =
408 ty.isSigned() ? parsed.getSignificantBits() <= width
409 : !parsed.isNegative() && parsed.getActiveBits() <= width;
410 if (!fits)
411 return parser.emitError(loc, "integer value too large for the given type");
412
413 value = ty.isSigned() ? parsed.sextOrTrunc(width) : parsed.zextOrTrunc(width);
414 return success();
415}
416
417void printIntLiteral(mlir::AsmPrinter &p, llvm::APInt value,
418 cir::IntTypeInterface ty) {
420 value.toString(str, /*radix=*/10, /*isSigned=*/ty.isSigned());
421 p << str;
422}
423
424LogicalResult IntAttr::verify(function_ref<InFlightDiagnostic()> emitError,
425 cir::IntTypeInterface type, llvm::APInt value) {
426 if (value.getBitWidth() != type.getWidth())
427 return emitError() << "type and value bitwidth mismatch: "
428 << type.getWidth() << " != " << value.getBitWidth();
429 return success();
430}
431
432//===----------------------------------------------------------------------===//
433// FPAttr definitions
434//===----------------------------------------------------------------------===//
435
436static void printFloatLiteral(AsmPrinter &p, APFloat value, Type ty) {
437 p << value;
438}
439
440static ParseResult parseFloatLiteral(AsmParser &parser,
441 FailureOr<APFloat> &value,
442 cir::FPTypeInterface fpType) {
443
444 APFloat parsedValue(0.0);
445 if (parser.parseFloat(fpType.getFloatSemantics(), parsedValue))
446 return failure();
447
448 value.emplace(parsedValue);
449 return success();
450}
451
452//===----------------------------------------------------------------------===//
453// MemoryEffectsAttr definitions
454//===----------------------------------------------------------------------===//
455
456MemoryEffectsAttr MemoryEffectsAttr::none(MLIRContext *ctx) {
457 return get(ctx, ModRefInfo::NoModRef);
458}
459
460MemoryEffectsAttr MemoryEffectsAttr::readOnly(MLIRContext *ctx) {
461 return get(ctx, ModRefInfo::Ref);
462}
463
464MemoryEffectsAttr MemoryEffectsAttr::writeOnly(MLIRContext *ctx) {
465 return get(ctx, ModRefInfo::Mod);
466}
467
468MemoryEffectsAttr MemoryEffectsAttr::argMemOnly(MLIRContext *ctx,
469 ModRefInfo mr) {
470 return get(ctx, /*other=*/ModRefInfo::NoModRef, /*arg_mem=*/mr,
471 /*inaccessible_mem=*/ModRefInfo::NoModRef,
472 /*errno_mem=*/ModRefInfo::NoModRef,
473 /*target_mem0=*/ModRefInfo::NoModRef,
474 /*target_mem1=*/ModRefInfo::NoModRef);
475}
476
477MemoryEffectsAttr MemoryEffectsAttr::inaccessibleMemOnly(MLIRContext *ctx,
478 ModRefInfo mr) {
479 return get(ctx, /*other=*/ModRefInfo::NoModRef,
480 /*arg_mem=*/ModRefInfo::NoModRef, /*inaccessible_mem=*/mr,
481 /*errno_mem=*/ModRefInfo::NoModRef,
482 /*target_mem0=*/ModRefInfo::NoModRef,
483 /*target_mem1=*/ModRefInfo::NoModRef);
484}
485
486MemoryEffectsAttr MemoryEffectsAttr::errnoMemOnly(MLIRContext *ctx,
487 ModRefInfo mr) {
488 return get(ctx, /*other=*/ModRefInfo::NoModRef,
489 /*arg_mem=*/ModRefInfo::NoModRef,
490 /*inaccessible_mem=*/ModRefInfo::NoModRef, /*errno_mem=*/mr,
491 /*target_mem0=*/ModRefInfo::NoModRef,
492 /*target_mem1=*/ModRefInfo::NoModRef);
493}
494
495MemoryEffectsAttr MemoryEffectsAttr::otherMemOnly(MLIRContext *ctx,
496 ModRefInfo mr) {
497 return get(ctx, /*other=*/mr, /*arg_mem=*/ModRefInfo::NoModRef,
498 /*inaccessible_mem=*/ModRefInfo::NoModRef,
499 /*errno_mem=*/ModRefInfo::NoModRef,
500 /*target_mem0=*/ModRefInfo::NoModRef,
501 /*target_mem1=*/ModRefInfo::NoModRef);
502}
503
504MemoryEffectsAttr MemoryEffectsAttr::inaccessibleOrArgMemOnly(MLIRContext *ctx,
505 ModRefInfo mr) {
506 return get(ctx, /*other=*/ModRefInfo::NoModRef, /*arg_mem=*/mr,
507 /*inaccessible_mem=*/mr, /*errno_mem=*/ModRefInfo::NoModRef,
508 /*target_mem0=*/ModRefInfo::NoModRef,
509 /*target_mem1=*/ModRefInfo::NoModRef);
510}
511
512MemoryEffectsAttr MemoryEffectsAttr::inaccessibleOrErrnoMemOnly(
513 MLIRContext *ctx, ModRefInfo inaccessibleMr, ModRefInfo errnoMr) {
514 return get(ctx, /*other=*/ModRefInfo::NoModRef,
515 /*arg_mem=*/ModRefInfo::NoModRef,
516 /*inaccessible_mem=*/inaccessibleMr, /*errno_mem=*/errnoMr,
517 /*target_mem0=*/ModRefInfo::NoModRef,
518 /*target_mem1=*/ModRefInfo::NoModRef);
519}
520
521MemoryEffectsAttr MemoryEffectsAttr::inaccessibleOrArgOrErrnoMemOnly(
522 MLIRContext *ctx, ModRefInfo inaccessibleOrArgMr, ModRefInfo errnoMr) {
523 return get(ctx, /*other=*/ModRefInfo::NoModRef,
524 /*arg_mem=*/inaccessibleOrArgMr,
525 /*inaccessible_mem=*/inaccessibleOrArgMr, /*errno_mem=*/errnoMr,
526 /*target_mem0=*/ModRefInfo::NoModRef,
527 /*target_mem1=*/ModRefInfo::NoModRef);
528}
529
530MemoryEffectsAttr
531MemoryEffectsAttr::argumentOrErrnoMemOnly(MLIRContext *ctx, ModRefInfo argMr,
532 ModRefInfo errnoMr) {
533 return get(ctx, /*other=*/ModRefInfo::NoModRef, /*arg_mem=*/argMr,
534 /*inaccessible_mem=*/ModRefInfo::NoModRef, /*errno_mem=*/errnoMr,
535 /*target_mem0=*/ModRefInfo::NoModRef,
536 /*target_mem1=*/ModRefInfo::NoModRef);
537}
538
539FPAttr FPAttr::getZero(Type type) {
540 return get(type,
541 APFloat::getZero(
542 mlir::cast<cir::FPTypeInterface>(type).getFloatSemantics()));
543}
544
545LogicalResult FPAttr::verify(function_ref<InFlightDiagnostic()> emitError,
546 cir::FPTypeInterface fpType, APFloat value) {
547 if (APFloat::SemanticsToEnum(fpType.getFloatSemantics()) !=
548 APFloat::SemanticsToEnum(value.getSemantics()))
549 return emitError() << "floating-point semantics mismatch";
550
551 return success();
552}
553
554//===----------------------------------------------------------------------===//
555// CmpThreeWayInfoAttr definitions
556//===----------------------------------------------------------------------===//
557
558std::string CmpThreeWayInfoAttr::getAlias() const {
559 std::string alias = "cmpinfo";
560
561 switch (getOrdering()) {
562 case CmpOrdering::Strong:
563 alias.append("_strong_");
564 break;
565 case CmpOrdering::Weak:
566 alias.append("_weak_");
567 break;
568 case CmpOrdering::Partial:
569 alias.append("_partial_");
570 break;
571 }
572
573 auto appendInt = [&](int64_t value) {
574 if (value < 0) {
575 alias.push_back('n');
576 value = -value;
577 }
578 alias.append(std::to_string(value));
579 };
580
581 alias.append("lt");
582 appendInt(getLt());
583 alias.append("eq");
584 appendInt(getEq());
585 alias.append("gt");
586 appendInt(getGt());
587
588 if (std::optional<int> unordered = getUnordered()) {
589 alias.append("un");
590 appendInt(unordered.value());
591 }
592
593 return alias;
594}
595
596LogicalResult
597CmpThreeWayInfoAttr::verify(function_ref<InFlightDiagnostic()> emitError,
598 CmpOrdering ordering, int64_t lt, int64_t eq,
599 int64_t gt, std::optional<int64_t> unordered) {
600 // The presence of unordered must match the value of ordering.
601 if ((ordering == CmpOrdering::Strong || ordering == CmpOrdering::Weak) &&
602 unordered) {
603 emitError() << "strong and weak ordering do not include unordered";
604 return failure();
605 }
606 if (ordering == CmpOrdering::Partial && !unordered) {
607 emitError() << "partial ordering requires unordered value";
608 return failure();
609 }
610
611 return success();
612}
613
614//===----------------------------------------------------------------------===//
615// ConstComplexAttr definitions
616//===----------------------------------------------------------------------===//
617
618LogicalResult
619ConstComplexAttr::verify(function_ref<InFlightDiagnostic()> emitError,
620 cir::ComplexType type, mlir::TypedAttr real,
621 mlir::TypedAttr imag) {
622 mlir::Type elemType = type.getElementType();
623 if (real.getType() != elemType)
624 return emitError()
625 << "type of the real part does not match the complex type";
626
627 if (imag.getType() != elemType)
628 return emitError()
629 << "type of the imaginary part does not match the complex type";
630
631 return success();
632}
633
634//===----------------------------------------------------------------------===//
635// CIR_CUDAVarRegistrationInfoAttr definitions
636//===----------------------------------------------------------------------===//
637
638void CUDAVarRegistrationInfoAttr::print(AsmPrinter &p) const {
639 p << "<" << getDeviceSideName();
640 p << ", " << stringifyEnum(getKind());
641 if (getIsExtern())
642 p << ", extern";
643 if (getIsConstant())
644 p << ", constant";
645 if (getIsManaged())
646 p << ", managed";
647 if (getKind() == CUDADeviceVarKind::Surface)
648 p << ", surface_type = " << getSurfTexType();
649 else if (getKind() == CUDADeviceVarKind::Texture) {
650 p << ", texture_type = " << getSurfTexType();
651 if (getNormalized())
652 p << ", normalized";
653 }
654 p << ">";
655}
656
657Attribute CUDAVarRegistrationInfoAttr::parse(AsmParser &parser, Type odsType) {
658 if (parser.parseLess())
659 return {};
660
661 std::string deviceSideName;
662 if (parser.parseKeywordOrString(&deviceSideName)) {
663 parser.emitError(parser.getCurrentLocation(),
664 "expected device variable name");
665 return {};
666 }
667
668 if (parser.parseComma())
669 return {};
670
671 // Parse the device variable kind (Variable, Surface, Texture)
672 StringRef kindStr;
673 if (parser.parseKeyword(&kindStr))
674 return {};
675
676 std::optional<CUDADeviceVarKind> kind = symbolizeCUDADeviceVarKind(kindStr);
677 if (!kind) {
678 parser.emitError(parser.getCurrentLocation(),
679 "unknown device variable kind: ")
680 << kindStr;
681 return {};
682 }
683
684 // Parse optional flags: extern, constant, managed
685 bool isExtern = false;
686 bool isConstant = false;
687 bool isManaged = false;
688 int32_t surfTexType = 0;
689 bool normalized = false;
690
691 while (parser.parseOptionalGreater().failed()) {
692 if (parser.parseComma())
693 return {};
694
695 StringRef flag;
696 if (parser.parseKeyword(&flag))
697 return {};
698
699 if (flag == "extern")
700 isExtern = true;
701 else if (flag == "constant")
702 isConstant = true;
703 else if (flag == "managed")
704 isManaged = true;
705 else if (flag == "normalized") {
706 if (*kind != CUDADeviceVarKind::Texture) {
707 parser.emitError(parser.getCurrentLocation(),
708 "'normalized' is only valid for Texture");
709 return {};
710 }
711 normalized = true;
712 } else if (flag == "surface_type") {
713 if (*kind != CUDADeviceVarKind::Surface) {
714 parser.emitError(parser.getCurrentLocation(),
715 "'surface_type' is only valid for Surface");
716 return {};
717 }
718 if (parser.parseEqual() || parser.parseInteger(surfTexType))
719 return {};
720 } else if (flag == "texture_type") {
721 if (*kind != CUDADeviceVarKind::Texture) {
722 parser.emitError(parser.getCurrentLocation(),
723 "'texture_type' is only valid for Texture");
724 return {};
725 }
726 if (parser.parseEqual() || parser.parseInteger(surfTexType))
727 return {};
728 } else {
729 parser.emitError(parser.getCurrentLocation(), "unknown flag: ") << flag;
730 return {};
731 }
732 }
733
734 return get(parser.getContext(), deviceSideName, *kind, isExtern, isConstant,
735 isManaged, surfTexType, normalized);
736}
737
738//===----------------------------------------------------------------------===//
739// DataMemberAttr definitions
740//===----------------------------------------------------------------------===//
741
742LogicalResult
743DataMemberAttr::verify(function_ref<InFlightDiagnostic()> emitError,
744 cir::DataMemberType ty,
745 mlir::DenseI32ArrayAttr memberPath) {
746 if (!memberPath)
747 return success(); // null pointer — always valid
748
749 if (memberPath.empty())
750 return emitError() << "#cir.data_member path must not be empty";
751
752 mlir::Type currentTy = ty.getClassTy();
753 for (auto [step, idx] : llvm::enumerate(memberPath.asArrayRef())) {
754 auto recTy = mlir::dyn_cast<cir::RecordType>(currentTy);
755 if (!recTy)
756 return emitError() << "#cir.data_member path step " << step
757 << " reaches a non-record type";
758
759 if (recTy.isIncomplete())
760 return success(); // cannot validate further; trust the builder
761
762 if (idx < 0 || static_cast<unsigned>(idx) >= recTy.getNumElements())
763 return emitError() << "#cir.data_member path index " << idx << " at step "
764 << step << " is out of range";
765
766 currentTy = recTy.getMembers()[idx];
767 }
768
769 if (currentTy != ty.getMemberTy())
770 return emitError()
771 << "member type of a #cir.data_member attribute must match "
772 "the attribute type";
773
774 return success();
775}
776
777//===----------------------------------------------------------------------===//
778// MethodAttr definitions
779//===----------------------------------------------------------------------===//
780
781LogicalResult MethodAttr::verify(function_ref<InFlightDiagnostic()> emitError,
782 cir::MethodType type,
783 std::optional<FlatSymbolRefAttr> symbol,
784 std::optional<uint64_t> vtable_index) {
785 if (symbol.has_value() && vtable_index.has_value())
786 return emitError()
787 << "at most one of symbol and vtable_index can be present "
788 "in #cir.method";
789
790 return success();
791}
792
793Attribute MethodAttr::parse(AsmParser &parser, Type odsType) {
794 auto ty = mlir::cast<cir::MethodType>(odsType);
795
796 if (parser.parseLess().failed())
797 return {};
798
799 // Try to parse the null pointer constant.
800 if (parser.parseOptionalKeyword("null").succeeded()) {
801 if (parser.parseGreater().failed())
802 return {};
803 return get(ty);
804 }
805
806 // Try to parse a flat symbol ref for a pointer to non-virtual member
807 // function.
808 FlatSymbolRefAttr symbol;
809 mlir::OptionalParseResult parseSymbolRefResult =
810 parser.parseOptionalAttribute(symbol);
811 if (parseSymbolRefResult.has_value()) {
812 if (parseSymbolRefResult.value().failed())
813 return {};
814 if (parser.parseGreater().failed())
815 return {};
816 return get(ty, symbol);
817 }
818
819 // Parse a uint64 that represents the vtable index.
820 std::uint64_t vtableIndex = 0;
821 if (parser.parseKeyword("vtable_index"))
822 return {};
823 if (parser.parseEqual())
824 return {};
825 if (parser.parseInteger(vtableIndex))
826 return {};
827
828 if (parser.parseGreater())
829 return {};
830
831 return get(ty, vtableIndex);
832}
833
834void MethodAttr::print(AsmPrinter &printer) const {
835 auto symbol = getSymbol();
836 auto vtableIndex = getVtableIndex();
837
838 printer << '<';
839 if (symbol.has_value()) {
840 printer << *symbol;
841 } else if (vtableIndex.has_value()) {
842 printer << "vtable_index = " << *vtableIndex;
843 } else {
844 printer << "null";
845 }
846 printer << '>';
847}
848
849//===----------------------------------------------------------------------===//
850// CIR ConstArrayAttr
851//===----------------------------------------------------------------------===//
852
853LogicalResult
854ConstArrayAttr::verify(function_ref<InFlightDiagnostic()> emitError, Type type,
855 Attribute elts, int trailingZerosNum) {
856
857 if (!(mlir::isa<ArrayAttr, StringAttr>(elts)))
858 return emitError() << "constant array expects ArrayAttr or StringAttr";
859
860 if (auto strAttr = mlir::dyn_cast<StringAttr>(elts)) {
861 const auto arrayTy = mlir::cast<ArrayType>(type);
862 const auto intTy = mlir::dyn_cast<IntType>(arrayTy.getElementType());
863
864 // TODO: add CIR type for char.
865 if (!intTy || intTy.getWidth() != 8)
866 return emitError()
867 << "constant array element for string literals expects "
868 "!cir.int<u, 8> element type";
869 return success();
870 }
871
872 assert(mlir::isa<ArrayAttr>(elts));
873 const auto arrayAttr = mlir::cast<mlir::ArrayAttr>(elts);
874 const auto arrayTy = mlir::cast<ArrayType>(type);
875
876 // Make sure both number of elements and subelement types match type.
877 if (arrayAttr.size() > arrayTy.getSize())
878 return emitError() << "constant array has " << arrayAttr.size()
879 << " values but array type has size "
880 << arrayTy.getSize();
881 if (arrayTy.getSize() != arrayAttr.size() + trailingZerosNum)
882 return emitError() << "constant array size should match type size";
883 return success();
884}
885
886Attribute ConstArrayAttr::parse(AsmParser &parser, Type type) {
887 mlir::FailureOr<Type> resultTy;
888 mlir::FailureOr<Attribute> resultVal;
889
890 // Parse literal '<'
891 if (parser.parseLess())
892 return {};
893
894 // Parse variable 'value'
895 resultVal = FieldParser<Attribute>::parse(parser);
896 if (failed(resultVal)) {
897 parser.emitError(
898 parser.getCurrentLocation(),
899 "failed to parse ConstArrayAttr parameter 'value' which is "
900 "to be a `Attribute`");
901 return {};
902 }
903
904 // ArrayAttrrs have per-element type, not the type of the array...
905 if (mlir::isa<ArrayAttr>(*resultVal)) {
906 // Array has implicit type: infer from const array type.
907 if (parser.parseOptionalColon().failed()) {
908 resultTy = type;
909 } else { // Array has explicit type: parse it.
910 resultTy = FieldParser<Type>::parse(parser);
911 if (failed(resultTy)) {
912 parser.emitError(
913 parser.getCurrentLocation(),
914 "failed to parse ConstArrayAttr parameter 'type' which is "
915 "to be a `::mlir::Type`");
916 return {};
917 }
918 }
919 } else {
920 auto ta = mlir::cast<TypedAttr>(*resultVal);
921 resultTy = ta.getType();
922 if (mlir::isa<mlir::NoneType>(*resultTy)) {
923 parser.emitError(parser.getCurrentLocation(),
924 "expected type declaration for string literal");
925 return {};
926 }
927 }
928
929 unsigned zeros = 0;
930 if (parser.parseOptionalComma().succeeded()) {
931 if (parser.parseOptionalKeyword("trailing_zeros").succeeded()) {
932 unsigned totalSize = mlir::cast<cir::ArrayType>(type).getSize();
933 mlir::Attribute elts = resultVal.value();
934 if (auto str = mlir::dyn_cast<mlir::StringAttr>(elts))
935 zeros = totalSize - str.size();
936 else
937 zeros = totalSize - mlir::cast<mlir::ArrayAttr>(elts).size();
938 } else {
939 return {};
940 }
941 }
942
943 // Parse literal '>'
944 if (parser.parseGreater())
945 return {};
946
947 return parser.getChecked<ConstArrayAttr>(parser.getCurrentLocation(),
948 parser.getContext(), type,
949 resultVal.value(), zeros);
950}
951
952void ConstArrayAttr::print(AsmPrinter &printer) const {
953 printer << "<";
954 printer.printStrippedAttrOrType(getElts());
955 if (getTrailingZerosNum())
956 printer << ", trailing_zeros";
957 printer << ">";
958}
959
960//===----------------------------------------------------------------------===//
961// CIR ConstVectorAttr
962//===----------------------------------------------------------------------===//
963
964LogicalResult
965cir::ConstVectorAttr::verify(function_ref<InFlightDiagnostic()> emitError,
966 Type type, ArrayAttr elts) {
967
968 if (!mlir::isa<cir::VectorType>(type))
969 return emitError() << "type of cir::ConstVectorAttr is not a "
970 "cir::VectorType: "
971 << type;
972
973 const auto vecType = mlir::cast<cir::VectorType>(type);
974
975 if (vecType.isScalable())
976 return emitError() << "scalable vector constants are not supported";
977
978 if (vecType.getFixedSize() != elts.size())
979 return emitError()
980 << "number of constant elements should match vector size";
981
982 // Check if the types of the elements match
983 LogicalResult elementTypeCheck = success();
984 elts.walkImmediateSubElements(
985 [&](Attribute element) {
986 if (elementTypeCheck.failed()) {
987 // An earlier element didn't match
988 return;
989 }
990 auto typedElement = mlir::dyn_cast<TypedAttr>(element);
991 if (!typedElement ||
992 typedElement.getType() != vecType.getElementType()) {
993 elementTypeCheck = failure();
994 emitError() << "constant type should match vector element type";
995 }
996 },
997 [&](Type) {});
998
999 return elementTypeCheck;
1000}
1001
1002//===----------------------------------------------------------------------===//
1003// CIR VTableAttr
1004//===----------------------------------------------------------------------===//
1005
1006LogicalResult cir::VTableAttr::verify(
1007 llvm::function_ref<mlir::InFlightDiagnostic()> emitError, mlir::Type type,
1008 mlir::ArrayAttr data, mlir::ArrayAttr addressPoints) {
1009 auto sTy = mlir::dyn_cast_if_present<cir::RecordType>(type);
1010 if (!sTy)
1011 return emitError() << "expected !cir.struct or !cir.union type result";
1012 if (sTy.getMembers().empty() || data.empty())
1013 return emitError() << "expected record type with one or more subtype";
1014
1015 if (cir::ConstRecordAttr::verify(emitError, type, data).failed())
1016 return failure();
1017
1018 if (addressPoints.size() != data.size())
1019 return emitError() << "expected one address point for each vtable, got "
1020 << addressPoints.size() << " for " << data.size()
1021 << " vtables";
1022
1023 for (const auto &[idx, element] :
1024 llvm::enumerate(data.getAsRange<mlir::Attribute>())) {
1025 const auto &constArrayAttr = mlir::dyn_cast<cir::ConstArrayAttr>(element);
1026 if (!constArrayAttr)
1027 return emitError() << "expected constant array subtype";
1028
1029 auto arrayTy = mlir::cast<cir::ArrayType>(constArrayAttr.getType());
1030 auto addressPoint =
1031 mlir::dyn_cast<cir::AddressPointAttr>(addressPoints[idx]);
1032 if (!addressPoint)
1033 return emitError() << "expected an address point for vtable " << idx;
1034 if (addressPoint.getIndex() != static_cast<int32_t>(idx))
1035 return emitError() << "address point " << idx << " refers to vtable "
1036 << addressPoint.getIndex();
1037 if (addressPoint.getOffset() < 0 ||
1038 static_cast<uint64_t>(addressPoint.getOffset()) > arrayTy.getSize())
1039 return emitError() << "address point offset " << addressPoint.getOffset()
1040 << " is out of range of vtable " << idx;
1041
1042 LogicalResult eltTypeCheck = success();
1043 auto arrayElts = mlir::cast<ArrayAttr>(constArrayAttr.getElts());
1044 arrayElts.walkImmediateSubElements(
1045 [&](mlir::Attribute attr) {
1046 if (mlir::isa<ConstPtrAttr, GlobalViewAttr>(attr))
1047 return;
1048
1049 eltTypeCheck = emitError()
1050 << "expected GlobalViewAttr or ConstPtrAttr";
1051 },
1052 [&](mlir::Type type) {});
1053 if (eltTypeCheck.failed())
1054 return eltTypeCheck;
1055 }
1056 return success();
1057}
1058
1059//===----------------------------------------------------------------------===//
1060// DynamicCastInfoAtttr definitions
1061//===----------------------------------------------------------------------===//
1062
1063std::string DynamicCastInfoAttr::getAlias() const {
1064 // The alias looks like: `dyn_cast_info_<src>_<dest>`
1065
1066 std::string alias = "dyn_cast_info_";
1067
1068 alias.append(getSrcRtti().getSymbol().getValue());
1069 alias.push_back('_');
1070 alias.append(getDestRtti().getSymbol().getValue());
1071
1072 return alias;
1073}
1074
1075// TODO: Give type_info a distinct CIR type so we can verify that a
1076// FlatSymbolRefAttr actually names a type_info global.
1077static bool isRttiPtr(mlir::Type ty) {
1078 auto ptrTy = mlir::dyn_cast<cir::PointerType>(ty);
1079 if (!ptrTy)
1080 return false;
1081
1082 auto pointeeIntTy = mlir::dyn_cast<cir::IntType>(ptrTy.getPointee());
1083 if (!pointeeIntTy)
1084 return false;
1085
1086 return pointeeIntTy.isUnsigned() && pointeeIntTy.getWidth() == 8;
1087}
1088
1089LogicalResult DynamicCastInfoAttr::verify(
1090 function_ref<InFlightDiagnostic()> emitError, cir::GlobalViewAttr srcRtti,
1091 cir::GlobalViewAttr destRtti, mlir::FlatSymbolRefAttr runtimeFunc,
1092 mlir::FlatSymbolRefAttr badCastFunc, cir::IntAttr offsetHint) {
1093 if (!isRttiPtr(srcRtti.getType()))
1094 return emitError() << "srcRtti must be an RTTI pointer";
1095
1096 if (!isRttiPtr(destRtti.getType()))
1097 return emitError() << "destRtti must be an RTTI pointer";
1098
1099 return success();
1100}
1101
1102//===----------------------------------------------------------------------===//
1103// EhFilterAttr definitions
1104//===----------------------------------------------------------------------===//
1105
1106LogicalResult EhFilterAttr::verify(function_ref<InFlightDiagnostic()> emitError,
1107 mlir::ArrayAttr permittedTypes) {
1108 for (mlir::Attribute typeAttr : permittedTypes) {
1109 auto rtti = mlir::dyn_cast<cir::GlobalViewAttr>(typeAttr);
1110 if (!rtti || !isRttiPtr(rtti.getType()))
1111 return emitError() << "permitted type list must contain only type info "
1112 "symbols";
1113 }
1114
1115 return success();
1116}
1117
1118//===----------------------------------------------------------------------===//
1119// RecordLayoutAttr
1120//===----------------------------------------------------------------------===//
1121
1122Attribute RecordLayoutAttr::parse(AsmParser &parser, Type odsType) {
1123 (void)odsType;
1124 SMLoc loc = parser.getCurrentLocation();
1125 if (parser.parseLess() || parser.parseKeyword("arg_passing_kind") ||
1126 parser.parseEqual())
1127 return {};
1128
1129 FailureOr<ArgPassingKind> kind = FieldParser<ArgPassingKind>::parse(parser);
1130 if (failed(kind))
1131 return {};
1132
1133 if (parser.parseComma() || parser.parseKeyword("has_trivial_dtor") ||
1134 parser.parseEqual())
1135 return {};
1136 FailureOr<bool> hasTrivialDtor = FieldParser<bool>::parse(parser);
1137 if (failed(hasTrivialDtor))
1138 return {};
1139
1140 if (parser.parseComma() || parser.parseKeyword("record_align") ||
1141 parser.parseEqual())
1142 return {};
1143 FailureOr<uint64_t> recordAlign = FieldParser<uint64_t>::parse(parser);
1144 if (failed(recordAlign))
1145 return {};
1146
1147 // An omitted unadjusted_align stores the record alignment. The optional
1148 // fields may follow record_align in any order.
1149 uint64_t unadjustedAlign = *recordAlign;
1150 bool transparentUnion = false;
1151 bool flexibleArrayMember = false;
1152 while (succeeded(parser.parseOptionalComma())) {
1153 if (succeeded(parser.parseOptionalKeyword("unadjusted_align"))) {
1154 if (parser.parseEqual())
1155 return {};
1156 FailureOr<uint64_t> parsed = FieldParser<uint64_t>::parse(parser);
1157 if (failed(parsed))
1158 return {};
1159 unadjustedAlign = *parsed;
1160 continue;
1161 }
1162 if (succeeded(parser.parseOptionalKeyword("transparent_union"))) {
1163 if (parser.parseEqual())
1164 return {};
1165 FailureOr<bool> parsed = FieldParser<bool>::parse(parser);
1166 if (failed(parsed))
1167 return {};
1168 transparentUnion = *parsed;
1169 continue;
1170 }
1171 if (succeeded(parser.parseOptionalKeyword("flexible_array_member"))) {
1172 if (parser.parseEqual())
1173 return {};
1174 FailureOr<bool> parsed = FieldParser<bool>::parse(parser);
1175 if (failed(parsed))
1176 return {};
1177 flexibleArrayMember = *parsed;
1178 continue;
1179 }
1180 parser.emitError(parser.getCurrentLocation(),
1181 "expected unadjusted_align, transparent_union or "
1182 "flexible_array_member");
1183 return {};
1184 }
1185
1186 if (parser.parseGreater())
1187 return {};
1188 return parser.getChecked<RecordLayoutAttr>(
1189 loc, parser.getContext(), *kind, *hasTrivialDtor, *recordAlign,
1190 unadjustedAlign, transparentUnion, flexibleArrayMember);
1191}
1192
1193void RecordLayoutAttr::print(AsmPrinter &printer) const {
1194 printer << "<arg_passing_kind = ";
1195 printer.printStrippedAttrOrType(getArgPassingKind());
1196 printer << ", has_trivial_dtor = ";
1197 printer.printStrippedAttrOrType(getHasTrivialDtor());
1198 printer << ", record_align = ";
1199 printer.printStrippedAttrOrType(getRecordAlign());
1200 // Print unadjusted_align only when it differs from record_align.
1201 if (getUnadjustedAlign() != getRecordAlign()) {
1202 printer << ", unadjusted_align = ";
1203 printer.printStrippedAttrOrType(getUnadjustedAlign());
1204 }
1205 if (getTransparentUnion()) {
1206 printer << ", transparent_union = ";
1207 printer.printStrippedAttrOrType(getTransparentUnion());
1208 }
1209 if (getFlexibleArrayMember()) {
1210 printer << ", flexible_array_member = ";
1211 printer.printStrippedAttrOrType(getFlexibleArrayMember());
1212 }
1213 printer << '>';
1214}
1215
1216//===----------------------------------------------------------------------===//
1217// RecordLayout lookup
1218//===----------------------------------------------------------------------===//
1219
1220RecordLayoutAttr cir::tryGetRecordLayout(mlir::ModuleOp mod,
1221 mlir::StringAttr name) {
1222 if (!name)
1223 return {};
1224 auto dict = mod->getAttrOfType<mlir::DictionaryAttr>(
1225 CIRDialect::getRecordLayoutsAttrName());
1226 if (!dict)
1227 return {};
1228 return dict.getAs<RecordLayoutAttr>(name);
1229}
1230
1231RecordLayoutAttr cir::getRecordLayout(mlir::ModuleOp mod,
1232 mlir::StringAttr name) {
1233 RecordLayoutAttr attr = tryGetRecordLayout(mod, name);
1234 assert(attr && "record layout entry missing for named record");
1235 return attr;
1236}
1237
1238//===----------------------------------------------------------------------===//
1239// CIR Dialect
1240//===----------------------------------------------------------------------===//
1241
1242void CIRDialect::registerAttributes() {
1243 addAttributes<
1244#define GET_ATTRDEF_LIST
1245#include "clang/CIR/Dialect/IR/CIROpsAttributes.cpp.inc"
1246 >();
1247}
static mlir::ParseResult parseFloatLiteral(mlir::AsmParser &parser, mlir::FailureOr< llvm::APFloat > &value, cir::FPTypeInterface fpType)
static void printConstPtr(mlir::AsmPrinter &p, mlir::IntegerAttr value)
static void printRecordMembers(mlir::AsmPrinter &p, mlir::ArrayAttr members)
Definition CIRAttrs.cpp:222
static mlir::ParseResult parseIntLiteral(mlir::AsmParser &parser, llvm::APInt &value, cir::IntTypeInterface ty)
Definition CIRAttrs.cpp:398
static void printIntLiteral(mlir::AsmPrinter &p, llvm::APInt value, cir::IntTypeInterface ty)
Definition CIRAttrs.cpp:417
static mlir::ParseResult parseConstPtr(mlir::AsmParser &parser, mlir::IntegerAttr &value)
static void printFloatLiteral(mlir::AsmPrinter &p, llvm::APFloat value, mlir::Type ty)
static mlir::ParseResult parseDataMemberPath(mlir::AsmParser &parser, mlir::DenseI32ArrayAttr &memberPath)
static bool isRttiPtr(mlir::Type ty)
static void printDataMemberPath(mlir::AsmPrinter &p, mlir::DenseI32ArrayAttr memberPath)
static mlir::ParseResult parseRecordMembers(mlir::AsmParser &parser, mlir::ArrayAttr &members)
Definition CIRAttrs.cpp:229
static bool isValidFlexibleArrayInit(mlir::Type memberType, mlir::Type initType)
Definition CIRAttrs.cpp:253
static Decl::Kind getKind(const Decl *D)
*collection of selector each with an associated kind and an ordered *collection of selectors A selector has a kind
RecordLayoutAttr tryGetRecordLayout(mlir::ModuleOp mod, mlir::StringAttr name)
Same lookup as getRecordLayout, but returns a null attribute instead of asserting when the record has...
RecordLayoutAttr getRecordLayout(mlir::ModuleOp mod, mlir::StringAttr name)
Look up the RecordLayoutAttr for a named record in the module's cir.record_layouts dictionary.
mlir::Type memberStorageType(mlir::Type memberTy)
The storage a member is stored as: the access unit for a bit-field member, and the member type itself...
Definition CIRTypes.h:135
bool memberOwnsBytes(mlir::Type memberTy)
Whether a record member occupies bytes of its record.
Definition CIRTypes.h:126
RangeSelector member(std::string ID)
Given a MemberExpr, selects the member token. ID is the node's binding in the match result.
float __ovld __cnfn step(float, float)
Returns 0.0 if x < edge, otherwise it returns 1.0.
__builtin_elementwise_add_sat __builtin_elementwise_sub_sat __builtin_riscv_ssha_i32 __builtin_riscv_sshl_u32 __builtin_riscv_nclipu_u32 int64_t
__builtin_elementwise_add_sat __builtin_elementwise_sub_sat __builtin_riscv_ssha_i32 __builtin_riscv_sshl_u32 uint64_t
__builtin_elementwise_add_sat __builtin_elementwise_sub_sat int32_t