Fix 1682

Author: Shubham Shukla

include/clad/Differentiator/BaseForwardModeVisitor.h

@@ -124,6 +124,8 @@ class BaseForwardModeVisitor
   StmtDiff VisitNullStmt(const clang::NullStmt* NS) { return StmtDiff{}; };
   StmtDiff
   VisitCXXStdInitializerListExpr(const clang::CXXStdInitializerListExpr* ILE);
+  StmtDiff VisitGNUNullExpr(const clang::GNUNullExpr* E);
+  StmtDiff VisitPredefinedExpr(const clang::PredefinedExpr* E);
 
   StmtDiff VisitOMPExecutableDirective(const clang::OMPExecutableDirective* D);
   StmtDiff VisitOMPParallelDirective(const clang::OMPParallelDirective* D);

include/clad/Differentiator/ReverseModeVisitor.h

@@ -407,6 +407,8 @@ namespace clad {
     StmtDiff VisitForStmt(const clang::ForStmt* FS);
     StmtDiff VisitIfStmt(const clang::IfStmt* If);
     StmtDiff VisitImplicitCastExpr(const clang::ImplicitCastExpr* ICE);
+    StmtDiff VisitGNUNullExpr(const clang::GNUNullExpr* E);
+    StmtDiff VisitPredefinedExpr(const clang::PredefinedExpr* E);
 
 #if CLANG_VERSION_MAJOR > 16
     StmtDiff VisitLambdaExpr(const clang::LambdaExpr* LE);

lib/Differentiator/BaseForwardModeVisitor.cpp

@@ -1612,6 +1612,21 @@ BaseForwardModeVisitor::VisitCStyleCastExpr(const CStyleCastExpr* CSCE) {
   return StmtDiff(castExpr, castExprDiff);
 }
 
+StmtDiff BaseForwardModeVisitor::VisitGNUNullExpr(const clang::GNUNullExpr* E) {
+  auto* Constant0 =
+      ConstantFolder::synthesizeLiteral(m_Context.IntTy, m_Context, /*val=*/0);
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+  return StmtDiff(const_cast<clang::GNUNullExpr*>(E), Constant0);
+}
+
+StmtDiff
+BaseForwardModeVisitor::VisitPredefinedExpr(const clang::PredefinedExpr* E) {
+  auto* Constant0 =
+      ConstantFolder::synthesizeLiteral(m_Context.IntTy, m_Context, /*val=*/0);
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+  return StmtDiff(const_cast<clang::PredefinedExpr*>(E), Constant0);
+}
+
 StmtDiff
 BaseForwardModeVisitor::VisitCXXNamedCastExpr(const CXXNamedCastExpr* NCE) {
   StmtDiff subExprDiff = Visit(NCE->getSubExpr());

lib/Differentiator/ReverseModeVisitor.cpp

@@ -1931,10 +1931,6 @@ Expr* ReverseModeVisitor::getStdInitListSizeExpr(const Expr* E) {
       }
     }
 
-    // FIXME: Revisit this when variadic functions are supported.
-    if (FD->getNameAsString() == "printf" || FD->getNameAsString() == "fprintf")
-      return StmtDiff(Clone(CE));
-
     Expr* CUDAExecConfig = nullptr;
     if (const auto* KCE = dyn_cast<CUDAKernelCallExpr>(CE))
       CUDAExecConfig = Clone(KCE->getConfig());
@@ -2148,6 +2144,10 @@ Expr* ReverseModeVisitor::getStdInitListSizeExpr(const Expr* E) {
                      i = skip_this, e = CE->getNumArgs();
          i != e; ++i) {
       const Expr* arg = CE->getArg(i);
+      if ((i - skip_this) >= FD->getNumParams()) {
+        CallArgs.push_back(Clone(arg));
+        continue;
+      }
       const auto* PVD = FD->getParamDecl(i - skip_this);
       StmtDiff argDiff =
           DifferentiateCallArg(arg, PVD, PreCallStmts, /*isNonDiff=*/nonDiff,
@@ -2907,6 +2907,8 @@ Expr* ReverseModeVisitor::getStdInitListSizeExpr(const Expr* E) {
                         direction::reverse);
       auto* condDiffStored = IfStmtDiff.getRevSweepAsExpr();
       return BuildOp(BO_LAnd, condDiffStored, condVarRef);
+    } else if (opCode == BO_Rem) {
+      return BuildOp(opCode, Visit(L).getExpr(), Visit(R).getExpr());
     } else {
       // We should not output any warning on visiting boolean conditions
       // FIXME: We should support boolean differentiation or ignore it
@@ -3429,6 +3431,21 @@ Expr* ReverseModeVisitor::getStdInitListSizeExpr(const Expr* E) {
     return result;
   }
 
+  StmtDiff ReverseModeVisitor::VisitGNUNullExpr(const clang::GNUNullExpr* E) {
+    auto* Constant0 = ConstantFolder::synthesizeLiteral(m_Context.IntTy,
+                                                        m_Context, /*val=*/0);
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+    return StmtDiff(const_cast<clang::GNUNullExpr*>(E), Constant0);
+  }
+
+  StmtDiff
+  ReverseModeVisitor::VisitPredefinedExpr(const clang::PredefinedExpr* E) {
+    auto* Constant0 = ConstantFolder::synthesizeLiteral(m_Context.IntTy,
+                                                        m_Context, /*val=*/0);
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+    return StmtDiff(const_cast<clang::PredefinedExpr*>(E), Constant0);
+  }
+
   StmtDiff ReverseModeVisitor::VisitCXXFunctionalCastExpr(
       const clang::CXXFunctionalCastExpr* FCE) {
     StmtDiff castExprDiff = Visit(FCE->getSubExpr(), dfdx());

test/Regressions/issue-1682.cpp

@@ -0,0 +1,51 @@
+// RUN: %cladclang -fsyntax-only -Xclang -verify %s -I%S/../../include
+
+#include "clad/Differentiator/Differentiator.h"
+
+extern "C" int printf(const char*, ...);
+void a(...);
+int b; // expected-warning {{gradient uses a global variable 'b'; rerunning the gradient requires 'b' to be reset}}
+
+void c(float) {
+    // expected-warning@+2 {{attempted differentiation of function 'a' without definition and no suitable overload was found in namespace 'custom_derivatives'}}
+    // expected-note@+1 {{numerical differentiation is not viable for 'a'; considering 'a' as 0}}
+    a(b);
+}
+
+double f0(double x) {
+    int index = 10 % 3;
+    const char* func = __func__;
+    void* ptr = __null;
+
+    // expected-warning@+2 {{attempted differentiation of function 'printf' without definition and no suitable overload was found in namespace 'custom_derivatives'}}
+    // expected-note@+1 {{numerical differentiation is not viable for 'printf'; considering 'printf' as 0}}
+    printf("%f", x);
+
+    return x * x;
+}
+
+auto df = clad::gradient(f0);
+auto dg = clad::gradient(c);
+
+int b_fwd;
+
+void c_fwd(float) {
+    // expected-warning@+2 {{attempted differentiation of function 'a' without definition and no suitable overload was found in namespace 'custom_derivatives'}}
+    // expected-note@+1 {{numerical differentiation is not viable for 'a'; considering 'a' as 0}}
+    a(b_fwd);
+}
+
+double f0_fwd(double x) {
+    int index = 10 % 3;
+    const char* func = __func__;
+    void* ptr = __null;
+
+    // expected-warning@+2 {{attempted differentiation of function 'printf' without definition and no suitable overload was found in namespace 'custom_derivatives'}}
+    // expected-note@+1 {{numerical differentiation is not viable for 'printf'; considering 'printf' as 0}}
+    printf("%f", x);
+
+    return x * x;
+}
+
+auto df_fwd = clad::differentiate(f0_fwd);
+auto dg_fwd = clad::differentiate(c_fwd);