Revert "[CIR] Upstream type bool (llvm#128601)"

This reverts commit eacbcbe.

Author: lanza

clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

@@ -10,8 +10,6 @@
 #define LLVM_CLANG_CIR_DIALECT_BUILDER_CIRBASEBUILDER_H
 
 #include "clang/CIR/Dialect/IR/CIRAttrs.h"
-#include "clang/CIR/Dialect/IR/CIRDialect.h"
-#include "clang/CIR/Dialect/IR/CIRTypes.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
@@ -25,14 +23,6 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
   CIRBaseBuilderTy(mlir::MLIRContext &mlirContext)
       : mlir::OpBuilder(&mlirContext) {}
 
-  cir::ConstantOp getBool(bool state, mlir::Location loc) {
-    return create<cir::ConstantOp>(loc, getBoolTy(), getCIRBoolAttr(state));
-  }
-  cir::ConstantOp getFalse(mlir::Location loc) { return getBool(false, loc); }
-  cir::ConstantOp getTrue(mlir::Location loc) { return getBool(true, loc); }
-
-  cir::BoolType getBoolTy() { return cir::BoolType::get(getContext()); }
-
   cir::PointerType getPointerTo(mlir::Type ty) {
     return cir::PointerType::get(getContext(), ty);
   }
@@ -41,10 +31,6 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return getPointerTo(cir::VoidType::get(getContext()));
   }
 
-  cir::BoolAttr getCIRBoolAttr(bool state) {
-    return cir::BoolAttr::get(getContext(), getBoolTy(), state);
-  }
-
   mlir::TypedAttr getConstPtrAttr(mlir::Type type, int64_t value) {
     auto valueAttr = mlir::IntegerAttr::get(
         mlir::IntegerType::get(type.getContext(), 64), value);

clang/include/clang/CIR/Dialect/IR/CIRAttrs.td

@@ -35,25 +35,6 @@ class CIRUnitAttr<string name, string attrMnemonic, list<Trait> traits = []>
   let isOptional = 1;
 }
 
-//===----------------------------------------------------------------------===//
-// BoolAttr
-//===----------------------------------------------------------------------===//
-
-def CIR_BoolAttr : CIR_Attr<"Bool", "bool", [TypedAttrInterface]> {
-  let summary = "Represent true/false for !cir.bool types";
-  let description = [{
-    The BoolAttr represents a 'true' or 'false' value.
-  }];
-
-  let parameters = (ins AttributeSelfTypeParameter<
-                        "", "cir::BoolType">:$type,
-                    "bool":$value);
-
-  let assemblyFormat = [{
-    `<` $value `>`
-  }];
-}
-
 //===----------------------------------------------------------------------===//
 // IntegerAttr
 //===----------------------------------------------------------------------===//

clang/include/clang/CIR/Dialect/IR/CIRTypes.td

@@ -266,20 +266,6 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr",
   }];
 }
 
-//===----------------------------------------------------------------------===//
-// BoolType
-//===----------------------------------------------------------------------===//
-
-def CIR_BoolType :
-    CIR_Type<"Bool", "bool",
-             [DeclareTypeInterfaceMethods<DataLayoutTypeInterface>]> {
-
-  let summary = "CIR bool type";
-  let description = [{
-    `cir.bool` represents C++ bool type.
-  }];
-}
-
 //===----------------------------------------------------------------------===//
 // FuncType
 //===----------------------------------------------------------------------===//
@@ -369,8 +355,7 @@ def VoidPtr : Type<
 //===----------------------------------------------------------------------===//
 
 def CIR_AnyType : AnyTypeOf<[
-  CIR_VoidType, CIR_BoolType, CIR_IntType, CIR_AnyFloat, CIR_PointerType,
-  CIR_FuncType
+  CIR_VoidType, CIR_IntType, CIR_AnyFloat, CIR_PointerType, CIR_FuncType
 ]>;
 
 #endif // MLIR_CIR_DIALECT_CIR_TYPES

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -58,13 +58,6 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
         cgf.getLoc(e->getExprLoc()), type,
         builder.getAttr<cir::IntAttr>(type, e->getValue()));
   }
