[CIR] More unused var warnings pt 2

Author: bcardosolopes

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -1137,10 +1137,10 @@ LValue CIRGenFunction::emitDeclRefLValue(const DeclRefExpr *E) {
 
   // We can form DeclRefExprs naming GUID declarations when reconstituting
   // non-type template parameters into expressions.
-  if (const auto *GD = dyn_cast<MSGuidDecl>(ND))
+  if (isa<MSGuidDecl>(ND))
     llvm_unreachable("NYI");
 
-  if (const auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND))
+  if (isa<TemplateParamObjectDecl>(ND))
     llvm_unreachable("NYI");
 
   llvm_unreachable("Unhandled DeclRefExpr");
@@ -1294,7 +1294,7 @@ Address CIRGenFunction::emitPointerWithAlignment(
 /// expression and compare the result against zero, returning an Int1Ty value.
 mlir::Value CIRGenFunction::evaluateExprAsBool(const Expr *E) {
   // TODO(cir): PGO
-  if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
+  if (E->getType()->getAs<MemberPointerType>()) {
     assert(0 && "not implemented");
   }
 
@@ -1831,8 +1831,7 @@ LValue CIRGenFunction::emitArraySubscriptExpr(const ArraySubscriptExpr *E,
         {Idx}, E->getType(), !getLangOpts().isSignedOverflowDefined(),
         SignedIndices, CGM.getLoc(E->getExprLoc()), /*shouldDecay=*/false,
         &ptrType, E->getBase());
-  } else if (const ObjCObjectType *OIT =
-                 E->getType()->getAs<ObjCObjectType>()) {
+  } else if (E->getType()->getAs<ObjCObjectType>()) {
     llvm_unreachable("ObjC object type subscript is NYI");
   } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
     // If this is A[i] where A is an array, the frontend will have decayed
@@ -1908,6 +1907,8 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *E) {
   switch (E->getCastKind()) {
   case CK_HLSLArrayRValue:
   case CK_HLSLVectorTruncation:
+  case CK_HLSLElementwiseCast:
+  case CK_HLSLAggregateSplatCast:
   case CK_ToVoid:
   case CK_BitCast:
   case CK_LValueToRValueBitCast:
@@ -2147,7 +2148,7 @@ LValue CIRGenFunction::emitMemberExpr(const MemberExpr *E) {
     return LV;
   }
 
-  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
+  if (isa<FunctionDecl>(ND))
     assert(0 && "not implemented");
 
   llvm_unreachable("Unhandled member declaration!");
@@ -2254,7 +2255,7 @@ static void pushTemporaryCleanup(CIRGenFunction &CGF,
   //   need to perform retain/release operations on the temporary.
   //
   // FIXME: This should be looking at E, not M.
-  if (auto Lifetime = M->getType().getObjCLifetime()) {
+  if ([[maybe_unused]] auto Lifetime = M->getType().getObjCLifetime()) {
     assert(0 && "NYI");
   }
 
@@ -2330,7 +2331,7 @@ LValue CIRGenFunction::emitMaterializeTemporaryExpr(
   for (const auto &Ignored : CommaLHSs)
     emitIgnoredExpr(Ignored);
 
-  if (const auto *opaque = dyn_cast<OpaqueValueExpr>(E))
+  if (isa<OpaqueValueExpr>(E))
     assert(0 && "NYI");
 
   // Create and initialize the reference temporary.
@@ -2424,7 +2425,7 @@ std::optional<LValue> HandleConditionalOperatorLValueSimpleCase(
       }
       // If a throw expression we emit it and return an undefined lvalue
       // because it can't be used.
-      if (auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Live->IgnoreParens())) {
+      if (isa<CXXThrowExpr>(Live->IgnoreParens())) {
         llvm_unreachable("NYI");
       }
       return CGF.emitLValue(Live);
@@ -2439,7 +2440,7 @@ std::optional<LValue> HandleConditionalOperatorLValueSimpleCase(
 /// LValue is returned and the current block has been terminated.
 static std::optional<LValue> emitLValueOrThrowExpression(CIRGenFunction &CGF,
                                                          const Expr *Operand) {
-  if (auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Operand->IgnoreParens())) {
+  if (isa<CXXThrowExpr>(Operand->IgnoreParens())) {
     llvm_unreachable("NYI");
   }
 
@@ -2599,7 +2600,7 @@ LValue CIRGenFunction::emitLValue(const Expr *E) {
     return emitBinaryOperatorLValue(cast<BinaryOperator>(E));
   case Expr::CompoundAssignOperatorClass: {
     QualType Ty = E->getType();
-    if (const AtomicType *AT = Ty->getAs<AtomicType>())
+    if (Ty->getAs<AtomicType>())
       assert(0 && "not yet implemented");
     if (!Ty->isAnyComplexType())
       return emitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
@@ -2780,7 +2781,7 @@ mlir::Value CIRGenFunction::emitOpOnBoolExpr(mlir::Location loc,
   //   llvm_unreachable("binaryoperator ifstmt NYI");
   // }
 
-  if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(cond)) {
+  if (isa<UnaryOperator>(cond)) {
     // In LLVM the condition is reversed here for efficient codegen.
     // This should be done in CIR prior to LLVM lowering, if we do now
     // we can make CIR based diagnostics misleading.
@@ -2812,7 +2813,7 @@ mlir::Value CIRGenFunction::emitOpOnBoolExpr(mlir::Location loc,
                                 getContext().BoolTy, CondOp->getExprLoc());
   }
 
-  if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(cond)) {
+  if (isa<CXXThrowExpr>(cond)) {
     llvm_unreachable("NYI");
   }
 
@@ -3300,7 +3301,7 @@ LValue CIRGenFunction::emitPredefinedLValue(const PredefinedExpr *E) {
   StringRef NameItems[] = {PredefinedExpr::getIdentKindName(E->getIdentKind()),
                            FnName};
   std::string GVName = llvm::join(NameItems, NameItems + 2, ".");
-  if (auto *BD = dyn_cast_or_null<BlockDecl>(CurCodeDecl)) {
+  if (isa_and_nonnull<BlockDecl>(CurCodeDecl)) {
     llvm_unreachable("NYI");
   }
 

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -227,7 +227,7 @@ RValue CIRGenFunction::emitCXXMemberOrOperatorMemberCallExpr(
     This = emitLValue(Base);
   }
 
-  if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
+  if (isa<CXXConstructorDecl>(MD)) {
     llvm_unreachable("NYI");
   }
 

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -565,7 +565,7 @@ void CIRGenFunction::finishFunction(SourceLocation endLoc) {
   if (hasCleanups) {
     // Make sure the line table doesn't jump back into the body for
     // the ret after it's been at EndLoc.
-    if (auto *di = getDebugInfo())
+    if (getDebugInfo())
       assert(!cir::MissingFeatures::generateDebugInfo() && "NYI");
     // FIXME(cir): should we clearInsertionPoint? breaks many testcases
     PopCleanupBlocks(PrologueCleanupDepth);
@@ -1057,7 +1057,7 @@ void CIRGenFunction::StartFunction(GlobalDecl gd, QualType retTy,
   // Ignore TSan memory acesses from within ObjC/ObjC++ dealloc, initialize,
   // .cxx_destruct, __destroy_helper_block_ and all of their calees at run time.
   if (SanOpts.has(SanitizerKind::Thread)) {
-    if (const auto *omd = dyn_cast_or_null<ObjCMethodDecl>(d)) {
+    if (isa_and_nonnull<ObjCMethodDecl>(d)) {
       llvm_unreachable("NYI");
     }
   }
@@ -1103,8 +1103,7 @@ void CIRGenFunction::StartFunction(GlobalDecl gd, QualType retTy,
   }
 
   unsigned count, offset;
-  if (const auto *attr =
-          d ? d->getAttr<PatchableFunctionEntryAttr>() : nullptr) {
+  if (d && d->getAttr<PatchableFunctionEntryAttr>()) {
     llvm_unreachable("NYI");
   } else {
     count = CGM.getCodeGenOpts().PatchableFunctionEntryCount;

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -648,11 +648,11 @@ void CIRGenModule::emitGlobal(GlobalDecl gd) {
       assert(!cir::MissingFeatures::openMPRuntime());
       return;
     }
-    if (auto *drd = dyn_cast<OMPDeclareReductionDecl>(global)) {
+    if (isa<OMPDeclareReductionDecl>(global)) {
       assert(!cir::MissingFeatures::openMP());
       return;
     }
-    if (auto *dmd = dyn_cast<OMPDeclareMapperDecl>(global)) {
+    if (isa<OMPDeclareMapperDecl>(global)) {
       assert(!cir::MissingFeatures::openMP());
       return;
     }

clang/lib/CIR/CodeGen/CIRGenStmt.cpp

@@ -106,6 +106,9 @@ mlir::LogicalResult CIRGenFunction::emitStmt(const Stmt *S,
 
   switch (S->getStmtClass()) {
   case Stmt::OMPScopeDirectiveClass:
+  case Stmt::OMPStripeDirectiveClass:
+  case Stmt::OpenACCCacheConstructClass:
+  case Stmt::OpenACCAtomicConstructClass:
     llvm_unreachable("NYI");
   case Stmt::OMPErrorDirectiveClass:
   case Stmt::NoStmtClass: