[llvm] r369160 - [Attributor] Fix: Do not partially resolve returned calls.

[Johannes Doerfert via llvm-commits]

Author: jdoerfert
Date: Fri Aug 16 14:59:52 2019
New Revision: 369160

URL: http://llvm.org/viewvc/llvm-project?rev=369160&view=rev
Log:
[Attributor] Fix: Do not partially resolve returned calls.

By partially resolving returned calls we did not record that they were
not fully resolved which caused odd behavior down the line. We could
also end up with some, but not all, returned values of the callee in the
returned values map of the caller, another odd behavior we want to
avoid.

Modified:
    llvm/trunk/lib/Transforms/IPO/Attributor.cpp

Modified: llvm/trunk/lib/Transforms/IPO/Attributor.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/Attributor.cpp?rev=369160&r1=369159&r2=369160&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/IPO/Attributor.cpp (original)
+++ llvm/trunk/lib/Transforms/IPO/Attributor.cpp Fri Aug 16 14:59:52 2019
@@ -943,12 +943,35 @@ ChangeStatus AAReturnedValuesImpl::updat
                       << static_cast<const AbstractAttribute &>(RetValAA)
                       << "\n");
 
-    // If we know something but not everyting about the returned values, keep
-    // track of that too. Hence, remember transitively unresolved calls.
-    UnresolvedCalls.insert(RetValAA.getUnresolvedCalls().begin(),
-                           RetValAA.getUnresolvedCalls().end());
+    // Do not try to learn partial information. If the callee has unresolved
+    // return values we will treat the call as unresolved/opaque.
+    auto &RetValAAUnresolvedCalls = RetValAA.getUnresolvedCalls();
+    if (!RetValAAUnresolvedCalls.empty()) {
+      UnresolvedCalls.insert(CB);
+      continue;
+    }
+
+    // Now check if we can track transitively returned values. If possible, thus
+    // if all return value can be represented in the current scope, do so.
+    bool Unresolved = false;
+    for (auto &RetValAAIt : RetValAA.returned_values()) {
+      Value *RetVal = RetValAAIt.first;
+      if (isa<Argument>(RetVal) || isa<CallBase>(RetVal) ||
+          isa<Constant>(RetVal))
+        continue;
+      // Anything that did not fit in the above categories cannot be resolved,
+      // mark the call as unresolved.
+      LLVM_DEBUG(dbgs() << "[AAReturnedValues] transitively returned value "
+                           "cannot be translated: "
+                        << *RetVal << "\n");
+      UnresolvedCalls.insert(CB);
+      Unresolved = true;
+      break;
+    }
+
+    if (Unresolved)
+      continue;
 
-    // Now track transitively returned values.
     for (auto &RetValAAIt : RetValAA.returned_values()) {
       Value *RetVal = RetValAAIt.first;
       if (Argument *Arg = dyn_cast<Argument>(RetVal)) {
@@ -967,12 +990,6 @@ ChangeStatus AAReturnedValuesImpl::updat
         NewRVsMap[RetVal].insert(It.second.begin(), It.second.end());
         continue;
       }
-      // Anything that did not fit in the above categories cannot be resolved,
-      // mark the call as unresolved.
-      LLVM_DEBUG(dbgs() << "[AAReturnedValues] transitively returned value "
-                           "cannot be translated: "
-                        << *RetVal << "\n");
-      UnresolvedCalls.insert(CB);
     }
   }