Initial support for memory operations in reverse mode

.clang-tidy

@@ -28,6 +28,7 @@ Checks: >
   -readability-function-cognitive-complexity,
   -readability-implicit-bool-conversion,
   -cppcoreguidelines-avoid-magic-numbers,
+  -clang-analyzer-cplusplus.NewDeleteLeaks,
 
 CheckOptions:
   - key:             readability-identifier-naming.ClassCase

include/clad/Differentiator/BaseForwardModeVisitor.h

@@ -106,6 +106,8 @@ class BaseForwardModeVisitor
   StmtDiff VisitPseudoObjectExpr(const clang::PseudoObjectExpr* POE);
   StmtDiff VisitSubstNonTypeTemplateParmExpr(
       const clang::SubstNonTypeTemplateParmExpr* NTTP);
+  StmtDiff VisitImplicitValueInitExpr(const clang::ImplicitValueInitExpr* IVIE);
+  StmtDiff VisitCStyleCastExpr(const clang::CStyleCastExpr* CSCE);
 
   virtual clang::QualType
   GetPushForwardDerivativeType(clang::QualType ParamType);

include/clad/Differentiator/BuiltinDerivatives.h

@@ -196,6 +196,31 @@ CUDA_HOST_DEVICE void clamp_pullback(const T& v, const T& lo, const T& hi,
 #endif
 
 } // namespace std
+
+// NOLINTBEGIN(cppcoreguidelines-no-malloc)
+// NOLINTBEGIN(cppcoreguidelines-owning-memory)
+inline ValueAndPushforward<void*, void*> malloc_pushforward(size_t sz,
+                                                            size_t d_sz) {
+  return {malloc(sz), malloc(sz)};
+}
+
+inline ValueAndPushforward<void*, void*>
+calloc_pushforward(size_t n, size_t sz, size_t d_n, size_t d_sz) {
+  return {calloc(n, sz), calloc(n, sz)};
+}
+
+inline ValueAndPushforward<void*, void*>
+realloc_pushforward(void* ptr, size_t sz, void* d_ptr, size_t d_sz) {
+  return {realloc(ptr, sz), realloc(d_ptr, sz)};
+}
+
+inline void free_pushforward(void* ptr, void* d_ptr) {
+  free(ptr);
+  free(d_ptr);
+}
+// NOLINTEND(cppcoreguidelines-owning-memory)
+// NOLINTEND(cppcoreguidelines-no-malloc)
+
 // These are required because C variants of mathematical functions are
 // defined in global namespace.
 using std::abs_pushforward;

include/clad/Differentiator/CladUtils.h

@@ -328,6 +328,9 @@ namespace clad {
     void SetSwitchCaseSubStmt(clang::SwitchCase* SC, clang::Stmt* subStmt);
 
     bool IsLiteral(const clang::Expr* E);
+
+    bool IsMemoryFunction(const clang::FunctionDecl* FD);
+    bool IsMemoryDeallocationFunction(const clang::FunctionDecl* FD);
     } // namespace utils
     } // namespace clad
 

include/clad/Differentiator/Compatibility.h

@@ -766,5 +766,16 @@ static inline const DeclSpec& Sema_ActOnStartOfLambdaDefinition_ScopeOrDeclSpec(
   ,Node->isTransparent()
 #endif
 
+// Clang 9 above added isa_and_nonnull.
+#if CLANG_VERSION_MAJOR < 9
+template <typename X, typename Y> bool isa_and_nonnull(const Y* Val) {
+  return Val && isa<X>(Val);
+}
+#else
+template <typename X, typename Y> bool isa_and_nonnull(const Y* Val) {
+  return llvm::isa_and_nonnull<X>(Val);
+}
+#endif
+
 } // namespace clad_compat
 #endif //CLAD_COMPATIBILITY

include/clad/Differentiator/ReverseModeVisitor.h

