[move-function] Add a new pass that propagates debug_value [moved] into coroutine func-lets.

NOTE: debug_value [moved] appearing in the source code implies a _move was
used. So this will not effect current stable swift code.

This is just a first version of this that I am using to commit/bring up tests
for IRGen supporting a full dataflow version of this patch.

Big picture is that there is a bunch of work that is done in the LLVM level in
the coroutine splitter to work around communicating live variables in the
various coroutine func-lets. This logic is all done with debug.declare and we
would need to update that logic in the coroutine splitter to handle
debug.addr. Rather than do this, after some conversation, AdrianP and I realized
that we could get the same effect of a debug.declare by just redeclaring the
current live set of debug_value after each possible coroutine funclet start. To
do this in full generality, we need a full dataflow but just to bring this up we
initially perform a dominance propagation algorithm of the following sort:

1. We walk the CFG along successors. By doing this we guarantee that we visit
   blocks after their dominators.

2. When we visit a block, we walk the block from start->end. During this walk:

   a. We grab a new block state from the centralized block->blockState map. This
      state is a [SILDebugVariable : DebugValueInst].

   b. If we see a debug_value, we map blockState[debug_value.getDbgVar()] =
      debug_value. This ensures that when we get to the bottom of the block, we
      have pairs of SILDebugVariable + last debug_value on it.

   c. If we see any coroutine funclet boundaries, we clone the current tracked
      set of our block state and then walk up the dom tree dumping in each block
      any debug_value with a SILDebugVariable that we have not already
      dumped. This is maintained by using a visited set of SILDebugVariable for
      each funclet boundary.

The end result is that at the beginning of each funclet we will basically
declare the debug info for an addr.

This is insufficient of course for moves that are in conditional control flow,
e.x.:

```
let x = Klass()
if boolValue {
  await asyncCall()
  let _ = _move(x)
}
```

but this at least lets me begin to write tests for this in lldb using straight
line code and work out the rest of the issues in CodeGen using those tests.

Author: gottesmm

include/swift/SIL/SILDebugInfoExpression.h

@@ -20,6 +20,7 @@
 #include "swift/AST/Decl.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/raw_ostream.h"
@@ -109,6 +110,12 @@ struct SILDIExprElement {
   }
 };
 
+/// Returns the hashcode for the di expr element.
+inline llvm::hash_code hash_value(const SILDIExprElement &elt) {
+  return llvm::hash_combine(elt.getKind(), elt.getAsDecl(), elt.getAsDecl(),
+                            elt.getAsConstInt());
+}
+
 /// For a given SILDIExprOperator, provides information
 /// like its textual name and operand types.
 struct SILDIExprInfo {
@@ -273,5 +280,11 @@ class SILDebugInfoExpression {
             SILDIExprOperator::Fragment;
   }
 };
+
+/// Returns the hashcode for the di expr element.
+inline llvm::hash_code hash_value(const SILDebugInfoExpression &elt) {
+  return llvm::hash_combine_range(elt.element_begin(), elt.element_end());
+}
+
 } // end namespace swift
 #endif

include/swift/SIL/SILDebugVariable.h

