1//===- Types.cpp - MLIR Type Classes --------------------------------------===//
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 "mlir/IR/BuiltinTypes.h"
10#include "mlir/IR/Dialect.h"
11
12using namespace mlir;
13using namespace mlir::detail;
14
15//===----------------------------------------------------------------------===//
16// AbstractType
17//===----------------------------------------------------------------------===//
18
19void AbstractType::walkImmediateSubElements(
20 Type type, function_ref<void(Attribute)> walkAttrsFn,
21 function_ref<void(Type)> walkTypesFn) const {
22 walkImmediateSubElementsFn(type, walkAttrsFn, walkTypesFn);
23}
24
25Type AbstractType::replaceImmediateSubElements(Type type,
26 ArrayRef<Attribute> replAttrs,
27 ArrayRef<Type> replTypes) const {
28 return replaceImmediateSubElementsFn(type, replAttrs, replTypes);
29}
30
31//===----------------------------------------------------------------------===//
32// Type
33//===----------------------------------------------------------------------===//
34
35MLIRContext *Type::getContext() const { return getDialect().getContext(); }
36
37bool Type::isFloat8E5M2() const { return llvm::isa<Float8E5M2Type>(*this); }
38bool Type::isFloat8E4M3FN() const { return llvm::isa<Float8E4M3FNType>(*this); }
39bool Type::isFloat8E5M2FNUZ() const {
40 return llvm::isa<Float8E5M2FNUZType>(*this);
41}
42bool Type::isFloat8E4M3FNUZ() const {
43 return llvm::isa<Float8E4M3FNUZType>(*this);
44}
45bool Type::isFloat8E4M3B11FNUZ() const {
46 return llvm::isa<Float8E4M3B11FNUZType>(*this);
47}
48bool Type::isBF16() const { return llvm::isa<BFloat16Type>(Val: *this); }
49bool Type::isF16() const { return llvm::isa<Float16Type>(Val: *this); }
50bool Type::isTF32() const { return llvm::isa<FloatTF32Type>(Val: *this); }
51bool Type::isF32() const { return llvm::isa<Float32Type>(Val: *this); }
52bool Type::isF64() const { return llvm::isa<Float64Type>(*this); }
53bool Type::isF80() const { return llvm::isa<Float80Type>(*this); }
54bool Type::isF128() const { return llvm::isa<Float128Type>(*this); }
55
56bool Type::isIndex() const { return llvm::isa<IndexType>(Val: *this); }
57
58bool Type::isInteger() const { return llvm::isa<IntegerType>(Val: *this); }
59
60/// Return true if this is an integer type with the specified width.
61bool Type::isInteger(unsigned width) const {
62 if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
63 return intTy.getWidth() == width;
64 return false;
65}
66
67bool Type::isSignlessInteger() const {
68 if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
69 return intTy.isSignless();
70 return false;
71}
72
73bool Type::isSignlessInteger(unsigned width) const {
74 if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
75 return intTy.isSignless() && intTy.getWidth() == width;
76 return false;
77}
78
79bool Type::isSignedInteger() const {
80 if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
81 return intTy.isSigned();
82 return false;
83}
84
85bool Type::isSignedInteger(unsigned width) const {
86 if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
87 return intTy.isSigned() && intTy.getWidth() == width;
88 return false;
89}
90
91bool Type::isUnsignedInteger() const {
92 if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
93 return intTy.isUnsigned();
94 return false;
95}
96
97bool Type::isUnsignedInteger(unsigned width) const {
98 if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
99 return intTy.isUnsigned() && intTy.getWidth() == width;
100 return false;
101}
102
103bool Type::isSignlessIntOrIndex() const {
104 return isSignlessInteger() || llvm::isa<IndexType>(Val: *this);
105}
106
107bool Type::isSignlessIntOrIndexOrFloat() const {
108 return isSignlessInteger() || llvm::isa<IndexType, FloatType>(Val: *this);
109}
110
111bool Type::isSignlessIntOrFloat() const {
112 return isSignlessInteger() || llvm::isa<FloatType>(Val: *this);
113}
114
115bool Type::isIntOrIndex() const {
116 return llvm::isa<IntegerType>(Val: *this) || isIndex();
117}
118
119bool Type::isIntOrFloat() const {
120 return llvm::isa<IntegerType, FloatType>(Val: *this);
121}
122
123bool Type::isIntOrIndexOrFloat() const { return isIntOrFloat() || isIndex(); }
124
125unsigned Type::getIntOrFloatBitWidth() const {
126 assert(isIntOrFloat() && "only integers and floats have a bitwidth");
127 if (auto intType = llvm::dyn_cast<IntegerType>(*this))
128 return intType.getWidth();
129 return llvm::cast<FloatType>(Val: *this).getWidth();
130}
131

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