@@ -41,6 +41,8 @@ namespace clad {
     /// the reverse mode we also accumulate Stmts for the reverse pass which
     /// will be executed on return.
     std::vector<Stmts> m_Reverse;
+    /// Storing expressions to delete/free memory in the reverse pass.
+    Stmts m_DeallocExprs;
     /// Stack is used to pass the arguments (dfdx) to further nodes
     /// in the Visit method.
     std::stack<clang::Expr*> m_Stack;
@@ -356,6 +358,9 @@ namespace clad {
     StmtDiff VisitForStmt(const clang::ForStmt* FS);
     StmtDiff VisitIfStmt(const clang::IfStmt* If);
     StmtDiff VisitImplicitCastExpr(const clang::ImplicitCastExpr* ICE);
+    StmtDiff
+    VisitImplicitValueInitExpr(const clang::ImplicitValueInitExpr* IVIE);
+    StmtDiff VisitCStyleCastExpr(const clang::CStyleCastExpr* CSCE);
     StmtDiff VisitInitListExpr(const clang::InitListExpr* ILE);
     StmtDiff VisitIntegerLiteral(const clang::IntegerLiteral* IL);
     StmtDiff VisitMemberExpr(const clang::MemberExpr* ME);
@@ -370,6 +375,8 @@ namespace clad {
     StmtDiff VisitContinueStmt(const clang::ContinueStmt* CS);
     StmtDiff VisitBreakStmt(const clang::BreakStmt* BS);
     StmtDiff VisitCXXThisExpr(const clang::CXXThisExpr* CTE);
+    StmtDiff VisitCXXNewExpr(const clang::CXXNewExpr* CNE);
+    StmtDiff VisitCXXDeleteExpr(const clang::CXXDeleteExpr* CDE);
     StmtDiff VisitCXXConstructExpr(const clang::CXXConstructExpr* CE);
     StmtDiff
     VisitMaterializeTemporaryExpr(const clang::MaterializeTemporaryExpr* MTE);

lib/Differentiator/BaseForwardModeVisitor.cpp

@@ -1445,6 +1445,30 @@ BaseForwardModeVisitor::VisitImplicitCastExpr(const ImplicitCastExpr* ICE) {
   return StmtDiff(subExprDiff.getExpr(), subExprDiff.getExpr_dx());
 }
 
+StmtDiff BaseForwardModeVisitor::VisitImplicitValueInitExpr(
+    const ImplicitValueInitExpr* E) {
+  return StmtDiff(Clone(E), Clone(E));
+}
+
+StmtDiff
+BaseForwardModeVisitor::VisitCStyleCastExpr(const CStyleCastExpr* CSCE) {
+  StmtDiff subExprDiff = Visit(CSCE->getSubExpr());
+  // Create a new CStyleCastExpr with the same type and the same subexpression
+  // as the original one.
+  Expr* castExpr = m_Sema
+                       .BuildCStyleCastExpr(
+                           CSCE->getLParenLoc(), CSCE->getTypeInfoAsWritten(),
+                           CSCE->getRParenLoc(), subExprDiff.getExpr())
+                       .get();
+  Expr* castExprDiff =
+      m_Sema
+          .BuildCStyleCastExpr(CSCE->getLParenLoc(),
+                               CSCE->getTypeInfoAsWritten(),
+                               CSCE->getRParenLoc(), subExprDiff.getExpr_dx())
+          .get();
+  return StmtDiff(castExpr, castExprDiff);
+}
+
 StmtDiff
 BaseForwardModeVisitor::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr* DE) {
   // FIXME: Shouldn't we simply clone the CXXDefaultArgExpr?

lib/Differentiator/CladUtils.cpp

@@ -6,6 +6,7 @@
 #include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Basic/Builtins.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Sema/Lookup.h"
 #include "llvm/ADT/SmallVector.h"
@@ -400,6 +401,12 @@
       auto& C = semaRef.getASTContext();
       if (!TSI)
         TSI = C.getTrivialTypeSourceInfo(qType);
+      if (clad_compat::isa_and_nonnull<ImplicitValueInitExpr>(initializer))
+        // If the initializer is an implicit value init expression, then
+        // we don't need to pass it explicitly to the CXXNewExpr. As, clang
+        // internally adds it when initializer is ParenListExpr and
+        // DirectInitRange is valid.
+        initializer = semaRef.ActOnParenListExpr(noLoc, noLoc, {}).get();
       auto newExpr =
           semaRef
               .BuildCXXNew(
@@ -641,5 +648,37 @@
              isa<ObjCBoolLiteralExpr>(E) || isa<CXXBoolLiteralExpr>(E) ||
              isa<GNUNullExpr>(E);
     }
+
+    bool IsMemoryFunction(const clang::FunctionDecl* FD) {
+
+#if CLANG_VERSION_MAJOR > 12
+      if (FD->getBuiltinID() == Builtin::BImalloc)
+        return true;
+      if (FD->getBuiltinID() == Builtin::ID::BIcalloc)
+        return true;
+      if (FD->getBuiltinID() == Builtin::ID::BIrealloc)
+        return true;
+      if (FD->getBuiltinID() == Builtin::ID::BImemset)
+        return true;
+#else
+      if (FD->getNameAsString() == "malloc")
+        return true;
+      if (FD->getNameAsString() == "calloc")
+        return true;
+      if (FD->getNameAsString() == "realloc")
+        return true;
+      if (FD->getNameAsString() == "memset")
+        return true;
+#endif
+      return false;
+    }
+
+    bool IsMemoryDeallocationFunction(const clang::FunctionDecl* FD) {
+#if CLANG_VERSION_MAJOR > 12
+      return FD->getBuiltinID() == Builtin::ID::BIfree;
+#else
+      return FD->getNameAsString() == "free";
+#endif
+    }
   } // namespace utils
 } // namespace clad