@@ -23,14 +23,23 @@ namespace swift {
 
 class AllocationInst;
 
+/// Holds common debug information about local variables and function
+/// arguments that are needed by DebugValueInst, AllocStackInst,
+/// and AllocBoxInst.
+struct SILDebugVariable;
+inline llvm::hash_code hash_value(const SILDebugVariable &P);
+
 /// Holds common debug information about local variables and function
 /// arguments that are needed by DebugValueInst, AllocStackInst,
 /// and AllocBoxInst.
 struct SILDebugVariable {
+  friend llvm::hash_code hash_value(const SILDebugVariable &P);
+
   StringRef Name;
   unsigned ArgNo : 16;
   unsigned Constant : 1;
   unsigned Implicit : 1;
+  unsigned isDenseMapSingleton : 2;
   Optional<SILType> Type;
   Optional<SILLocation> Loc;
   const SILDebugScope *Scope;
@@ -40,26 +49,41 @@ struct SILDebugVariable {
   SILDebugVariable(const SILDebugVariable &) = default;
   SILDebugVariable &operator=(const SILDebugVariable &) = default;
 
+  enum class IsDenseMapSingleton { No, IsEmpty, IsTombstone };
+  SILDebugVariable(IsDenseMapSingleton inputIsDenseMapSingleton)
+      : SILDebugVariable() {
+    assert(inputIsDenseMapSingleton != IsDenseMapSingleton::No &&
+           "Should only pass IsEmpty or IsTombstone");
+    isDenseMapSingleton = unsigned(inputIsDenseMapSingleton);
+  }
+
   SILDebugVariable()
-      : ArgNo(0), Constant(false), Implicit(false), Scope(nullptr) {}
+      : ArgNo(0), Constant(false), Implicit(false), isDenseMapSingleton(0),
+        Scope(nullptr) {}
   SILDebugVariable(bool Constant, uint16_t ArgNo)
-      : ArgNo(ArgNo), Constant(Constant), Implicit(false), Scope(nullptr) {}
+      : ArgNo(ArgNo), Constant(Constant), Implicit(false),
+        isDenseMapSingleton(0), Scope(nullptr) {}
   SILDebugVariable(StringRef Name, bool Constant, unsigned ArgNo,
                    bool IsImplicit = false, Optional<SILType> AuxType = {},
                    Optional<SILLocation> DeclLoc = {},
                    const SILDebugScope *DeclScope = nullptr,
                    llvm::ArrayRef<SILDIExprElement> ExprElements = {})
       : Name(Name), ArgNo(ArgNo), Constant(Constant), Implicit(IsImplicit),
-        Type(AuxType), Loc(DeclLoc), Scope(DeclScope), DIExpr(ExprElements) {}
+        isDenseMapSingleton(0), Type(AuxType), Loc(DeclLoc), Scope(DeclScope),
+        DIExpr(ExprElements) {}
 
   /// Created from either AllocStack or AllocBox instruction
   static Optional<SILDebugVariable>
   createFromAllocation(const AllocationInst *AI);
 
-  bool operator==(const SILDebugVariable &V) {
+  // We're not comparing DIExpr here because strictly speaking,
+  // DIExpr is not part of the debug variable. We simply piggyback
+  // it in this class so that's it's easier to carry DIExpr around.
+  bool operator==(const SILDebugVariable &V) const {
     return ArgNo == V.ArgNo && Constant == V.Constant && Name == V.Name &&
            Implicit == V.Implicit && Type == V.Type && Loc == V.Loc &&
-           Scope == V.Scope && DIExpr == V.DIExpr;
+           Scope == V.Scope && isDenseMapSingleton == V.isDenseMapSingleton &&
+           DIExpr == V.DIExpr;
   }
 
   SILDebugVariable withoutDIExpr() const {
@@ -73,6 +97,13 @@ struct SILDebugVariable {
   bool isVar() const { return Name.size() && !Constant; }
 };
 
+/// Returns the hashcode for the new projection path.
+inline llvm::hash_code hash_value(const SILDebugVariable &P) {
+  return llvm::hash_combine(P.ArgNo, P.Constant, P.Name, P.Implicit,
+                            P.isDenseMapSingleton, P.Type, P.Loc, P.Scope,
+                            P.DIExpr);
+}
+
 } // namespace swift
 
 #endif

include/swift/SIL/SILInstruction.h

@@ -9863,6 +9863,19 @@ struct ilist_traits<::swift::SILInstruction> :
   void createNode(const SILInstruction &);
 };
 
+template <>
+struct DenseMapInfo<swift::SILDebugVariable> {
+  using KeyTy = swift::SILDebugVariable;
+  static inline KeyTy getEmptyKey() {
+    return KeyTy(KeyTy::IsDenseMapSingleton::IsEmpty);
+  }
+  static inline KeyTy getTombstoneKey() {
+    return KeyTy(KeyTy::IsDenseMapSingleton::IsTombstone);
+  }
+  static unsigned getHashValue(const KeyTy &Val) { return hash_value(Val); }
+  static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) { return LHS == RHS; }
+};
+
 } // end llvm namespace
 
 #endif

include/swift/SIL/SILLocation.h

@@ -72,8 +72,10 @@ class SILLocation {
       return line == rhs.line && column == rhs.column &&
              filename.equals(rhs.filename);
     }
+
     void dump() const;
     void print(raw_ostream &OS) const;
+    friend llvm::hash_code hash_value(const FilenameAndLocation &);
   };
 
 protected:
@@ -431,8 +433,19 @@ class SILLocation {
   }
 
   inline bool operator!=(const SILLocation &R) const { return !(*this == R); }
+
+  friend llvm::hash_code hash_value(const SILLocation &);
 };
 
+inline llvm::hash_code hash_value(const SILLocation &R) {
+  return llvm::hash_combine(R.kindAndFlags.packedKindAndFlags,
+                            *R.storage.filePositionLoc);
+}
+
+inline llvm::hash_code hash_value(const SILLocation::FilenameAndLocation &R) {
+  return llvm::hash_combine(R.line, R.column, R.filename);
+}
+
 /// Allowed on any instruction.
 class RegularLocation : public SILLocation {
 public:

include/swift/SILOptimizer/PassManager/Passes.def

@@ -436,6 +436,8 @@ PASS(MoveKillsCopyableAddressesChecker, "sil-move-kills-copyable-addresses-check
 PASS(MoveFunctionCanonicalization, "sil-move-function-canon",
      "Pass that canonicalizes certain parts of the IR before we perform move "
      "function checking.")
+PASS(DebugInfoCanonicalizer, "sil-onone-debuginfo-canonicalizer",
+     "Canonicalize debug info at -Onone by propagating debug info into coroutine funclets")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -5,6 +5,7 @@ target_sources(swiftSILOptimizer PRIVATE
   CapturePromotion.cpp
   ClosureLifetimeFixup.cpp
   ConstantPropagation.cpp
+  DebugInfoCanonicalizer.cpp
   DefiniteInitialization.cpp
   DIMemoryUseCollector.cpp
   DataflowDiagnostics.cpp