!fixup remove left over code.

Author: fhahn

llvm/lib/Analysis/Loads.cpp

@@ -36,6 +36,11 @@ static bool isDereferenceableAndAlignedPointerViaAssumption(
     function_ref<bool(const RetainedKnowledge &RK)> CheckSize,
     const DataLayout &DL, const Instruction *CtxI, AssumptionCache *AC,
     const DominatorTree *DT) {
+  // Dereferenceable information from assumptions is only valid if the value
+  // cannot be freed between the assumption and use. For now just use the
+  // information for values that cannot be freed in the function.
+  // TODO: More precisely check if the pointer can be freed between assumption
+  // and use.
   if (!CtxI || Ptr->canBeFreed())
     return false;
   /// Look through assumes to see if both dereferencability and alignment can
@@ -198,40 +203,6 @@ static bool isDereferenceableAndAlignedPointer(
                                               Size, DL, CtxI, AC, DT, TLI,
                                               Visited, MaxDepth);
 
-  // Dereferenceable information from assumptions is only valid if the value
-  // cannot be freed between the assumption and use. For now just use the
-  // information for values that cannot be freed in the function.
-  // TODO: More precisely check if the pointer can be freed between assumption
-  // and use.
-  if (CtxI) {
-    const Value *UO = getUnderlyingObjectAggressive(V);
-    if (!V->canBeFreed() || (UO && !UO->canBeFreed())) {
-      /// Look through assumes to see if both dereferencability and alignment
-      /// can be proven by an assume if needed.
-      RetainedKnowledge AlignRK;
-      RetainedKnowledge DerefRK;
-      bool IsAligned = V->getPointerAlignment(DL) >= Alignment;
-      if (getKnowledgeForValue(
-              V, {Attribute::Dereferenceable, Attribute::Alignment}, AC,
-              [&](RetainedKnowledge RK, Instruction *Assume, auto) {
-                if (!isValidAssumeForContext(Assume, CtxI, DT))
-                  return false;
-                if (RK.AttrKind == Attribute::Alignment)
-                  AlignRK = std::max(AlignRK, RK);
-                if (RK.AttrKind == Attribute::Dereferenceable)
-                  DerefRK = std::max(DerefRK, RK);
-                IsAligned |= AlignRK && AlignRK.ArgValue >= Alignment.value();
-                if (IsAligned && DerefRK &&
-                    DerefRK.ArgValue >= Size.getZExtValue())
-                  return true; // We have found what we needed so we stop
-                               // looking
-                return false;  // Other assumes may have better information. so
-                               // keep looking
-              }))
-        return true;
-    }
-  }
-
   return isDereferenceableAndAlignedPointerViaAssumption(
       V, Alignment,
       [Size](const RetainedKnowledge &RK) {