[opt-remark] Add remarks for casts that go through the runtime and aren't optimized away.

Now we get opt-remarks like the following:

```
public func condCast5<NS, T>(_ ns: NS) -> T? {
  // Make sure the colon info is right so that the arrow is under the a.
  //
  // Today, we lose that x was assigned.
  if let x = ns as? T {  // expected-remark @:17 {{conditional runtime cast of value with type 'NS' to 'T'}}
    return x             // expected-note @-5:32 {{of 'ns'}}
  }
  return nil
}
```

Author: gottesmm

lib/SILOptimizer/Transforms/OptRemarkGenerator.cpp

@@ -19,8 +19,10 @@
 
 #define DEBUG_TYPE "sil-opt-remark-gen"
 
-#include "swift/Basic/Defer.h"
 #include "swift/AST/SemanticAttrs.h"
+#include "swift/Basic/Defer.h"
+#include "swift/SIL/DebugUtils.h"
+#include "swift/SIL/DynamicCasts.h"
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/OptimizationRemark.h"
 #include "swift/SIL/Projection.h"
@@ -244,19 +246,20 @@ bool ValueUseToDeclInferrer::findDecls(Operand *use, SILValue value) {
   // Then see if we have a debug_value that is associated with a non-inlined
   // debug scope. Such an instruction is an instruction that is from the
   // current function.
-  auto *dvi = dyn_cast<DebugValueInst>(use->getUser());
-  if (!dvi)
+  auto debugInst = DebugVarCarryingInst(use->getUser());
+  if (!debugInst)
     return false;
 
-  if (!hasNonInlinedDebugScope(dvi))
+  LLVM_DEBUG(llvm::dbgs() << "Found DebugInst: " << **debugInst);
+  if (!hasNonInlinedDebugScope(*debugInst))
     return false;
 
   // See if we have already inferred this debug_value as a potential source
   // for this instruction. In such a case, just return.
-  if (!visitedDebugValueInsts.insert(dvi).second)
+  if (!visitedDebugValueInsts.insert(*debugInst).second)
     return false;
 
-  if (auto *decl = dvi->getDecl()) {
+  if (auto *decl = debugInst.getDecl()) {
     std::string msg;
     {
       llvm::raw_string_ostream stream(msg);
@@ -279,7 +282,7 @@ bool ValueUseToDeclInferrer::findDecls(Operand *use, SILValue value) {
   if (!DecllessDebugValueUseSILDebugInfo)
     return false;
 
-  auto varInfo = dvi->getVarInfo();
+  auto varInfo = debugInst.getVarInfo();
   if (!varInfo)
     return false;
 
@@ -293,8 +296,8 @@ bool ValueUseToDeclInferrer::findDecls(Operand *use, SILValue value) {
     object.printNote(stream, name,
                      use->get() == value /*print projection path*/);
   }
-  resultingInferredDecls.push_back(
-      Argument({keyKind, "InferredValue"}, std::move(msg), dvi->getLoc()));
+  resultingInferredDecls.push_back(Argument(
+      {keyKind, "InferredValue"}, std::move(msg), debugInst->getLoc()));
   return true;
 }
 
@@ -315,7 +318,10 @@ bool ValueToDeclInferrer::infer(
   // 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.
+  LLVM_DEBUG(llvm::dbgs() << "Searching for decls!\n");
   while (true) {
+    LLVM_DEBUG(llvm::dbgs() << "Visiting: " << *value);
+
     // First check for "identified values" like arguments and global_addr.
     if (auto *arg = dyn_cast<SILArgument>(value))
       if (auto *decl = arg->getDecl()) {
@@ -368,6 +374,10 @@ bool ValueToDeclInferrer::infer(
       }
     }
 
+    // We prefer decls not from uses since these are inherently noisier. Still,
+    // it is better than nothing.
+    bool foundDeclFromUse = false;
+
     if (auto *asi = dyn_cast<AllocStackInst>(value)) {
       if (auto *decl = asi->getDecl()) {
         std::string msg;
@@ -379,6 +389,23 @@ bool ValueToDeclInferrer::infer(
             Argument({keyKind, "InferredValue"}, std::move(msg), decl));
         return true;
       }
+
+      // See if we have a single init alloc_stack and can infer a
+      // debug_value/debug_value_addr from that.
+      LLVM_DEBUG(llvm::dbgs() << "Checking for single init use!\n");
+      if (auto *initUse = getSingleInitAllocStackUse(asi)) {
+        LLVM_DEBUG(llvm::dbgs() << "Found one: " << *initUse->getUser());
+        if (auto *si = dyn_cast<StoreInst>(initUse->getUser())) {
+          for (auto *use : si->getSrc()->getUses()) {
+            foundDeclFromUse |= valueUseInferrer.findDecls(use, value);
+          }
+        }
+        if (auto *cai = dyn_cast<CopyAddrInst>(initUse->getUser())) {
+          for (auto *use : cai->getSrc()->getUses()) {
+            foundDeclFromUse |= valueUseInferrer.findDecls(use, value);
+          }
+        }
+      }
     }
 
     // Then visit our users (ignoring rc identical transformations) and see if
@@ -388,7 +415,6 @@ bool ValueToDeclInferrer::infer(
     // The reason why we do this is that sometimes we reform a struct from its
     // constituant parts and then construct the debug_value from that. For
     // instance, if we FSOed.
-    bool foundDeclFromUse = false;
     rcfi.visitRCUses(value, [&](Operand *use) {
       foundDeclFromUse |= valueUseInferrer.findDecls(use, value);
     });
@@ -460,10 +486,58 @@ struct OptRemarkGeneratorInstructionVisitor
   void visitSILInstruction(SILInstruction *) {}
   void visitBeginAccessInst(BeginAccessInst *bai);
   void visitEndAccessInst(EndAccessInst *eai);
+  void visitCheckedCastAddrBranchInst(CheckedCastAddrBranchInst *ccabi);
+  void visitUnconditionalCheckedCastAddrInst(
+      UnconditionalCheckedCastAddrInst *uccai);
 };
 
 } // anonymous namespace
 
+void OptRemarkGeneratorInstructionVisitor::
+    visitUnconditionalCheckedCastAddrInst(
+        UnconditionalCheckedCastAddrInst *uccai) {
+  ORE.emit([&]() {
+    using namespace OptRemark;
+    SmallVector<Argument, 8> inferredArgs;
+    bool foundArgs = valueToDeclInferrer.infer(
+        ArgumentKeyKind::Note, uccai->getSrc(), inferredArgs,
+        true /*allow single ref elt peek*/);
+    (void)foundArgs;
+
+    // Use the actual source loc of the
+    auto remark = RemarkMissed("memory", *uccai)
+                  << "unconditional runtime cast of value with type '"
+                  << NV("ValueType", uccai->getSrc()->getType()) << "' to '"
+                  << NV("CastType", uccai->getDest()->getType()) << "'";
+    for (auto arg : inferredArgs) {
+      remark << arg;
+    }
+    return remark;
+  });
+}
+
+void OptRemarkGeneratorInstructionVisitor::visitCheckedCastAddrBranchInst(
+    CheckedCastAddrBranchInst *ccabi) {
+  ORE.emit([&]() {
+    using namespace OptRemark;
+    SmallVector<Argument, 8> inferredArgs;
+    bool foundArgs = valueToDeclInferrer.infer(
+        ArgumentKeyKind::Note, ccabi->getSrc(), inferredArgs,
+        true /*allow single ref elt peek*/);
+    (void)foundArgs;
+
+    // Use the actual source loc of the
+    auto remark = RemarkMissed("memory", *ccabi)
+                  << "conditional runtime cast of value with type '"
+                  << NV("ValueType", ccabi->getSrc()->getType()) << "' to '"
+                  << NV("CastType", ccabi->getDest()->getType()) << "'";
+    for (auto arg : inferredArgs) {
+      remark << arg;
+    }
+    return remark;
+  });
+}
+
 void OptRemarkGeneratorInstructionVisitor::visitBeginAccessInst(
     BeginAccessInst *bai) {
   ORE.emit([&]() {