Test assert-less build (#1742)

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 {