Test assert-less build

enzyme/CMakeLists.txt

@@ -14,7 +14,7 @@ add_definitions(-DENZYME_VERSION_MINOR=${ENZYME_MINOR_VERSION})
 add_definitions(-DENZYME_VERSION_PATCH=${ENZYME_PATCH_VERSION})
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-SET(CMAKE_CXX_FLAGS "-Wall -fno-rtti ${CMAKE_CXX_FLAGS} -Werror=unused-variable -Werror=dangling-else")
+SET(CMAKE_CXX_FLAGS "-Wall -fno-rtti ${CMAKE_CXX_FLAGS} -Werror=unused-variable -Werror=dangling-else -Werror=unused-but-set-variable -Werror=return-type -Werror=nonnull")
 SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -ggdb")
 SET(CMAKE_CXX_FLAGS_RELEASE "-O2")
 

enzyme/Enzyme/ActivityAnalysis.cpp

@@ -1049,9 +1049,11 @@ bool ActivityAnalyzer::isConstantValue(TypeResults const &TR, Value *Val) {
     }
     assert(TR.getFunction() == I->getParent()->getParent());
   }
+#ifndef NDEBUG
   if (auto Arg = dyn_cast<Argument>(Val)) {
     assert(TR.getFunction() == Arg->getParent());
   }
+#endif
 
   // Void values are definitionally inactive
   if (Val->getType()->isVoidTy())
