Handle copysign

Author: wsmoses

Diff for: enzyme/Enzyme/ActivityAnalysis.cpp

@@ -168,6 +168,12 @@ bool ActivityAnalyzer::isFunctionArgumentConstant(CallInst *CI, Value *val) {
   if (F->getIntrinsicID() == Intrinsic::trap)
     return true;
 
+  /// Only the first argument (magnitude) of copysign is active
+  if (F->getIntrinsicID() == Intrinsic::copysign &&
+      CI->getArgOperand(0) != val) {
+    return true;
+  }
+
   /// Use of the value as a non-src/dst in memset/memcpy/memmove is an inactive
   /// use
   if (F->getIntrinsicID() == Intrinsic::memset && CI->getArgOperand(0) != val &&

Diff for: enzyme/Enzyme/AdjointGenerator.h

@@ -1352,6 +1352,7 @@ class AdjointGenerator
       case Intrinsic::log10:
       case Intrinsic::exp:
       case Intrinsic::exp2:
+      case Intrinsic::copysign:
       case Intrinsic::pow:
       case Intrinsic::powi:
 #if LLVM_VERSION_MAJOR >= 9
@@ -1631,6 +1632,48 @@ class AdjointGenerator
         }
         return;
       }
+      case Intrinsic::copysign: {
+        if (vdiff && !gutils->isConstantValue(orig_ops[0])) {
+
+          Value *xsign = nullptr;
+          {
+            Type *tys[] = {orig_ops[0]->getType()};
+            SmallVector<Value *, 2> args = {
+                ConstantFP::get(tys[0], 1.0),
+                lookup(gutils->getNewFromOriginal(orig_ops[0]), Builder2)};
+
+            auto cal = cast<CallInst>(Builder2.CreateCall(
+                Intrinsic::getDeclaration(M, Intrinsic::copysign, tys), args));
+            cal->copyIRFlags(&II);
+            cal->setAttributes(II.getAttributes());
+            cal->setCallingConv(II.getCallingConv());
+            cal->setTailCallKind(II.getTailCallKind());
+            cal->setDebugLoc(gutils->getNewFromOriginal(II.getDebugLoc()));
+            xsign = cal;
+          }
+
+          Value *ysign = nullptr;
+          {
+            Type *tys[] = {orig_ops[1]->getType()};
+            SmallVector<Value *, 2> args = {
+                ConstantFP::get(tys[0], 1.0),
+                lookup(gutils->getNewFromOriginal(orig_ops[1]), Builder2)};
+
+            auto cal = cast<CallInst>(Builder2.CreateCall(
+                Intrinsic::getDeclaration(M, Intrinsic::copysign, tys), args));
+            cal->copyIRFlags(&II);
+            cal->setAttributes(II.getAttributes());
+            cal->setCallingConv(II.getCallingConv());
+            cal->setTailCallKind(II.getTailCallKind());
+            cal->setDebugLoc(gutils->getNewFromOriginal(II.getDebugLoc()));
+            ysign = cal;
+          }
+          Value *dif0 =
+              Builder2.CreateFMul(Builder2.CreateFMul(xsign, ysign), vdiff);
+          addToDiffe(orig_ops[0], dif0, Builder2, II.getType());
+        }
+        return;
+      }
       case Intrinsic::powi: {
         if (vdiff && !gutils->isConstantValue(orig_ops[0])) {
 

Diff for: enzyme/Enzyme/TypeAnalysis/TypeAnalysis.cpp

@@ -1704,6 +1704,7 @@ void TypeAnalyzer::visitIntrinsicInst(llvm::IntrinsicInst &I) {
 #if LLVM_VERSION_MAJOR >= 9
   case Intrinsic::experimental_vector_reduce_v2_fadd:
 #endif
+  case Intrinsic::copysign:
   case Intrinsic::maxnum:
   case Intrinsic::minnum:
   case Intrinsic::pow:

Diff for: enzyme/test/Enzyme/copysign.ll

@@ -0,0 +1,30 @@
+; RUN: %opt < %s %loadEnzyme -enzyme -enzyme-preopt=false -mem2reg -instsimplify -simplifycfg -S | FileCheck %s
+
+; Function Attrs: noinline nounwind readnone uwtable
+define double @tester(double %x, double %y) {
+entry:
+  %0 = tail call fast double @llvm.copysign.f64(double %x, double %y)
+  ret double %0
+}
+
+define double @test_derivative(double %x, double %y) {
+entry:
+  %0 = tail call double (double (double, double)*, ...) @__enzyme_autodiff(double (double, double)* nonnull @tester, double %x, double %y)
+  ret double %0
+}
+
+declare double @llvm.copysign.f64(double, double)
+
+; Function Attrs: nounwind
+declare double @__enzyme_autodiff(double (double, double)*, ...)
+
+; CHECK: define internal {{(dso_local )?}}{ double, double } @diffetester(double %x, double %y, double %[[differet:.+]])
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = tail call fast double @llvm.copysign.f64(double 1.000000e+00, double %x)
+; CHECK-NEXT:   %1 = tail call fast double @llvm.copysign.f64(double 1.000000e+00, double %y)
+; CHECK-NEXT:   %2 = fmul fast double %0, %1
+; CHECK-NEXT:   %3 = fmul fast double %2, %[[differet]]
+; CHECK-NEXT:   %4 = insertvalue { double, double } undef, double %3, 0
+; CHECK-NEXT:   %5 = insertvalue { double, double } %4, double 0.000000e+00, 1
+; CHECK-NEXT:   ret { double, double } %5
+; CHECK-NEXT: }