Merge pull request swiftlang#33115 from gottesmm/pr-3b1ab9c8196e6decb2b6b49cbf4f5b44435ed2c9

[opt-remark] Move Argument::inferArgumentFromValue into OptRemarkGenerator.

Author: gottesmm

include/swift/SIL/OptimizationRemark.h

@@ -119,19 +119,6 @@ struct Argument {
       : Argument(ArgumentKey(ArgumentKeyKind::Default, key), msg, decl) {}
   Argument(ArgumentKey key, StringRef msg, const ValueDecl *decl)
       : key(key), val(msg), loc(decl->getLoc()) {}
-
-  /// Given a value, call \p funcPassedInferredArgs for each associated
-  /// ValueDecl that is associated with \p value. All created Arguments are
-  /// passed the same StringRef. To stop iteration, return false in \p
-  /// funcPassedInferedArgs.
-  ///
-  /// NOTE: the function may be called multiple times if the optimizer joined
-  /// two live ranges and thus when iterating over value's users we see multiple
-  /// debug_value operations.
-  static bool
-  inferArgumentsForValue(ArgumentKeyKind keyKind, StringRef message,
-                         SILValue value,
-                         function_ref<bool(Argument)> funcPassedInferedArgs);
 };
 
 /// Shorthand to insert named-value pairs.

lib/SIL/Utils/OptimizationRemark.cpp

@@ -77,42 +77,6 @@ Argument::Argument(StringRef key, CanType ty)
   ty.print(stream);
 }
 
