diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h
--- a/llvm/include/llvm/Transforms/IPO/Attributor.h
+++ b/llvm/include/llvm/Transforms/IPO/Attributor.h
@@ -1501,16 +1501,31 @@
 
   /// If \p V is assumed simplified, return it, if it is unclear yet,
   /// return None, otherwise return `nullptr`.
+  Optional<Value *> getAssumedSimplified(const IRPosition &IRP,
+                                         const AbstractAttribute &AA,
+                                         bool &UsedAssumedInformation,
+                                         bool &ForceUpdate) {
+    return getAssumedSimplified(IRP, &AA, UsedAssumedInformation, ForceUpdate);
+  }
+  Optional<Value *> getAssumedSimplified(const Value &V,
+                                         const AbstractAttribute &AA,
+                                         bool &UsedAssumedInformation,
+                                         bool &ForceUpdate) {
+    return getAssumedSimplified(IRPosition::value(V), AA,
+                                UsedAssumedInformation, ForceUpdate);
+  }
   Optional<Value *> getAssumedSimplified(const IRPosition &IRP,
                                          const AbstractAttribute &AA,
                                          bool &UsedAssumedInformation) {
-    return getAssumedSimplified(IRP, &AA, UsedAssumedInformation);
+    bool ForceUpdate = false;
+    return getAssumedSimplified(IRP, &AA, UsedAssumedInformation, ForceUpdate);
   }
   Optional<Value *> getAssumedSimplified(const Value &V,
                                          const AbstractAttribute &AA,
                                          bool &UsedAssumedInformation) {
+    bool ForceUpdate = false;
     return getAssumedSimplified(IRPosition::value(V), AA,
-                                UsedAssumedInformation);
+                                UsedAssumedInformation, ForceUpdate);
   }
 
   /// Register \p CB as a simplification callback.
@@ -1522,6 +1537,8 @@
       const IRPosition &, const AbstractAttribute *, bool &)>;
   void registerSimplificationCallback(const IRPosition &IRP,
                                       const SimplifictionCallbackTy &CB) {
+    assert(SimplificationCallbacks[IRP].size() == 0 &&
+           "Expected a single simplification callback for a given IRP");
     SimplificationCallbacks[IRP].emplace_back(CB);
   }
 
@@ -1535,7 +1552,14 @@
   /// except that it can be used without recording dependences on any \p AA.
   Optional<Value *> getAssumedSimplified(const IRPosition &V,
                                          const AbstractAttribute *AA,
-                                         bool &UsedAssumedInformation);
+                                         bool &UsedAssumedInformation,
+                                         bool &ForceUpdate);
+  Optional<Value *> getAssumedSimplified(const IRPosition &V,
+                                         const AbstractAttribute *AA,
+                                         bool &UsedAssumedInformation) {
+    bool ForceUpdate = false;
+    return getAssumedSimplified(V, AA, UsedAssumedInformation, ForceUpdate);
+  }
 
 public:
   /// Translate \p V from the callee context into the call site context.
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -658,8 +658,7 @@
     Optional<Value *> SimplifiedV = CB(IRP, &AA, UsedAssumedInformation);
     if (!SimplifiedV.hasValue())
       return llvm::None;
-    if (*SimplifiedV && *SimplifiedV != &IRP.getAssociatedValue() &&
-        isa<Constant>(*SimplifiedV))
+    if (*SimplifiedV && isa<Constant>(*SimplifiedV))
       return cast<Constant>(*SimplifiedV);
   }
   const auto &ValueSimplifyAA =
@@ -686,18 +685,22 @@
   return CI;
 }
 
-Optional<Value *>
-Attributor::getAssumedSimplified(const IRPosition &IRP,
-                                 const AbstractAttribute *AA,
-                                 bool &UsedAssumedInformation) {
+Optional<Value *> Attributor::getAssumedSimplified(const IRPosition &IRP,
+                                                   const AbstractAttribute *AA,
+                                                   bool &UsedAssumedInformation,
+                                                   bool &ForceUpdate) {
   // First check all callbacks provided by outside AAs. If any of them returns
   // a non-null value that is different from the associated value, or None, we
   // assume it's simpliied.
   for (auto &CB : SimplificationCallbacks[IRP]) {
     Optional<Value *> SimplifiedV = CB(IRP, AA, UsedAssumedInformation);
-    if (!SimplifiedV.hasValue() ||
-        (*SimplifiedV && *SimplifiedV != &IRP.getAssociatedValue()))
+    if (!SimplifiedV.hasValue())
       return SimplifiedV;
+
+    if (*SimplifiedV) {
+      ForceUpdate = true;
+      return SimplifiedV;
+    }
   }
 
   // If no high-level/outside simplification occured, use AAValueSimplify.
diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
--- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
+++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
@@ -5068,10 +5068,17 @@
   bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
                       const IRPosition &IRP, bool Simplify = true) {
     bool UsedAssumedInformation = false;
+    bool ForceUpdate = false;
     Optional<Value *> QueryingValueSimplified = &IRP.getAssociatedValue();
     if (Simplify)
-      QueryingValueSimplified =
-          A.getAssumedSimplified(IRP, QueryingAA, UsedAssumedInformation);
+      QueryingValueSimplified = A.getAssumedSimplified(
+          IRP, QueryingAA, UsedAssumedInformation, ForceUpdate);
+
+    if (ForceUpdate) {
+      SimplifiedAssociatedValue = QueryingValueSimplified;
+      return true;
+    }
+
     return unionAssumed(QueryingValueSimplified);
   }