MLIR  19.0.0git
Types.cpp
Go to the documentation of this file.
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 
12 using namespace mlir;
13 using namespace mlir::detail;
14 
15 //===----------------------------------------------------------------------===//
16 // AbstractType
17 //===----------------------------------------------------------------------===//
18 
20  Type type, function_ref<void(Attribute)> walkAttrsFn,
21  function_ref<void(Type)> walkTypesFn) const {
22  walkImmediateSubElementsFn(type, walkAttrsFn, walkTypesFn);
23 }
24 
26  ArrayRef<Attribute> replAttrs,
27  ArrayRef<Type> replTypes) const {
28  return replaceImmediateSubElementsFn(type, replAttrs, replTypes);
29 }
30 
31 //===----------------------------------------------------------------------===//
32 // Type
33 //===----------------------------------------------------------------------===//
34 
35 MLIRContext *Type::getContext() const { return getDialect().getContext(); }
36 
37 bool Type::isFloat8E5M2() const { return llvm::isa<Float8E5M2Type>(*this); }
38 bool Type::isFloat8E4M3FN() const { return llvm::isa<Float8E4M3FNType>(*this); }
39 bool Type::isFloat8E5M2FNUZ() const {
40  return llvm::isa<Float8E5M2FNUZType>(*this);
41 }
42 bool Type::isFloat8E4M3FNUZ() const {
43  return llvm::isa<Float8E4M3FNUZType>(*this);
44 }
46  return llvm::isa<Float8E4M3B11FNUZType>(*this);
47 }
48 bool Type::isBF16() const { return llvm::isa<BFloat16Type>(*this); }
49 bool Type::isF16() const { return llvm::isa<Float16Type>(*this); }
50 bool Type::isTF32() const { return llvm::isa<FloatTF32Type>(*this); }
51 bool Type::isF32() const { return llvm::isa<Float32Type>(*this); }
52 bool Type::isF64() const { return llvm::isa<Float64Type>(*this); }
53 bool Type::isF80() const { return llvm::isa<Float80Type>(*this); }
54 bool Type::isF128() const { return llvm::isa<Float128Type>(*this); }
55 
56 bool Type::isIndex() const { return llvm::isa<IndexType>(*this); }
57 
58 bool Type::isInteger() const { return llvm::isa<IntegerType>(*this); }
59 
60 /// Return true if this is an integer type with the specified width.
61 bool Type::isInteger(unsigned width) const {
62  if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
63  return intTy.getWidth() == width;
64  return false;
65 }
66 
68  if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
69  return intTy.isSignless();
70  return false;
71 }
72 
73 bool 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 
79 bool Type::isSignedInteger() const {
80  if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
81  return intTy.isSigned();
82  return false;
83 }
84 
85 bool 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 
92  if (auto intTy = llvm::dyn_cast<IntegerType>(*this))
93  return intTy.isUnsigned();
94  return false;
95 }
96 
97 bool 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 
104  return isSignlessInteger() || llvm::isa<IndexType>(*this);
105 }
106 
108  return isSignlessInteger() || llvm::isa<IndexType, FloatType>(*this);
109 }
110 
112  return isSignlessInteger() || llvm::isa<FloatType>(*this);
113 }
114 
115 bool Type::isIntOrIndex() const {
116  return llvm::isa<IntegerType>(*this) || isIndex();
117 }
118 
119 bool Type::isIntOrFloat() const {
120  return llvm::isa<IntegerType, FloatType>(*this);
121 }
122 
123 bool Type::isIntOrIndexOrFloat() const { return isIntOrFloat() || isIndex(); }
124 
125 unsigned 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>(*this).getWidth();
130 }
Type replaceImmediateSubElements(Type type, ArrayRef< Attribute > replAttrs, ArrayRef< Type > replTypes) const
Replace the immediate sub-elements of the given type.
Definition: Types.cpp:25
void walkImmediateSubElements(Type type, function_ref< void(Attribute)> walkAttrsFn, function_ref< void(Type)> walkTypesFn) const
Walk the immediate sub-elements of the given type.
Definition: Types.cpp:19
Attributes are known-constant values of operations.
Definition: Attributes.h:25
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:60
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:74
bool isF64() const
Definition: Types.cpp:52
bool isTF32() const
Definition: Types.cpp:50
bool isSignlessIntOrIndex() const
Return true if this is a signless integer or index type.
Definition: Types.cpp:103
MLIRContext * getContext() const
Return the MLIRContext in which this type was uniqued.
Definition: Types.cpp:35
bool isSignedInteger() const
Return true if this is a signed integer type (with the specified width).
Definition: Types.cpp:79
bool isFloat8E4M3FN() const
Definition: Types.cpp:38
bool isSignlessInteger() const
Return true if this is a signless integer type (with the specified width).
Definition: Types.cpp:67
bool isIndex() const
Definition: Types.cpp:56
bool isIntOrIndexOrFloat() const
Return true if this is an integer (of any signedness), index, or float type.
Definition: Types.cpp:123
bool isF32() const
Definition: Types.cpp:51
bool isFloat8E4M3FNUZ() const
Definition: Types.cpp:42
bool isUnsignedInteger() const
Return true if this is an unsigned integer type (with the specified width).
Definition: Types.cpp:91
bool isIntOrIndex() const
Return true if this is an integer (of any signedness) or an index type.
Definition: Types.cpp:115
bool isFloat8E4M3B11FNUZ() const
Definition: Types.cpp:45
bool isInteger() const
Return true if this is an integer type (with the specified width).
Definition: Types.cpp:58
bool isIntOrFloat() const
Return true if this is an integer (of any signedness) or a float type.
Definition: Types.cpp:119
bool isFloat8E5M2() const
Definition: Types.cpp:37
bool isF128() const
Definition: Types.cpp:54
bool isF16() const
Definition: Types.cpp:49
bool isF80() const
Definition: Types.cpp:53
bool isSignlessIntOrFloat() const
Return true of this is a signless integer or a float type.
Definition: Types.cpp:111
unsigned getIntOrFloatBitWidth() const
Return the bit width of an integer or a float type, assert failure on other types.
Definition: Types.cpp:125
bool isBF16() const
Definition: Types.cpp:48
bool isFloat8E5M2FNUZ() const
Definition: Types.cpp:39
bool isSignlessIntOrIndexOrFloat() const
Return true if this is a signless integer, index, or float type.
Definition: Types.cpp:107
AttrTypeReplacer.
Include the generated interface declarations.