[opt-remark] Add a new SIL testing option that works around not having decls in SIL for debug_value.

Instead, in such a case, we use the name on the debug_value instead and just use
as the loc the debug_value itself. This will let me write SIL test cases for
opt-remark-gen.

I am going to add SIL test cases for future changes (as well as swift ones)
using this technique. I am going to in forthcoming commits fill in some tests
for the current opt-remark-generation here. I just want to get in this part.

Author: gottesmm

include/swift/SIL/OptimizationRemark.h

@@ -119,6 +119,12 @@ struct Argument {
       : Argument(ArgumentKey(ArgumentKeyKind::Default, key), msg, decl) {}
   Argument(ArgumentKey key, StringRef msg, const ValueDecl *decl)
       : key(key), val(msg), loc(decl->getLoc()) {}
+
+  Argument(StringRef key, llvm::Twine &&msg, SILLocation loc)
+      : Argument(ArgumentKey(ArgumentKeyKind::Default, key), std::move(msg),
+                 loc) {}
+  Argument(ArgumentKey key, llvm::Twine &&msg, SILLocation loc)
+      : key(key), val(msg.str()), loc(loc.getSourceLoc()) {}
 };
 
 /// Shorthand to insert named-value pairs.

lib/SILOptimizer/Transforms/OptRemarkGenerator.cpp

@@ -41,6 +41,15 @@ static llvm::cl::opt<bool> ForceVisitImplicitAutogeneratedFunctions(
         "Emit opt remarks even on implicit and autogenerated functions"),
     llvm::cl::init(false));
 
+static llvm::cl::opt<bool> DecllessDebugValueUseSILDebugInfo(
+    "optremarkgen-declless-debugvalue-use-sildebugvar-info", llvm::cl::Hidden,
+    llvm::cl::desc(
+        "If a debug_value does not have a decl, infer a value with a name from "
+        "that info that has a loc set to the loc of the debug_value "
+        "instruction itself. This is for testing purposes so it is easier to "
+        "write SIL test cases for this pass"),
+    llvm::cl::init(false));
+
 //===----------------------------------------------------------------------===//
 //                           Value To Decl Inferrer
 //===----------------------------------------------------------------------===//
@@ -65,16 +74,13 @@ struct ValueToDeclInferrer {
   /// accessPath we computed for decl producing a segmented access path, e.x.:
   /// "of 'x.lhs.ivar'".
   void printNote(llvm::raw_string_ostream &stream, const ValueDecl *decl);
+
+  void printProjectionPath(llvm::raw_string_ostream &stream);
 };
 
 } // anonymous namespace
 
-void ValueToDeclInferrer::printNote(llvm::raw_string_ostream &stream,
-                                    const ValueDecl *decl) {
-  assert(decl &&
-         "We assume for now that this is always called with a non-null decl");
-  stream << "of '" << decl->getBaseName();
-
+void ValueToDeclInferrer::printProjectionPath(llvm::raw_string_ostream &stream) {
   for (auto &pair : accessPath) {
     auto baseType = pair.first;
     auto &proj = pair.second;
@@ -111,8 +117,14 @@ void ValueToDeclInferrer::printNote(llvm::raw_string_ostream &stream,
 
     llvm_unreachable("Covered switch is not covered?!");
   }
+}
 
-  accessPath.clear();
+void ValueToDeclInferrer::printNote(llvm::raw_string_ostream &stream,
+                                    const ValueDecl *decl) {
+  assert(decl &&
+         "We assume for now that this is always called with a non-null decl");
+  stream << "of '" << decl->getBaseName();
+  printProjectionPath(stream);
   stream << "'";
 }
 
@@ -145,6 +157,11 @@ static bool hasNonInlinedDebugScope(SILInstruction *i) {
 bool ValueToDeclInferrer::infer(
     ArgumentKeyKind keyKind, SILValue value,
     SmallVectorImpl<Argument> &resultingInferredDecls) {
+  // Clear the stored access path at end of scope.
+  SWIFT_DEFER {
+    accessPath.clear();
+  };
+
   // 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
@@ -234,15 +251,37 @@ bool ValueToDeclInferrer::infer(
               llvm::raw_string_ostream stream(msg);
               printNote(stream, decl);
             }
-            resultingInferredDecls.push_back(
-                Argument({keyKind, "InferredValue"}, std::move(msg), decl));
+            resultingInferredDecls.emplace_back(
+                OptRemark::ArgumentKey{keyKind, "InferredValue"},
+                std::move(msg), decl);
             foundDeclFromUse = true;
+          } else {
+            // If we did not have a decl, see if we were asked for testing
+            // purposes to use SILDebugInfo to create a placeholder inferred
+            // value.
+            if (DecllessDebugValueUseSILDebugInfo) {
+              if (auto varInfo = dvi->getVarInfo()) {
+                auto name = varInfo->Name;
+                if (!name.empty()) {
+                  std::string msg;
+                  {
+                    llvm::raw_string_ostream stream(msg);
+                    stream << "of '" << name;
+                    printProjectionPath(stream);
+                    stream << "'";
+                  }
+                  resultingInferredDecls.push_back(
+                      Argument({keyKind, "InferredValue"},
+                               std::move(msg),
+                               dvi->getLoc()));
+                  foundDeclFromUse = true;
+                }
+              }
+            }
           }
         }
       }
     }
