[mlir][NFC] Add isBool to replace isInteger(1).

[jacquesguan]

Summary

There are many situations that we want to determine that if the type is a bool type in mlir. Using isBool instead of isInteger should make the code more clear.

[rriddle]

I'd prefer to keep this as-is, we don't use bool to refer to i1 types anywhere in the source.

flang/lib/Optimizer/Dialect/FIROps.cpp

mlir::ParseResult fir::IterWhileOp::parse(mlir::OpAsmParser &parser,
   fir::IterWhileOp::ensureTerminator(*body, builder, result.location);
   return mlir::success();
 }
 
 mlir::LogicalResult fir::IterWhileOp::verify() {
   // Check that the body defines as single block argument for the induction
   // variable.
   auto *body = getBody();
-  if (!body->getArgument(1).getType().isInteger(1))
+  if (!body->getArgument(1).getType().isBool())
     return emitOpError(
         "expected body second argument to be an index argument for "
         "the induction variable");
   if (!body->getArgument(0).getType().isIndex())
     return emitOpError(
         "expected body first argument to be an index argument for "
         "the induction variable");
 

mlir/include/mlir/IR/Types.h

public:
 
   /// Return true if this is an integer (of any signedness) or an index type.
   bool isIntOrIndex() const;
   /// Return true if this is an integer (of any signedness) or a float type.
   bool isIntOrFloat() const;
   /// Return true if this is an integer (of any signedness), index, or float
   /// type.
   bool isIntOrIndexOrFloat() const;
+  /// Return true if this is an bool type.
+  bool isBool() const;
 
   /// Print the current type.
   void print(raw_ostream &os) const;
   void dump() const;
 
   friend ::llvm::hash_code hash_value(Type arg);
 
   /// Methods for supporting PointerLikeTypeTraits.

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

if (status != APFloat::opOK || losesInfo) {
     return FloatAttr();
   }
 
   return builder.getF32FloatAttr(dstVal.convertToFloat());
 }
 
 /// Returns true if the given `type` is a boolean scalar or vector type.
 static bool isBoolScalarOrVector(Type type) {
-  if (type.isInteger(1))
+  if (type.isBool())
     return true;
   if (auto vecType = type.dyn_cast<VectorType>())
-    return vecType.getElementType().isInteger(1);
+    return vecType.getElementType().isBool();
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp with composite type
 //===----------------------------------------------------------------------===//
 
 LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
if (srcElemType != dstElemType) {
     if (srcElemType.isa<FloatType>()) {
       for (FloatAttr srcAttr : dstElementsAttr.getValues<FloatAttr>()) {
         FloatAttr dstAttr =
             convertFloatAttr(srcAttr, dstElemType.cast<FloatType>(), rewriter);
         if (!dstAttr)
           return failure();
         elements.push_back(dstAttr);
       }
-    } else if (srcElemType.isInteger(1)) {
+    } else if (srcElemType.isBool()) {
       return failure();
     } else {
       for (IntegerAttr srcAttr : dstElementsAttr.getValues<IntegerAttr>()) {
         IntegerAttr dstAttr = convertIntegerAttr(
             srcAttr, dstElemType.cast<IntegerType>(), rewriter);
         if (!dstAttr)
           return failure();
         elements.push_back(dstAttr);
if (srcType != dstType) {
         return failure();
     }
 
     rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
     return success();
   }
 
   // Bool type.
-  if (srcType.isInteger(1)) {
+  if (srcType.isBool()) {
     // arith.constant can use 0/1 instead of true/false for i1 values. We need
     // to handle that here.
     auto dstAttr = convertBoolAttr(cstAttr, rewriter);
     if (!dstAttr)
       return failure();
     rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
     return success();
   }

mlir/lib/Conversion/MemRefToSPIRV/MemRefToSPIRV.cpp

static Optional<spirv::Scope> getAtomicOpScope(MemRefType type) {
   default: {
   }
   }
   return {};
 }
 
 /// Casts the given `srcInt` into a boolean value.
 static Value castIntNToBool(Location loc, Value srcInt, OpBuilder &builder) {
-  if (srcInt.getType().isInteger(1))
+  if (srcInt.getType().isBool())
     return srcInt;
 
   auto one = spirv::ConstantOp::getOne(srcInt.getType(), loc, builder);
   return builder.create<spirv::IEqualOp>(loc, srcInt, one);
 }
 
 /// Casts the given `srcBool` into an integer of `dstType`.
 static Value castBoolToIntN(Location loc, Value srcBool, Type dstType,
                             OpBuilder &builder) {
-  assert(srcBool.getType().isInteger(1));
-  if (dstType.isInteger(1))
+  assert(srcBool.getType().isBool());
+  if (dstType.isBool())
     return srcBool;
   Value zero = spirv::ConstantOp::getZero(dstType, loc, builder);
   Value one = spirv::ConstantOp::getOne(dstType, loc, builder);
   return builder.create<spirv::SelectOp>(loc, dstType, srcBool, one, zero);
 }
 
 //===----------------------------------------------------------------------===//
 // Operation conversion

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args,
   }
 
   // tosa::ClzOp
   if (isa<tosa::ClzOp>(op) && elementTy.isa<IntegerType>()) {
     return rewriter.create<math::CountLeadingZerosOp>(loc, elementTy, args[0]);
   }
 
   // tosa::LogicalAnd
-  if (isa<tosa::LogicalAndOp>(op) && elementTy.isInteger(1))
+  if (isa<tosa::LogicalAndOp>(op) && elementTy.isBool())
     return rewriter.create<arith::AndIOp>(loc, resultTypes, args);
 
   // tosa::LogicalNot
-  if (isa<tosa::LogicalNotOp>(op) && elementTy.isInteger(1)) {
+  if (isa<tosa::LogicalNotOp>(op) && elementTy.isBool()) {
     auto one = rewriter.create<arith::ConstantOp>(
         loc, rewriter.getIntegerAttr(elementTy, 1));
     return rewriter.create<arith::XOrIOp>(loc, resultTypes, args[0], one);
   }
 
   // tosa::LogicalOr
-  if (isa<tosa::LogicalOrOp>(op) && elementTy.isInteger(1))
+  if (isa<tosa::LogicalOrOp>(op) && elementTy.isBool())
     return rewriter.create<arith::OrIOp>(loc, resultTypes, args);
 
   // tosa::LogicalXor
-  if (isa<tosa::LogicalXorOp>(op) && elementTy.isInteger(1))
+  if (isa<tosa::LogicalXorOp>(op) && elementTy.isBool())
     return rewriter.create<arith::XOrIOp>(loc, resultTypes, args);
 
   // tosa::PowOp
   if (isa<tosa::PowOp>(op) && elementTy.isa<FloatType>())
     return rewriter.create<mlir::math::PowFOp>(loc, resultTypes, args);
 
   // tosa::RsqrtOp
   if (isa<tosa::RsqrtOp>(op) && elementTy.isa<FloatType>())
if (isa<tosa::CastOp>(op)) {
     if (srcTy.isa<FloatType>() && dstTy.isa<FloatType>() && bitExtend)
       return rewriter.create<arith::ExtFOp>(loc, resultTypes, args, mlir::None);
 
     if (srcTy.isa<FloatType>() && dstTy.isa<FloatType>() && !bitExtend)
       return rewriter.create<arith::TruncFOp>(loc, resultTypes, args,
                                               mlir::None);
 
     // 1-bit integers need to be treated as signless.
-    if (srcTy.isInteger(1) && arith::UIToFPOp::areCastCompatible(srcTy, dstTy))
+    if (srcTy.isBool() && arith::UIToFPOp::areCastCompatible(srcTy, dstTy))
       return rewriter.create<arith::UIToFPOp>(loc, resultTypes, args,
                                               mlir::None);
 
-    if (srcTy.isInteger(1) && dstTy.isa<IntegerType>() && bitExtend)
+    if (srcTy.isBool() && dstTy.isa<IntegerType>() && bitExtend)
       return rewriter.create<arith::ExtUIOp>(loc, resultTypes, args,
                                              mlir::None);
 
     // Unsigned integers need an unrealized cast so that they can be passed
     // to UIToFP.
     if (srcTy.isUnsignedInteger() && dstTy.isa<FloatType>()) {
       auto unrealizedCast =
           rewriter
               .create<UnrealizedConversionCastOp>(
                   loc, rewriter.getIntegerType(srcTy.getIntOrFloatBitWidth()),
                   args[0])
               .getResult(0);
       return rewriter.create<arith::UIToFPOp>(loc, resultTypes[0],
                                               unrealizedCast);
     }
 
     // All other si-to-fp conversions should be handled by SIToFP.
     if (arith::SIToFPOp::areCastCompatible(srcTy, dstTy))
       return rewriter.create<arith::SIToFPOp>(loc, resultTypes, args,
                                               mlir::None);
 
     // Casting to boolean, floats need to only be checked as not-equal to zero.
-    if (srcTy.isa<FloatType>() && dstTy.isInteger(1)) {
+    if (srcTy.isa<FloatType>() && dstTy.isBool()) {
       Value zero = rewriter.create<arith::ConstantOp>(
           loc, rewriter.getFloatAttr(srcTy, 0.0));
       return rewriter.create<arith::CmpFOp>(loc, arith::CmpFPredicate::UNE,
                                             args.front(), zero);
     }
 
     if (arith::FPToSIOp::areCastCompatible(srcTy, dstTy)) {
       auto zero = rewriter.create<arith::ConstantOp>(
if (arith::FPToSIOp::areCastCompatible(srcTy, dstTy)) {
       auto clamped = clampHelper<arith::CmpFOp>(
           loc, rounded, intMin, intMax, arith::CmpFPredicate::OLT, rewriter);
 
       return rewriter.create<arith::FPToSIOp>(loc, dstTy, clamped);
     }
 
     // Casting to boolean, integers need to only be checked as not-equal to
     // zero.
-    if (srcTy.isa<IntegerType>() && dstTy.isInteger(1)) {
+    if (srcTy.isa<IntegerType>() && dstTy.isBool()) {
       Value zero = rewriter.create<arith::ConstantIntOp>(
           loc, 0, srcTy.getIntOrFloatBitWidth());
       return rewriter.create<arith::CmpIOp>(loc, arith::CmpIPredicate::ne,
                                             args.front(), zero);
     }
 
     if (srcTy.isa<IntegerType>() && dstTy.isa<IntegerType>() && bitExtend)
       return rewriter.create<arith::ExtSIOp>(loc, resultTypes, args,
if (isa<tosa::ReduceMaxOp>(op) && elementTy.isa<FloatType>())
     return rewriter.getFloatAttr(
         elementTy, APFloat::getLargest(
                        elementTy.cast<FloatType>().getFloatSemantics(), true));
 
   if (isa<tosa::ReduceMaxOp>(op) && elementTy.isa<IntegerType>())
     return rewriter.getIntegerAttr(
         elementTy, APInt::getSignedMinValue(elementTy.getIntOrFloatBitWidth()));
 
-  if (isa<tosa::ReduceAllOp>(op) && elementTy.isInteger(1))
+  if (isa<tosa::ReduceAllOp>(op) && elementTy.isBool())
     return rewriter.getIntegerAttr(elementTy, APInt::getAllOnes(1));
 
-  if (isa<tosa::ReduceAnyOp>(op) && elementTy.isInteger(1))
+  if (isa<tosa::ReduceAnyOp>(op) && elementTy.isBool())
     return rewriter.getIntegerAttr(elementTy, APInt::getZero(1));
 
   if (isa<tosa::ArgMaxOp>(op) && elementTy.isa<FloatType>())
     return rewriter.getFloatAttr(
         elementTy, APFloat::getLargest(
                        elementTy.cast<FloatType>().getFloatSemantics(), true));
 
   if (isa<tosa::ArgMaxOp>(op) && elementTy.isa<IntegerType>())
static Value createLinalgBodyCalculationForReduceOp(Operation *op,
   }
 
   if (isa<tosa::ReduceMaxOp>(op) && elementTy.isa<IntegerType>()) {
     auto predicate = rewriter.create<arith::CmpIOp>(
         loc, arith::CmpIPredicate::sgt, args[0], args[1]);
     return rewriter.create<arith::SelectOp>(loc, predicate, args[0], args[1]);
   }
 
-  if (isa<tosa::ReduceAllOp>(op) && elementTy.isInteger(1))
+  if (isa<tosa::ReduceAllOp>(op) && elementTy.isBool())
     return rewriter.create<arith::AndIOp>(loc, args);
 
-  if (isa<tosa::ReduceAnyOp>(op) && elementTy.isInteger(1))
+  if (isa<tosa::ReduceAnyOp>(op) && elementTy.isBool())
     return rewriter.create<arith::OrIOp>(loc, args);
 
   return {};
 }
 
 // Performs the match and rewrite for reduction operations. This includes
 // declaring a correctly sized initial value, and the linalg.generic operation
 // that reduces across the specified axis.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

OpFoldResult arith::CmpIOp::fold(ArrayRef<Attribute> operands) {
   // cmpi(pred, x, x)
   if (getLhs() == getRhs()) {
     auto val = applyCmpPredicateToEqualOperands(getPredicate());
     return getBoolAttribute(getType(), getContext(), val);
   }
 
   if (matchPattern(getRhs(), m_Zero())) {
     if (auto extOp = getLhs().getDefiningOp<ExtSIOp>()) {
-      if (extOp.getOperand().getType().cast<IntegerType>().getWidth() == 1) {
+      if (extOp.getOperand().getType().isBool()) {
         // extsi(%x : i1 -> iN) != 0  ->  %x
         if (getPredicate() == arith::CmpIPredicate::ne) {
           return extOp.getOperand();
         }
       }
     }
     if (auto extOp = getLhs().getDefiningOp<ExtUIOp>()) {
-      if (extOp.getOperand().getType().cast<IntegerType>().getWidth() == 1) {
+      if (extOp.getOperand().getType().isBool()) {
         // extui(%x : i1 -> iN) != 0  ->  %x
         if (getPredicate() == arith::CmpIPredicate::ne) {
           return extOp.getOperand();
         }
       }
     }
   }
 

 //  becomes
 //
 //  and(%arg, %x) or and(!%arg, %y)
 struct SelectI1Simplify : public OpRewritePattern<arith::SelectOp> {
   using OpRewritePattern<arith::SelectOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(arith::SelectOp op,
                                 PatternRewriter &rewriter) const override {
-    if (!op.getType().isInteger(1))
+    if (!op.getType().isBool())
       return failure();
 
     Value falseConstant =
         rewriter.create<arith::ConstantIntOp>(op.getLoc(), true, 1);
     Value notCondition = rewriter.create<arith::XOrIOp>(
         op.getLoc(), op.getCondition(), falseConstant);
 
     Value trueVal = rewriter.create<arith::AndIOp>(
         op.getLoc(), op.getCondition(), op.getTrueValue());
     Value falseVal = rewriter.create<arith::AndIOp>(op.getLoc(), notCondition,
                                                     op.getFalseValue());
     rewriter.replaceOpWithNewOp<arith::OrIOp>(op, trueVal, falseVal);
     return success();
   }
 };
 
 //  select %arg, %c1, %c0 => extui %arg
 struct SelectToExtUI : public OpRewritePattern<arith::SelectOp> {
   using OpRewritePattern<arith::SelectOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(arith::SelectOp op,
                                 PatternRewriter &rewriter) const override {
     // Cannot extui i1 to i1, or i1 to f32
-    if (!op.getType().isa<IntegerType>() || op.getType().isInteger(1))
+    if (!op.getType().isa<IntegerType>() || op.getType().isBool())
       return failure();
 
     // select %x, c1, %c0 => extui %arg
     if (matchPattern(op.getTrueValue(), m_One()))
       if (matchPattern(op.getFalseValue(), m_Zero())) {
         rewriter.replaceOpWithNewOp<arith::ExtUIOp>(op, op.getType(),
                                                     op.getCondition());
         return success();
OpFoldResult arith::SelectOp::fold(ArrayRef<Attribute> operands) {
   if (matchPattern(condition, m_One()))
     return trueVal;
 
   // select false, %0, %1 => %1
   if (matchPattern(condition, m_Zero()))
     return falseVal;
 
   // select %x, true, false => %x
-  if (getType().isInteger(1))
+  if (getType().isBool())
     if (matchPattern(getTrueValue(), m_One()))
       if (matchPattern(getFalseValue(), m_Zero()))
         return condition;
 
   if (auto cmp = dyn_cast_or_null<arith::CmpIOp>(condition.getDefiningOp())) {
     auto pred = cmp.getPredicate();
     if (pred == arith::CmpIPredicate::eq || pred == arith::CmpIPredicate::ne) {
       auto cmpLhs = cmp.getLhs();

mlir/lib/Dialect/SCF/SCF.cpp

for (auto tup : llvm::zip(trueYield.getResults(), falseYield.getResults(),
         }
         continue;
       }
 
       auto trueYield = trueResult.getDefiningOp<arith::ConstantOp>();
       if (!trueYield)
         continue;
 
-      if (!trueYield.getType().isInteger(1))
+      if (!trueYield.getType().isBool())
         continue;
 
       auto falseYield = falseResult.getDefiningOp<arith::ConstantOp>();
       if (!falseYield)
         continue;
 
       bool trueVal = trueYield.getValue().cast<BoolAttr>().getValue();
       bool falseVal = falseYield.getValue().cast<BoolAttr>().getValue();

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp

 
 /// Returns the boolean value under the hood if the given `boolAttr` is a scalar
 /// or splat vector bool constant.
 static Optional<bool> getScalarOrSplatBoolAttr(Attribute boolAttr) {
   if (!boolAttr)
     return llvm::None;
 
   auto type = boolAttr.getType();
-  if (type.isInteger(1)) {
+  if (type.isBool()) {
     auto attr = boolAttr.cast<BoolAttr>();
     return attr.getValue();
   }
   if (auto vecType = type.cast<VectorType>()) {
-    if (vecType.getElementType().isInteger(1))
+    if (vecType.getElementType().isBool())
       if (auto attr = boolAttr.dyn_cast<SplatElementsAttr>())
         return attr.getSplatValue<bool>();
   }
   return llvm::None;
 }
 
 // Extracts an element from the given `composite` by following the given
 // `indices`. Returns a null Attribute if error happens.

mlir/lib/IR/BuiltinAttributes.cpp

else
       llvm_unreachable("unexpected element type");
 
     assert(intVal.getBitWidth() == bitWidth &&
            "expected value to have same bitwidth as element type");
     writeBits(data.data(), i * storageBitWidth, intVal);
   }
 
   // Handle the special encoding of splat of bool.
-  if (values.size() == 1 && values[0].getType().isInteger(1))
+  if (values.size() == 1 && values[0].getType().isBool())
     data[0] = data[0] ? -1 : 0;
 
   return DenseIntOrFPElementsAttr::getRaw(type, data);
 }
 
 DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                          ArrayRef<bool> values) {
   assert(hasSameElementsOrSplat(type, values));
-  assert(type.getElementType().isInteger(1));
+  assert(type.getElementType().isBool());
 
   std::vector<char> buff(llvm::divideCeil(values.size(), CHAR_BIT));
 
   if (!values.empty()) {
     bool isSplat = true;
     bool firstValue = values[0];
     for (int i = 0, e = values.size(); i != e; ++i) {
       isSplat &= values[i] == firstValue;

mlir/lib/IR/Operation.cpp

return op->emitOpError("requires at least ")
            << op->getNumSuccessors();
   }
   return verifyTerminatorSuccessors(op);
 }
 
 LogicalResult OpTrait::impl::verifyResultsAreBoolLike(Operation *op) {
   for (auto resultType : op->getResultTypes()) {
     auto elementType = getTensorOrVectorElementType(resultType);
-    bool isBoolType = elementType.isInteger(1);
+    bool isBoolType = elementType.isBool();
     if (!isBoolType)
       return op->emitOpError() << "requires a bool result type";
   }
 
   return success();
 }
 
 LogicalResult OpTrait::impl::verifyResultsAreFloatLike(Operation *op) {

mlir/lib/IR/Types.cpp

 bool Type::isIntOrIndexOrFloat() const { return isIntOrFloat() || isIndex(); }
 
 unsigned Type::getIntOrFloatBitWidth() const {
   assert(isIntOrFloat() && "only integers and floats have a bitwidth");
   if (auto intType = dyn_cast<IntegerType>())
     return intType.getWidth();
   return cast<FloatType>().getWidth();
 }
+
+bool Type::isBool() const { return isInteger(1); }

mlir/lib/Parser/AttributeParser.cpp

for (const auto &signAndToken : storage) {
     if (token.is(Token::floatliteral)) {
       return p.emitError(tokenLoc)
              << "expected integer elements, but parsed floating-point";
     }
 
     assert(token.isAny(Token::integer, Token::kw_true, Token::kw_false) &&
            "unexpected token type");
     if (token.isAny(Token::kw_true, Token::kw_false)) {
-      if (!eltTy.isInteger(1)) {
+      if (!eltTy.isBool()) {
         return p.emitError(tokenLoc)
                << "expected i1 type for 'true' or 'false' values";
       }
       APInt apInt(1, token.is(Token::kw_true), /*isSigned=*/false);
       intValues.push_back(apInt);
       continue;
     }
 

mlir/lib/Target/SPIRV/Serialization/Serializer.cpp

 uint32_t
 Serializer::prepareDenseElementsConstant(Location loc, Type constType,
                                          DenseElementsAttr valueAttr, int dim,
                                          MutableArrayRef<uint64_t> index) {
   auto shapedType = valueAttr.getType().dyn_cast<ShapedType>();
   assert(dim <= shapedType.getRank());
   if (shapedType.getRank() == dim) {
     if (auto attr = valueAttr.dyn_cast<DenseIntElementsAttr>()) {
-      return attr.getType().getElementType().isInteger(1)
+      return attr.getType().getElementType().isBool()
                  ? prepareConstantBool(loc, attr.getValues<BoolAttr>()[index])
                  : prepareConstantInt(loc,
                                       attr.getValues<IntegerAttr>()[index]);
     }
     if (auto attr = valueAttr.dyn_cast<DenseFPElementsAttr>()) {
       return prepareConstantFp(loc, attr.getValues<FloatAttr>()[index]);
     }
     return 0;