@@ -2305,6 +2307,9 @@ bool ActivityAnalyzer::isConstantValue(TypeResults const &TR, Value *Val) {
   // this value is inactive, we are inactive Since we won't look at uses to
   // prove, we can inductively assume this is inactive
   if (directions & UP) {
+    if (!UpHypothesis)
+      UpHypothesis =
+          std::shared_ptr<ActivityAnalyzer>(new ActivityAnalyzer(*this, UP));
     if (directions == UP && !isa<PHINode>(Val)) {
       if (isInstructionInactiveFromOrigin(TR, Val, true)) {
         InsertConstantValue(TR, Val);
@@ -2320,8 +2325,6 @@ bool ActivityAnalyzer::isConstantValue(TypeResults const &TR, Value *Val) {
         }
       }
     } else {
-      UpHypothesis =
-          std::shared_ptr<ActivityAnalyzer>(new ActivityAnalyzer(*this, UP));
       UpHypothesis->ConstantValues.insert(Val);
       if (UpHypothesis->isInstructionInactiveFromOrigin(TR, Val, true)) {
         insertConstantsFrom(TR, *UpHypothesis);

enzyme/Enzyme/AdjointGenerator.h

@@ -408,6 +408,7 @@ class AdjointGenerator : public llvm::InstVisitor<AdjointGenerator> {
     constantval |= gutils->isConstantValue(&I);
 
     Type *type = gutils->getShadowType(I.getType());
+    (void)type;
 
     auto *newi = dyn_cast<Instruction>(gutils->getNewFromOriginal(&I));
 
@@ -621,6 +622,7 @@ class AdjointGenerator : public llvm::InstVisitor<AdjointGenerator> {
       if (primalNeededInReverse) {
         inst = gutils->cacheForReverse(BuilderZ, newi,
                                        getIndex(&I, CacheType::Self, BuilderZ));
+        (void)inst;
         assert(inst->getType() == type);
 
         if (Mode == DerivativeMode::ReverseModeGradient ||
@@ -3777,6 +3779,7 @@ class AdjointGenerator : public llvm::InstVisitor<AdjointGenerator> {
         setDiffe(&I, Constant::getNullValue(gutils->getShadowType(I.getType())),
                  Builder2);
       }
+      (void)vdiff;
 
       switch (ID) {
 
@@ -5201,6 +5204,7 @@ class AdjointGenerator : public llvm::InstVisitor<AdjointGenerator> {
 
         // Note sometimes whattype mistakenly says something should be
         // constant [because composed of integer pointers alone]
+        (void)argType;
         assert(whatType(argType, Mode) == DIFFE_TYPE::DUP_ARG ||
                whatType(argType, Mode) == DIFFE_TYPE::CONSTANT);
       } else {

enzyme/Enzyme/CApi.cpp

@@ -1184,6 +1184,7 @@ LLVMValueRef EnzymeCloneFunctionWithoutReturnOrArgs(LLVMValueRef FC,
       for (auto s : sub) {
         uint64_t ival;
         bool b = s.getAsInteger(10, ival);
+        (void)b;
         assert(!b);
         previdx.push_back(ival);
       }
@@ -1241,6 +1242,7 @@ LLVMValueRef EnzymeComputeByteOffsetOfGEP(LLVMBuilderRef B_r, LLVMValueRef V_r,
   APInt Offset(width, 0);
   bool success =
       collectOffset(cast<GEPOperator>(gep), DL, width, VariableOffsets, Offset);
+  (void)success;
   assert(success);
   Value *start = ConstantInt::get(T, Offset);
   for (auto &pair : VariableOffsets)

enzyme/Enzyme/CacheUtility.cpp

@@ -200,6 +200,7 @@ std::pair<PHINode *, Instruction *> FindCanonicalIV(Loop *L, Type *Ty) {
   }
   llvm::errs() << *Header << "\n";
   assert(0 && "Could not find canonical IV");
+  return std::pair<PHINode *, Instruction *>(nullptr, nullptr);
 }
 
 // Attempt to rewrite all phinode's in the loop in terms of the
@@ -1330,8 +1331,10 @@ void CacheUtility::storeInstructionInCache(LimitContext ctx,
                                            IRBuilder<> &BuilderM, Value *val,
                                            AllocaInst *cache, MDNode *TBAA) {
   assert(BuilderM.GetInsertBlock()->getParent() == newFunc);
+#ifndef NDEBUG
   if (auto inst = dyn_cast<Instruction>(val))
     assert(inst->getParent()->getParent() == newFunc);
+#endif
   IRBuilder<> v(BuilderM.GetInsertBlock());
   v.SetInsertPoint(BuilderM.GetInsertBlock(), BuilderM.GetInsertPoint());
   v.setFastMathFlags(getFast());

enzyme/Enzyme/CallDerivatives.cpp

@@ -4047,6 +4047,7 @@ bool AdjointGenerator::handleKnownCallDerivatives(
             return true;
           }
           assert(!unnecessaryValues.count(rmat.first));
+          (void)primalNeededInReverse;
           assert(primalNeededInReverse);
         }
       }

enzyme/Enzyme/Clang/EnzymeClang.cpp

@@ -141,10 +141,10 @@ class EnzymePlugin final : public clang::ASTConsumer {
     using namespace clang;
     DeclGroupRef::iterator it;
 
-    Visitor v(CI);
+    // Visitor v(CI);
     // Forcibly require emission of all libdevice
     for (it = dg.begin(); it != dg.end(); ++it) {
-      v.TraverseDecl(*it);
+      // v.TraverseDecl(*it);
       if (auto FD = dyn_cast<FunctionDecl>(*it)) {
         if (!FD->hasAttr<clang::CUDADeviceAttr>())
           continue;

enzyme/Enzyme/DiffeGradientUtils.cpp

@@ -164,10 +164,12 @@ DiffeGradientUtils *DiffeGradientUtils::CreateFromClone(
 
 AllocaInst *DiffeGradientUtils::getDifferential(Value *val) {
   assert(val);
+#ifndef NDEBUG
   if (auto arg = dyn_cast<Argument>(val))
     assert(arg->getParent() == oldFunc);
   if (auto inst = dyn_cast<Instruction>(val))
     assert(inst->getParent()->getParent() == oldFunc);
+#endif
   assert(inversionAllocs);
 
   Type *type = getShadowType(val->getType());
@@ -195,10 +197,12 @@ AllocaInst *DiffeGradientUtils::getDifferential(Value *val) {
 }
 
 Value *DiffeGradientUtils::diffe(Value *val, IRBuilder<> &BuilderM) {
+#ifndef NDEBUG
   if (auto arg = dyn_cast<Argument>(val))
     assert(arg->getParent() == oldFunc);
   if (auto inst = dyn_cast<Instruction>(val))
     assert(inst->getParent()->getParent() == oldFunc);
+#endif
 
   if (isConstantValue(val)) {
     llvm::errs() << *newFunc << "\n";
@@ -336,6 +340,7 @@ DiffeGradientUtils::addToDiffe(Value *val, Value *dif, IRBuilder<> &BuilderM,
   llvm::errs() << "} start=" << start << " size=" << size
                << " storeSize=" << storeSize << " val=" << *val << "\n";
   assert(0 && "unhandled accumulate with partial sizes");
+  return {};
 }
 
 SmallVector<SelectInst *, 4>
@@ -345,10 +350,12 @@ DiffeGradientUtils::addToDiffe(Value *val, Value *dif, IRBuilder<> &BuilderM,
   assert(mode == DerivativeMode::ReverseModeGradient ||
          mode == DerivativeMode::ReverseModeCombined);
 
+#ifndef NDEBUG
   if (auto arg = dyn_cast<Argument>(val))
     assert(arg->getParent() == oldFunc);
   if (auto inst = dyn_cast<Instruction>(val))
     assert(inst->getParent()->getParent() == oldFunc);
+#endif
 
   SmallVector<SelectInst *, 4> addedSelects;
 
@@ -659,6 +666,7 @@ DiffeGradientUtils::addToDiffe(Value *val, Value *dif, IRBuilder<> &BuilderM,
 
 void DiffeGradientUtils::setDiffe(Value *val, Value *toset,
                                   IRBuilder<> &BuilderM) {
+#ifndef NDEBUG
   if (auto arg = dyn_cast<Argument>(val))
     assert(arg->getParent() == oldFunc);
   if (auto inst = dyn_cast<Instruction>(val))
@@ -668,6 +676,7 @@ void DiffeGradientUtils::setDiffe(Value *val, Value *toset,
     llvm::errs() << *val << "\n";
   }
   assert(!isConstantValue(val));
+#endif
   toset = SanitizeDerivatives(val, toset, BuilderM);
   if (mode == DerivativeMode::ForwardMode ||
       mode == DerivativeMode::ForwardModeSplit) {

enzyme/Enzyme/DifferentialUseAnalysis.cpp

@@ -54,9 +54,11 @@ bool DifferentialUseAnalysis::is_use_directly_needed_in_reverse(
     const SmallPtrSetImpl<BasicBlock *> &oldUnreachable, QueryType qtype,
     bool *recursiveUse) {
   TypeResults const &TR = gutils->TR;
+#ifndef NDEBUG
   if (auto ainst = dyn_cast<Instruction>(val)) {
     assert(ainst->getParent()->getParent() == gutils->oldFunc);
   }
+#endif
 
   bool shadow =
       qtype == QueryType::Shadow || qtype == QueryType::ShadowByConstPrimal;
@@ -79,8 +81,7 @@ bool DifferentialUseAnalysis::is_use_directly_needed_in_reverse(
 
   if (!user) {
     if (EnzymePrintDiffUse)
-      llvm::errs() << " Need: of " << *val << " in reverse as unknown user "
-                   << *user << "\n";
+      llvm::errs() << " Need: of " << *val << " in reverse as nullptr user\n";
     return true;
   }
 
@@ -794,12 +795,14 @@ void DifferentialUseAnalysis::minCut(const DataLayout &DL, LoopInfo &OrigLI,
       }
     }
   }
+#ifndef NDEBUG
   for (auto R : Required) {
     assert(Intermediates.count(R));
   }
   for (auto R : Recomputes) {
     assert(Intermediates.count(R));
   }
+#endif
 
   Graph Orig = G;
 

enzyme/Enzyme/EnzymeLogic.cpp

@@ -3632,13 +3632,15 @@ Function *EnzymeLogic::CreatePrimalAndGradient(
 
   if (hasMetadata(key.todiff, "enzyme_gradient")) {
     std::set<llvm::Type *> seen;
+#ifndef NDEBUG
     DIFFE_TYPE subretType = whatType(key.todiff->getReturnType(),
                                      DerivativeMode::ReverseModeGradient,
                                      /*intAreConstant*/ false, seen);
     if (key.todiff->getReturnType()->isVoidTy() ||
         key.todiff->getReturnType()->isEmptyTy())
       subretType = DIFFE_TYPE::CONSTANT;
     assert(subretType == key.retType);
+#endif
 
     if (key.mode == DerivativeMode::ReverseModeCombined) {
       auto res = getDefaultFunctionTypeForGradient(

enzyme/Enzyme/FunctionUtils.cpp

@@ -6295,6 +6295,7 @@ class Constraints : public std::enable_shared_from_this<Constraints> {
     assert(t != Type::None);
     assert(c.size() != 0);
     assert(c.size() != 1);
+#ifndef NDEBUG
     SmallVector<InnerTy, 1> tmp(c.begin(), c.end());
     for (unsigned i = 0; i < tmp.size(); i++)
       for (unsigned j = 0; j < i; j++)
@@ -6317,6 +6318,7 @@ class Constraints : public std::enable_shared_from_this<Constraints> {
               if (auto s = dyn_cast<SCEVAddRecExpr>(tmp[j]->node))
                 assert(s->getLoop() != tmp[i]->Loop);
     }
+#endif
   }
 
   bool operator==(const Constraints &rhs) const {