[CIR] Let ConstantOp builder infer its type automatically (llvm#1578)

xlauko · lanza · commit bc1f679e70ef · 2025-08-10T20:18:44.000-07:00
diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
@@ -46,7 +46,7 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
   mlir::Value getConstAPSInt(mlir::Location loc, const llvm::APSInt &val) {
     auto ty =
         cir::IntType::get(getContext(), val.getBitWidth(), val.isSigned());
-    return create<cir::ConstantOp>(loc, ty, getAttr<cir::IntAttr>(ty, val));
+    return create<cir::ConstantOp>(loc, getAttr<cir::IntAttr>(ty, val));
   }
 
   mlir::Value getSignedInt(mlir::Location loc, int64_t val, unsigned numBits) {
@@ -63,20 +63,20 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
 
   mlir::Value getConstAPInt(mlir::Location loc, mlir::Type typ,
                             const llvm::APInt &val) {
-    return create<cir::ConstantOp>(loc, typ, getAttr<cir::IntAttr>(typ, val));
+    return create<cir::ConstantOp>(loc, getAttr<cir::IntAttr>(typ, val));
   }
 
   cir::ConstantOp getConstant(mlir::Location loc, mlir::TypedAttr attr) {
-    return create<cir::ConstantOp>(loc, attr.getType(), attr);
+    return create<cir::ConstantOp>(loc, attr);
   }
 
   // Creates constant null value for integral type ty.
   cir::ConstantOp getNullValue(mlir::Type ty, mlir::Location loc) {
-    return create<cir::ConstantOp>(loc, ty, getZeroInitAttr(ty));
+    return create<cir::ConstantOp>(loc, getZeroInitAttr(ty));
   }
 
   cir::ConstantOp getBool(bool state, mlir::Location loc) {
-    return create<cir::ConstantOp>(loc, getBoolTy(), getCIRBoolAttr(state));
+    return create<cir::ConstantOp>(loc, getCIRBoolAttr(state));
   }
   cir::ConstantOp getFalse(mlir::Location loc) { return getBool(false, loc); }
   cir::ConstantOp getTrue(mlir::Location loc) { return getBool(true, loc); }
@@ -630,7 +630,7 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
   // Creates constant nullptr for pointer type ty.
   cir::ConstantOp getNullPtr(mlir::Type ty, mlir::Location loc) {
     assert(!MissingFeatures::targetCodeGenInfoGetNullPointer());
-    return create<cir::ConstantOp>(loc, ty, getConstPtrAttr(ty, 0));
+    return create<cir::ConstantOp>(loc, getConstPtrAttr(ty, 0));
   }
 
   /// Create a loop condition.
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -407,12 +407,6 @@ def ConstantOp : CIR_Op<"const",
   // The constant operation returns a single value of CIR_AnyType.
   let results = (outs CIR_AnyType:$res);
 
-  let builders = [
-    OpBuilder<(ins "cir::BoolAttr":$value), [{
-      build($_builder, $_state, value.getType(), value);
-    }]>
-  ];
-
   let assemblyFormat = "attr-dict $value";
 
   let hasVerifier = 1;
@@ -5704,9 +5698,9 @@ def SignBitOp : CIR_Op<"signbit", [Pure]> {
 def LinkerOptionsOp : CIR_Op<"linker_options"> {
   let summary = "Options to pass to the linker when the object file is linked";
   let description = [{
-    Pass the given options to the linker when the resulting object file 
+    Pass the given options to the linker when the resulting object file
     is linked.
-    This is used extensively on Windows to determine the C runtime that the 
+    This is used extensively on Windows to determine the C runtime that the
     object files should link against.
 
     Examples:
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.cpp b/clang/lib/CIR/CodeGen/CIRGenBuilder.cpp
@@ -58,10 +58,9 @@ cir::ConstantOp CIRGenBuilderTy::getConstInt(mlir::Location loc,
 }
 
 cir::ConstantOp CIRGenBuilderTy::getConstInt(mlir::Location loc, mlir::Type t,
-                                             uint64_t C) {
-  auto intTy = mlir::dyn_cast<cir::IntType>(t);
-  assert(intTy && "expected cir::IntType");
-  return create<cir::ConstantOp>(loc, intTy, cir::IntAttr::get(t, C));
+                                             uint64_t c) {
+  assert(mlir::isa<cir::IntType>(t) && "expected cir::IntType");
+  return create<cir::ConstantOp>(loc, cir::IntAttr::get(t, c));
 }
 
 void CIRGenBuilderTy::computeGlobalViewIndicesFromFlatOffset(
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h
@@ -546,27 +546,23 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
   //
   cir::ConstantOp getUInt8(uint8_t c, mlir::Location loc) {
     auto uInt8Ty = getUInt8Ty();
-    return create<cir::ConstantOp>(loc, uInt8Ty, cir::IntAttr::get(uInt8Ty, c));
+    return create<cir::ConstantOp>(loc, cir::IntAttr::get(uInt8Ty, c));
   }
   cir::ConstantOp getSInt32(int32_t c, mlir::Location loc) {
     auto sInt32Ty = getSInt32Ty();
-    return create<cir::ConstantOp>(loc, sInt32Ty,
-                                   cir::IntAttr::get(sInt32Ty, c));
+    return create<cir::ConstantOp>(loc, cir::IntAttr::get(sInt32Ty, c));
   }
   cir::ConstantOp getUInt32(uint32_t C, mlir::Location loc) {
     auto uInt32Ty = getUInt32Ty();
-    return create<cir::ConstantOp>(loc, uInt32Ty,
-                                   cir::IntAttr::get(uInt32Ty, C));
+    return create<cir::ConstantOp>(loc, cir::IntAttr::get(uInt32Ty, C));
   }
   cir::ConstantOp getSInt64(uint64_t C, mlir::Location loc) {
     auto sInt64Ty = getSInt64Ty();
-    return create<cir::ConstantOp>(loc, sInt64Ty,
-                                   cir::IntAttr::get(sInt64Ty, C));
+    return create<cir::ConstantOp>(loc, cir::IntAttr::get(sInt64Ty, C));
   }
   cir::ConstantOp getUInt64(uint64_t C, mlir::Location loc) {
     auto uInt64Ty = getUInt64Ty();
-    return create<cir::ConstantOp>(loc, uInt64Ty,
-                                   cir::IntAttr::get(uInt64Ty, C));
+    return create<cir::ConstantOp>(loc, cir::IntAttr::get(uInt64Ty, C));
   }
 
   cir::ConstantOp getConstInt(mlir::Location loc, llvm::APSInt intVal);
@@ -579,7 +575,7 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
                              llvm::APFloat fpVal) {
     assert((mlir::isa<cir::SingleType, cir::DoubleType>(t)) &&
            "expected cir::SingleType or cir::DoubleType");
-    return create<cir::ConstantOp>(loc, t, getAttr<cir::FPAttr>(t, fpVal));
+    return create<cir::ConstantOp>(loc, getAttr<cir::FPAttr>(t, fpVal));
   }
 
   cir::IsFPClassOp createIsFPClass(mlir::Location loc, mlir::Value src,
@@ -590,19 +586,19 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
   /// Create constant nullptr for pointer-to-data-member type ty.
   cir::ConstantOp getNullDataMemberPtr(cir::DataMemberType ty,
                                        mlir::Location loc) {
-    return create<cir::ConstantOp>(loc, ty, getNullDataMemberAttr(ty));
+    return create<cir::ConstantOp>(loc, getNullDataMemberAttr(ty));
   }
 
   cir::ConstantOp getNullMethodPtr(cir::MethodType ty, mlir::Location loc) {
-    return create<cir::ConstantOp>(loc, ty, getNullMethodAttr(ty));
+    return create<cir::ConstantOp>(loc, getNullMethodAttr(ty));
   }
 
   cir::ConstantOp getZero(mlir::Location loc, mlir::Type ty) {
     // TODO: dispatch creation for primitive types.
     assert((mlir::isa<cir::RecordType>(ty) || mlir::isa<cir::ArrayType>(ty) ||
             mlir::isa<cir::VectorType>(ty)) &&
            "NYI for other types");
-    return create<cir::ConstantOp>(loc, ty, cir::ZeroAttr::get(ty));
+    return create<cir::ConstantOp>(loc, cir::ZeroAttr::get(ty));
   }
 
   //
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp
@@ -2151,7 +2151,7 @@ static mlir::Value emitNeonShiftVector(CIRGenBuilderTy &builder,
       cir::IntAttr::get(vecTy.getEltType(), shiftAmt)};
   cir::ConstVectorAttr constVecAttr = cir::ConstVectorAttr::get(
       vecTy, mlir::ArrayAttr::get(builder.getContext(), vecAttr));
-  return builder.create<cir::ConstantOp>(loc, vecTy, constVecAttr);
+  return builder.create<cir::ConstantOp>(loc, constVecAttr);
 }
 
 /// Build ShiftOp of vector type whose shift amount is a vector built
@@ -2202,7 +2202,7 @@ static void vecExtendIntValue(CIRGenFunction &cgf, cir::VectorType argVTy,
   arg = builder.createIntCast(arg, eltTy);
   mlir::Value zero = builder.getConstInt(loc, cgf.SizeTy, 0);
   mlir::Value poison = builder.create<cir::ConstantOp>(
-      loc, eltTy, builder.getAttr<cir::PoisonAttr>(eltTy));
+      loc, builder.getAttr<cir::PoisonAttr>(eltTy));
   arg = builder.create<cir::VecInsertOp>(
       loc, builder.create<cir::VecSplatOp>(loc, argVTy, poison), arg, zero);
 }
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp b/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp
@@ -2033,19 +2033,19 @@ mlir::Value CIRGenModule::emitMemberPointerConstant(const UnaryOperator *E) {
     auto ty = mlir::cast<cir::MethodType>(convertType(E->getType()));
     if (methodDecl->isVirtual())
       return builder.create<cir::ConstantOp>(
-          loc, ty, getCXXABI().buildVirtualMethodAttr(ty, methodDecl));
+          loc, getCXXABI().buildVirtualMethodAttr(ty, methodDecl));
 
     auto methodFuncOp = GetAddrOfFunction(methodDecl);
     return builder.create<cir::ConstantOp>(
-        loc, ty, builder.getMethodAttr(ty, methodFuncOp));
+        loc, builder.getMethodAttr(ty, methodFuncOp));
   }
 
   auto ty = mlir::cast<cir::DataMemberType>(convertType(E->getType()));
 
   // Otherwise, a member data pointer.
   const auto *fieldDecl = cast<FieldDecl>(decl);
   return builder.create<cir::ConstantOp>(
-      loc, ty, builder.getDataMemberAttr(ty, fieldDecl->getFieldIndex()));
+      loc, builder.getDataMemberAttr(ty, fieldDecl->getFieldIndex()));
 }
 
 mlir::Attribute ConstantEmitter::emitAbstract(const Expr *E,
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -174,7 +174,7 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
   mlir::Value VisitIntegerLiteral(const IntegerLiteral *E) {
     mlir::Type Ty = CGF.convertType(E->getType());
     return Builder.create<cir::ConstantOp>(
-        CGF.getLoc(E->getExprLoc()), Ty,
+        CGF.getLoc(E->getExprLoc()),
         Builder.getAttr<cir::IntAttr>(Ty, E->getValue()));
   }
 
@@ -186,14 +186,14 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
     assert(mlir::isa<cir::CIRFPTypeInterface>(Ty) &&
            "expect floating-point type");
     return Builder.create<cir::ConstantOp>(
-        CGF.getLoc(E->getExprLoc()), Ty,
+        CGF.getLoc(E->getExprLoc()),
         Builder.getAttr<cir::FPAttr>(Ty, E->getValue()));
   }
   mlir::Value VisitCharacterLiteral(const CharacterLiteral *E) {
     mlir::Type Ty = CGF.convertType(E->getType());
     auto loc = CGF.getLoc(E->getExprLoc());
     auto init = cir::IntAttr::get(Ty, E->getValue());
-    return Builder.create<cir::ConstantOp>(loc, Ty, init);
+    return Builder.create<cir::ConstantOp>(loc, init);
   }
   mlir::Value VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
     llvm_unreachable("NYI");
@@ -2001,7 +2001,7 @@ mlir::Value ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) {
     // Zero-initialize any remaining values.
     if (NumInitElements < VectorType.getSize()) {
       mlir::Value ZeroValue = CGF.getBuilder().create<cir::ConstantOp>(
-          CGF.getLoc(E->getSourceRange()), VectorType.getEltType(),
+          CGF.getLoc(E->getSourceRange()),
           CGF.getBuilder().getZeroInitAttr(VectorType.getEltType()));
       for (uint64_t i = NumInitElements; i < VectorType.getSize(); ++i) {
         Elements.push_back(ZeroValue);
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h
@@ -807,7 +807,7 @@ class CIRGenFunction : public CIRGenTypeCache {
     bool isReference() const { return ValueAndIsReference.getInt(); }
     LValue getReferenceLValue(CIRGenFunction &CGF, Expr *refExpr) const {
       assert(isReference());
-      // create<cir::ConstantOp>(loc, ty, cir::ZeroAttr::get(ty));
+      // create<cir::ConstantOp>(loc, cir::ZeroAttr::get(ty));
       // CGF.getBuilder().const
       // return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(),
       //                                       refExpr->getType());
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -1035,8 +1035,7 @@ void CIRGenModule::replaceGlobal(cir::GlobalOp oldSym, cir::GlobalOp newSym) {
           auto ar = cast<ConstArrayAttr>(init);
           mlir::OpBuilder::InsertionGuard guard(builder);
           builder.setInsertionPointAfter(c);
-          auto newUser =
-              builder.create<cir::ConstantOp>(c.getLoc(), ar.getType(), ar);
+          auto newUser = builder.create<cir::ConstantOp>(c.getLoc(), ar);
           c.replaceAllUsesWith(newUser.getOperation());
         }
       }
diff --git a/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp b/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp
@@ -654,12 +654,10 @@ class CIRSwitchOpFlattening : public mlir::OpRewritePattern<cir::SwitchOp> {
     auto uIntType = cir::IntType::get(op.getContext(), 32, false);
 
     auto rangeLength = rewriter.create<cir::ConstantOp>(
-        op.getLoc(), sIntType,
-        cir::IntAttr::get(op.getContext(), sIntType, upperBound - lowerBound));
+        op.getLoc(), cir::IntAttr::get(sIntType, upperBound - lowerBound));
 
     auto lowerBoundValue = rewriter.create<cir::ConstantOp>(
-        op.getLoc(), sIntType,
-        cir::IntAttr::get(op.getContext(), sIntType, lowerBound));
+        op.getLoc(), cir::IntAttr::get(sIntType, lowerBound));
     auto diffValue =
         rewriter.create<cir::BinOp>(op.getLoc(), sIntType, cir::BinOpKind::Sub,
                                     op.getCondition(), lowerBoundValue);
diff --git a/clang/lib/CIR/Dialect/Transforms/LibOpt.cpp b/clang/lib/CIR/Dialect/Transforms/LibOpt.cpp
@@ -187,8 +187,7 @@ void LibOptPass::xformStdFindIntoMemchr(StdFindOp findOp) {
         return builder.create<MemChrOp>(
             findOp.getLoc(), memchrOp0, memchrOp1,
             builder.create<ConstantOp>(
-                findOp.getLoc(), uInt64Ty,
-                cir::IntAttr::get(uInt64Ty, staticSize)));
+                findOp.getLoc(), cir::IntAttr::get(uInt64Ty, staticSize)));
       }
     }
     return builder.create<MemChrOp>(
diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp
@@ -875,7 +875,7 @@ void LoweringPreparePass::lowerThreeWayCmpOp(CmpThreeWayOp op) {
 
   auto buildCmpRes = [&](int64_t value) -> mlir::Value {
     return builder.create<cir::ConstantOp>(
-        loc, op.getType(), cir::IntAttr::get(op.getType(), value));
+        loc, cir::IntAttr::get(op.getType(), value));
   };
   auto ltRes = buildCmpRes(cmpInfo.getLt());
   auto eqRes = buildCmpRes(cmpInfo.getEq());
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/ItaniumCXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/ItaniumCXXABI.cpp
@@ -541,7 +541,7 @@ mlir::Value ItaniumCXXABI::lowerMethodCmp(cir::CmpOp op, mlir::Value loweredLhs,
 
   cir::IntType ptrdiffCIRTy = getPtrDiffCIRTy(LM);
   mlir::Value ptrdiffZero = builder.create<cir::ConstantOp>(
-      op.getLoc(), ptrdiffCIRTy, cir::IntAttr::get(ptrdiffCIRTy, 0));
+      op.getLoc(), cir::IntAttr::get(ptrdiffCIRTy, 0));
 
   mlir::Value lhsPtrField = builder.create<cir::ExtractMemberOp>(
       op.getLoc(), ptrdiffCIRTy, loweredLhs, 0);
@@ -622,7 +622,7 @@ ItaniumCXXABI::lowerMethodToBoolCast(cir::CastOp op, mlir::Value loweredSrc,
   //   unspecified for null member function pointers.
   cir::IntType ptrdiffCIRTy = getPtrDiffCIRTy(LM);
   mlir::Value ptrdiffZero = builder.create<cir::ConstantOp>(
-      op.getLoc(), ptrdiffCIRTy, cir::IntAttr::get(ptrdiffCIRTy, 0));
+      op.getLoc(), cir::IntAttr::get(ptrdiffCIRTy, 0));
   mlir::Value ptrField = builder.create<cir::ExtractMemberOp>(
       op.getLoc(), ptrdiffCIRTy, loweredSrc, 0);
   return builder.create<cir::CmpOp>(op.getLoc(), cir::CmpOpKind::ne, ptrField,
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareAArch64CXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareAArch64CXXABI.cpp
@@ -157,7 +157,7 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg(
   // though anyone passing 2GB of arguments, each at most 16 bytes, deserves
   // whatever they get).
   auto zeroValue = builder.create<cir::ConstantOp>(
-      loc, regOffs.getType(), cir::IntAttr::get(regOffs.getType(), 0));
+      loc, cir::IntAttr::get(regOffs.getType(), 0));
   auto usingStack = builder.create<cir::CmpOp>(loc, boolTy, cir::CmpOpKind::ge,
                                                regOffs, zeroValue);
   builder.create<cir::BrCondOp>(loc, usingStack, onStackBlock, maybeRegBlock);
@@ -192,7 +192,7 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg(
   // allocating an argument to the stack also uses up all the remaining
   // registers of the appropriate kind.
   auto regSizeValue = builder.create<cir::ConstantOp>(
-      loc, regOffs.getType(), cir::IntAttr::get(regOffs.getType(), regSize));
+      loc, cir::IntAttr::get(regOffs.getType(), regSize));
   auto newOffset = builder.create<cir::BinOp>(
       loc, regOffs.getType(), cir::BinOpKind::Add, regOffs, regSizeValue);
   builder.createStore(loc, newOffset, regOffsP);
@@ -251,8 +251,7 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg(
         tySize < slotSize) {
       clang::CharUnits offset = slotSize - tySize;
       auto offsetConst = builder.create<cir::ConstantOp>(
-          loc, regOffs.getType(),
-          cir::IntAttr::get(regOffs.getType(), offset.getQuantity()));
+          loc, cir::IntAttr::get(regOffs.getType(), offset.getQuantity()));
 
       resAsInt8P = builder.create<cir::PtrStrideOp>(loc, castRegTop.getType(),
                                                     resAsInt8P, offsetConst);
@@ -309,7 +308,7 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg(
   cir_cconv_assert(!cir::MissingFeatures::supportTySizeQueryForAArch64());
 
   auto stackSizeC = builder.create<cir::ConstantOp>(
-      loc, ptrDiffTy, cir::IntAttr::get(ptrDiffTy, stackSize.getQuantity()));
+      loc, cir::IntAttr::get(ptrDiffTy, stackSize.getQuantity()));
   auto castStack = builder.createBitcast(onStackPtr, i8PtrTy);
   // Write the new value of __stack for the next call to va_arg
   auto newStackAsi8Ptr = builder.create<cir::PtrStrideOp>(
@@ -320,7 +319,7 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg(
   if (isBigEndian && !isAggregateTypeForABI && tySize < stackSlotSize) {
     clang::CharUnits offset = stackSlotSize - tySize;
     auto offsetConst = builder.create<cir::ConstantOp>(
-        loc, ptrDiffTy, cir::IntAttr::get(ptrDiffTy, offset.getQuantity()));
+        loc, cir::IntAttr::get(ptrDiffTy, offset.getQuantity()));
     auto offsetStackAsi8Ptr = builder.create<cir::PtrStrideOp>(
         loc, castStack.getType(), castStack, offsetConst);
     auto onStackPtrBE =
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -1171,8 +1171,7 @@ mlir::LogicalResult CIRToLLVMCastOpLowering::matchAndRewrite(
   }
   case cir::CastKind::int_to_bool: {
     auto zero = rewriter.create<cir::ConstantOp>(
-        src.getLoc(), castOp.getSrc().getType(),
-        cir::IntAttr::get(castOp.getSrc().getType(), 0));
+        src.getLoc(), cir::IntAttr::get(castOp.getSrc().getType(), 0));
     rewriter.replaceOpWithNewOp<cir::CmpOp>(
         castOp, cir::BoolType::get(getContext()), cir::CmpOpKind::ne,
         castOp.getSrc(), zero);
@@ -1323,8 +1322,7 @@ mlir::LogicalResult CIRToLLVMCastOpLowering::matchAndRewrite(
     auto zero =
         mlir::IntegerAttr::get(mlir::IntegerType::get(getContext(), 64), 0);
     auto null = rewriter.create<cir::ConstantOp>(
-        src.getLoc(), castOp.getSrc().getType(),
-        cir::ConstPtrAttr::get(getContext(), castOp.getSrc().getType(), zero));
+        src.getLoc(), cir::ConstPtrAttr::get(castOp.getSrc().getType(), zero));
     rewriter.replaceOpWithNewOp<cir::CmpOp>(
         castOp, cir::BoolType::get(getContext()), cir::CmpOpKind::ne,
         castOp.getSrc(), null);

Original file line number	Diff line number	Diff line change
`@@ -58,10 +58,9 @@ cir::ConstantOp CIRGenBuilderTy::getConstInt(mlir::Location loc,`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`cir::ConstantOp CIRGenBuilderTy::getConstInt(mlir::Location loc, mlir::Type t,`
`61`		`- uint64_t C) {`
`62`		`- auto intTy = mlir::dyn_cast<cir::IntType>(t);`
`63`		`- assert(intTy && "expected cir::IntType");`
`64`		`- return create<cir::ConstantOp>(loc, intTy, cir::IntAttr::get(t, C));`
	`61`	`+ uint64_t c) {`
	`62`	`+ assert(mlir::isa<cir::IntType>(t) && "expected cir::IntType");`
	`63`	`+ return create<cir::ConstantOp>(loc, cir::IntAttr::get(t, c));`
`65`	`64`	`}`
`66`	`65`
`67`	`66`	`void CIRGenBuilderTy::computeGlobalViewIndicesFromFlatOffset(`
Original file line number	Diff line number	Diff line change
`@@ -1035,8 +1035,7 @@ void CIRGenModule::replaceGlobal(cir::GlobalOp oldSym, cir::GlobalOp newSym) {`
`1035`	`1035`	`auto ar = cast<ConstArrayAttr>(init);`
`1036`	`1036`	`mlir::OpBuilder::InsertionGuard guard(builder);`
`1037`	`1037`	`builder.setInsertionPointAfter(c);`
`1038`		`- auto newUser =`
`1039`		`- builder.create<cir::ConstantOp>(c.getLoc(), ar.getType(), ar);`
	`1038`	`+ auto newUser = builder.create<cir::ConstantOp>(c.getLoc(), ar);`
`1040`	`1039`	`c.replaceAllUsesWith(newUser.getOperation());`
`1041`	`1040`	`}`
`1042`	`1041`	`}`