-
-  mlir::Value VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *e) {
-    mlir::Type type = cgf.convertType(e->getType());
-    return builder.create<cir::ConstantOp>(
-        cgf.getLoc(e->getExprLoc()), type,
-        builder.getCIRBoolAttr(e->getValue()));
-  }
 };
 } // namespace
 

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -141,11 +141,7 @@ void CIRGenModule::emitGlobalVarDefinition(const clang::VarDecl *vd,
       if (APValue *value = initDecl->evaluateValue()) {
         switch (value->getKind()) {
         case APValue::Int: {
-          if (mlir::isa<cir::BoolType>(type))
-            initializer =
-                builder.getCIRBoolAttr(value->getInt().getZExtValue());
-          else
-            initializer = builder.getAttr<cir::IntAttr>(type, value->getInt());
+          initializer = builder.getAttr<cir::IntAttr>(type, value->getInt());
           break;
         }
         case APValue::Float: {

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -108,11 +108,6 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
       resultType = cgm.VoidTy;
       break;
 
-    // bool
-    case BuiltinType::Bool:
-      resultType = cir::BoolType::get(&getMLIRContext());
-      break;
-
     // Signed integral types.
     case BuiltinType::Char_S:
     case BuiltinType::Int:

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -25,23 +25,6 @@ using namespace cir;
 //===----------------------------------------------------------------------===//
 // CIR Dialect
 //===----------------------------------------------------------------------===//
-namespace {
-struct CIROpAsmDialectInterface : public OpAsmDialectInterface {
-  using OpAsmDialectInterface::OpAsmDialectInterface;
-
-  AliasResult getAlias(Type type, raw_ostream &os) const final {
-    return AliasResult::NoAlias;
-  }
-
-  AliasResult getAlias(Attribute attr, raw_ostream &os) const final {
-    if (auto boolAttr = mlir::dyn_cast<cir::BoolAttr>(attr)) {
-      os << (boolAttr.getValue() ? "true" : "false");
-      return AliasResult::FinalAlias;
-    }
-    return AliasResult::NoAlias;
-  }
-};
-} // namespace
 
 void cir::CIRDialect::initialize() {
   registerTypes();
@@ -50,7 +33,6 @@ void cir::CIRDialect::initialize() {
 #define GET_OP_LIST
 #include "clang/CIR/Dialect/IR/CIROps.cpp.inc"
       >();
-  addInterfaces<CIROpAsmDialectInterface>();
 }
 
 //===----------------------------------------------------------------------===//
@@ -130,13 +112,6 @@ static LogicalResult checkConstantTypes(mlir::Operation *op, mlir::Type opType,
     return success();
   }
 
-  if (mlir::isa<cir::BoolAttr>(attrType)) {
-    if (!mlir::isa<cir::BoolType>(opType))
-      return op->emitOpError("result type (")
-             << opType << ") must be '!cir.bool' for '" << attrType << "'";
-    return success();
-  }
-
   if (mlir::isa<cir::IntAttr, cir::FPAttr>(attrType)) {
     auto at = cast<TypedAttr>(attrType);
     if (at.getType() != opType) {

clang/lib/CIR/Dialect/IR/CIRTypes.cpp

@@ -381,28 +381,6 @@ llvm::ArrayRef<mlir::Type> FuncType::getReturnTypes() const {
 
 bool FuncType::isVoid() const { return mlir::isa<VoidType>(getReturnType()); }
 
-//===----------------------------------------------------------------------===//
-// BoolType
-//===----------------------------------------------------------------------===//
-
-llvm::TypeSize
-BoolType::getTypeSizeInBits(const ::mlir::DataLayout &dataLayout,
-                            ::mlir::DataLayoutEntryListRef params) const {
-  return llvm::TypeSize::getFixed(8);
-}
-
-uint64_t
-BoolType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
-                          ::mlir::DataLayoutEntryListRef params) const {
-  return 1;
-}
-
-uint64_t
-BoolType::getPreferredAlignment(const ::mlir::DataLayout &dataLayout,
-                                ::mlir::DataLayoutEntryListRef params) const {
-  return 1;
-}
-
 //===----------------------------------------------------------------------===//
 // PointerType Definitions
 //===----------------------------------------------------------------------===//

clang/test/CIR/func-simple.cpp

@@ -51,9 +51,3 @@ unsigned long long ullfunc() { return 42ull; }
 // CHECK:   %0 = cir.const #cir.int<42> : !cir.int<u, 64>
 // CHECK:   cir.return %0 : !cir.int<u, 64>
 // CHECK: }
-
-bool boolfunc() { return true; }
-// CHECK: cir.func @boolfunc() -> !cir.bool {
-// CHECK:   %0 = cir.const #true
-// CHECK:   cir.return %0 : !cir.bool
-// CHECK: }

clang/test/CIR/global-var-simple.cpp

@@ -58,9 +58,6 @@ _BitInt(20) sb20;
 unsigned _BitInt(48) ub48;
 // CHECK: cir.global @ub48 : !cir.int<u, 48>
 
-bool boolfalse = false;
-// CHECK: cir.global @boolfalse = #false
-
 _Float16 f16;
 // CHECK: cir.global @f16 : !cir.f16