Fix insertvalue issue (#2448)

* Fix insertvalue issue

* fix

* fix fwd ret

Author: wsmoses

enzyme/Enzyme/DifferentialUseAnalysis.h

@@ -179,7 +179,7 @@ inline bool is_value_needed_in_reverse(
         }
       }
 
-      if (!TR.anyFloat(const_cast<Value *>(inst)))
+      if (!TR.allFloat(const_cast<Value *>(inst)))
         if (auto IVI = dyn_cast<Instruction>(user)) {
           bool inserted = false;
           if (auto II = dyn_cast<InsertValueInst>(IVI))
@@ -215,10 +215,32 @@ inline bool is_value_needed_in_reverse(
                 }
 
                 bool partial = false;
-                if (!gutils->isConstantValue(const_cast<Instruction *>(cur))) {
-                  partial = is_value_needed_in_reverse<QueryType::Shadow>(
-                      gutils, user, mode, seen, oldUnreachable);
+                if (auto UI = dyn_cast<Instruction>(u)) {
+                  if (!gutils->isConstantValue(
+                          const_cast<Instruction *>(cur))) {
+                    bool recursiveUse = false;
+                    if (is_use_directly_needed_in_reverse(
+                            gutils, cur, mode, UI, oldUnreachable,
+                            QueryType::Shadow, &recursiveUse)) {
+                      partial = true;
+                    } else if (recursiveUse && !OneLevel) {
+                      partial = is_value_needed_in_reverse<QueryType::Shadow>(
+                          gutils, UI, mode, seen, oldUnreachable);
+                    }
+                  } else if (VT == QueryType::Shadow) {
+                    bool recursiveUse = false;
+                    if (is_use_directly_needed_in_reverse(
+                            gutils, cur, mode, UI, oldUnreachable,
+                            QueryType::ShadowByConstPrimal, &recursiveUse)) {
+                      partial = true;
+                    } else if (recursiveUse && !OneLevel) {
+                      partial = is_value_needed_in_reverse<
+                          QueryType::ShadowByConstPrimal>(gutils, UI, mode,
+                                                          seen, oldUnreachable);
+                    }
+                  }
                 }
+
                 if (partial) {
 
                   if (EnzymePrintDiffUse)

enzyme/Enzyme/TypeAnalysis/TypeAnalysis.cpp

@@ -6099,6 +6099,35 @@ size_t skippedBytes(SmallSet<size_t, 8> &offs, Type *T, const DataLayout &DL,
   return prevOff;
 }
 
+bool TypeResults::allFloat(Value *val) const {
+  assert(val);
+  assert(val->getType());
+  auto q = query(val);
+  auto dt = q[{-1}];
+  if (dt != BaseType::Anything && dt != BaseType::Unknown)
+    return dt.isFloat();
+
+  if (val->getType()->isTokenTy() || val->getType()->isVoidTy())
+    return false;
+  auto &dl = analyzer->fntypeinfo.Function->getParent()->getDataLayout();
+  SmallSet<size_t, 8> offs;
+  size_t ObjSize = skippedBytes(offs, val->getType(), dl);
+
+  for (size_t i = 0; i < ObjSize;) {
+    dt = q[{(int)i}];
+    if (auto FT = dt.isFloat()) {
+      i += (dl.getTypeSizeInBits(FT) + 7) / 8;
+      continue;
+    }
+    if (offs.count(i)) {
+      i++;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
 bool TypeResults::anyFloat(Value *val, bool anythingIsFloat) const {
   assert(val);
   assert(val->getType());

enzyme/Enzyme/TypeAnalysis/TypeAnalysis.h

@@ -205,6 +205,9 @@ class TypeResults {
   // be considered a float.
   bool anyFloat(llvm::Value *val, bool anythingIsFloat = true) const;
 
+  /// Whether all of the top level register is known to contain float data
+  bool allFloat(llvm::Value *val) const;
+
   /// Whether any part of the top level register can contain a pointer
   ///   e.g. { i64, i8* } can contain a pointer, but { i64, float } would not.
   //    Of course, here we compute with type analysis rather than llvm type