Merge pull request #41944 from gottesmm/add_initial_dominance_impl

[move-function] Add initial support for moved lets over async funclet edges

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)