-    if (foundDeclFromUse)
-      return true;
 
     // At this point, we could not infer any argument. See if we can look
     // through loads.
@@ -267,7 +306,7 @@ bool ValueToDeclInferrer::infer(
 
     // If we reached this point, we finished falling through the loop and return
     // true.
-    return true;
+    return foundDeclFromUse;
   }
 }
 

test/SILOptimizer/opt-remark-generator.sil

@@ -1,15 +1,54 @@
-// RUN: %target-sil-opt -sil-opt-remark-generator -sil-remarks-missed=sil-opt-remark-gen -verify %s -o /dev/null
+// RUN: %target-sil-opt -optremarkgen-declless-debugvalue-use-sildebugvar-info -sil-opt-remark-generator -sil-remarks-missed=sil-opt-remark-gen -verify %s -o /dev/null
 
 sil_stage canonical
 
 import Builtin
 
 sil @foo : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
 bb0(%0 : $Builtin.NativeObject):
+  debug_value %0 : $Builtin.NativeObject, let, name "arg"
   strong_retain %0 : $Builtin.NativeObject // expected-remark {{retain of type 'Builtin.NativeObject'}}
+                                           // expected-note @-2 {{of 'arg'}}
   retain_value %0 : $Builtin.NativeObject  // expected-remark {{retain of type 'Builtin.NativeObject'}}
+                                             // expected-note @-4 {{of 'arg'}}
   strong_release %0 : $Builtin.NativeObject // expected-remark {{release of type 'Builtin.NativeObject'}}
+                                             // expected-note @-6 {{of 'arg'}}
   release_value %0 : $Builtin.NativeObject // expected-remark {{release of type 'Builtin.NativeObject'}}
+                                             // expected-note @-8 {{of 'arg'}}
   %9999 = tuple()
   return %9999 : $()
 }
+
+public enum TrivialState {
+case first
+case second
+case third
+}
+
+struct StructWithOwner {
+  var owner: Builtin.NativeObject
+  var state: TrivialState
+}
+
+sil @extract_out_singleobj_struct_subfield_1 : $@convention(thin) (@guaranteed StructWithOwner) -> Builtin.NativeObject {
+bb0(%0 : $StructWithOwner):
+  debug_value %0 : $StructWithOwner, let, name "x"
+  %1 = struct_extract %0 : $StructWithOwner, #StructWithOwner.owner
+  strong_retain %1 : $Builtin.NativeObject // expected-remark {{retain of type 'Builtin.NativeObject'}}
+                                           // expected-note @-3 {{of 'x.owner'}}
+  return %1 : $Builtin.NativeObject
+}
+
+// This case should never actually happen like this, but we should handle it in
+// a sane way by printing both notes for y and x and also make sure that we do
+// not infer .owner on y since y is on owner itself.
+sil @extract_out_singleobj_struct_subfield_multiple_debugvalue : $@convention(thin) (@guaranteed StructWithOwner) -> Builtin.NativeObject {
+bb0(%0 : $StructWithOwner):
+  debug_value %0 : $StructWithOwner, let, name "x"
+  %1 = struct_extract %0 : $StructWithOwner, #StructWithOwner.owner
+  debug_value %1 : $Builtin.NativeObject, let, name "y"
+  strong_retain %1 : $Builtin.NativeObject // expected-remark {{retain of type 'Builtin.NativeObject'}}
+                                           // expected-note @-4 {{of 'x.owner'}}
+                                           // expected-note @-3 {{of 'y'}}
+  return %1 : $Builtin.NativeObject
+}