-bool Argument::inferArgumentsForValue(
-    ArgumentKeyKind keyKind, StringRef msg, SILValue value,
-    function_ref<bool(Argument)> funcPassedInferedArgs) {
-
-  while (true) {
-    // If we have an argument, just use that.
-    if (auto *arg = dyn_cast<SILArgument>(value))
-      if (auto *decl = arg->getDecl())
-        return funcPassedInferedArgs(
-            Argument({keyKind, "InferredValue"}, msg, decl));
-
-    // Otherwise, look for debug_values.
-    for (auto *use : getDebugUses(value))
-      if (auto *dvi = dyn_cast<DebugValueInst>(use->getUser()))
-        if (auto *decl = dvi->getDecl())
-          if (!funcPassedInferedArgs(
-                  Argument({keyKind, "InferredValue"}, msg, decl)))
-            return false;
-
-    // If we have a load, look through it and continue. We may have a global or
-    // a function argument.
-    if (auto *li = dyn_cast<LoadInst>(value)) {
-      value = stripAccessMarkers(li->getOperand());
-      continue;
-    }
-
-    if (auto *ga = dyn_cast<GlobalAddrInst>(value))
-      if (auto *decl = ga->getReferencedGlobal()->getDecl())
-        if (!funcPassedInferedArgs(
-                Argument({keyKind, "InferredValue"}, msg, decl)))
-          return false;
-
-    return true;
-  }
-}
-
 template <typename DerivedT>
 std::string Remark<DerivedT>::getMsg() const {
   std::string str;

lib/SILOptimizer/Transforms/OptRemarkGenerator.cpp

@@ -12,6 +12,7 @@
 
 #define DEBUG_TYPE "sil-opt-remark-gen"
 
+#include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/OptimizationRemark.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
@@ -23,6 +24,82 @@
 
 using namespace swift;
 
+//===----------------------------------------------------------------------===//
+//                                  Utility
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+/// Given a value, call \p funcPassedInferredArgs for each associated
+/// ValueDecl that is associated with \p value. All created Arguments are
+/// passed the same StringRef. To stop iteration, return false in \p
+/// funcPassedInferedArgs.
+///
+/// NOTE: the function may be called multiple times if the optimizer joined
+/// two live ranges and thus when iterating over value's users we see multiple
+/// debug_value operations.
+struct ValueToDeclInferrer {
+  using Argument = OptRemark::Argument;
+  using ArgumentKeyKind = OptRemark::ArgumentKeyKind;
+
+  bool infer(ArgumentKeyKind keyKind, StringRef msg, SILValue value,
+             function_ref<bool(Argument)> funcPassedInferedArgs);
+};
+
+} // anonymous namespace
+
+bool ValueToDeclInferrer::infer(
+    ArgumentKeyKind keyKind, StringRef msg, SILValue value,
+    function_ref<bool(Argument)> funcPassedInferedArgs) {
+
+  // This is a linear IR traversal using a 'falling while loop'. That means
+  // every time through the loop we are trying to handle a case before we hit
+  // the bottom of the while loop where we always return true (since we did not
+  // hit a could not compute case). Reassign value and continue to go to the
+  // next step.
+  while (true) {
+    // First check for "identified values" like arguments and global_addr.
+    if (auto *arg = dyn_cast<SILArgument>(value))
+      if (auto *decl = arg->getDecl())
+        return funcPassedInferedArgs(
+            Argument({keyKind, "InferredValue"}, msg, decl));
+
+    if (auto *ga = dyn_cast<GlobalAddrInst>(value))
+      if (auto *decl = ga->getReferencedGlobal()->getDecl())
+        if (!funcPassedInferedArgs(
+                Argument({keyKind, "InferredValue"}, msg, decl)))
+          return false;
+
+    // Then visit our users and see if we can find a debug_value that provides
+    // us with a decl we can use to construct an argument.
+    for (auto *use : value->getUses()) {
+      // Skip type dependent uses.
+      if (use->isTypeDependent())
+        continue;
+
+      if (auto *dvi = dyn_cast<DebugValueInst>(use->getUser())) {
+        if (auto *decl = dvi->getDecl())
+          if (!funcPassedInferedArgs(
+                  Argument({keyKind, "InferredValue"}, msg, decl)))
+            return false;
+      }
+    }
+
+    // At this point, we could not infer any argument. See if we can look
+    // through loads, geps to construct a ProjectionPath.
+
+    // Finally, see if we can look through a load...
+    if (auto *li = dyn_cast<LoadInst>(value)) {
+      value = stripAccessMarkers(li->getOperand());
+      continue;
+    }
+
+    // If we reached this point, we finished falling through the loop and return
+    // true.
+    return true;
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                        Opt Remark Generator Visitor
 //===----------------------------------------------------------------------===//
@@ -35,6 +112,10 @@ struct OptRemarkGeneratorInstructionVisitor
   RCIdentityFunctionInfo &rcfi;
   OptRemark::Emitter ORE;
 
+  /// A class that we use to infer the decl that is associated with a
+  /// miscellaneous SIL value. This is just a heuristic that is to taste.
+  ValueToDeclInferrer valueToDeclInferrer;
+
   OptRemarkGeneratorInstructionVisitor(SILFunction &fn,
                                        RCIdentityFunctionInfo &rcfi)
       : mod(fn.getModule()), rcfi(rcfi), ORE(DEBUG_TYPE, fn) {}
@@ -54,7 +135,7 @@ void OptRemarkGeneratorInstructionVisitor::visitStrongRetainInst(
     using namespace OptRemark;
     SILValue root = rcfi.getRCIdentityRoot(sri->getOperand());
     SmallVector<Argument, 8> inferredArgs;
-    bool foundArgs = Argument::inferArgumentsForValue(
+    bool foundArgs = valueToDeclInferrer.infer(
         ArgumentKeyKind::Note, "on value:", root, [&](Argument arg) {
           inferredArgs.push_back(arg);
           return true;
@@ -84,7 +165,7 @@ void OptRemarkGeneratorInstructionVisitor::visitStrongReleaseInst(
     // Releases end a lifetime scope so we infer scan backward.
     SILValue root = rcfi.getRCIdentityRoot(sri->getOperand());
     SmallVector<Argument, 8> inferredArgs;
-    bool foundArgs = Argument::inferArgumentsForValue(
+    bool foundArgs = valueToDeclInferrer.infer(
         ArgumentKeyKind::Note, "on value:", root, [&](Argument arg) {
           inferredArgs.push_back(arg);
           return true;
@@ -111,7 +192,7 @@ void OptRemarkGeneratorInstructionVisitor::visitRetainValueInst(
     using namespace OptRemark;
     SILValue root = rcfi.getRCIdentityRoot(rvi->getOperand());
     SmallVector<Argument, 8> inferredArgs;
-    bool foundArgs = Argument::inferArgumentsForValue(
+    bool foundArgs = valueToDeclInferrer.infer(
         ArgumentKeyKind::Note, "on value:", root, [&](Argument arg) {
           inferredArgs.push_back(arg);
           return true;
@@ -140,7 +221,7 @@ void OptRemarkGeneratorInstructionVisitor::visitReleaseValueInst(
     using namespace OptRemark;
     SILValue root = rcfi.getRCIdentityRoot(rvi->getOperand());
     SmallVector<Argument, 8> inferredArgs;
-    bool foundArgs = Argument::inferArgumentsForValue(
+    bool foundArgs = valueToDeclInferrer.infer(
         ArgumentKeyKind::Note, "on value:", root, [&](Argument arg) {
           inferredArgs.push_back(arg);
           return true;