Add debug info support for inlined and specialized generic variables.

This patch adds SIL-level debug info support for variables whose
static type is rewritten by an optimizer transformation. When a
function is (generic-)specialized or inlined, the static types of
inlined variables my change as they are remapped into the generic
environment of the inlined call site. With this patch all inlined
SILDebugScopes that point to functions with a generic signature are
recursively rewritten to point to clones of the original function with
new unique mangled names. The new mangled names consist of the old
mangled names plus the new substituions, similar (or exactly,
respectively) to how generic specialization is handled.

On libSwiftCore.dylib (x86_64), this yields a 17% increase in unique
source vars and a ~24% increase in variables with a debug location.

rdar://problem/28859432
rdar://problem/34526036

Author: adrian-prantl

docs/ABI/Mangling.rst

@@ -787,6 +787,7 @@ Function Specializations
 
   specialization ::= type '_' type* 'Tg' SPEC-INFO     // Generic re-abstracted specialization
   specialization ::= type '_' type* 'TG' SPEC-INFO     // Generic not re-abstracted specialization
+  specialization ::= type '_' type* 'Ti' SPEC-INFO     // Inlined function with generic substitutions.
 
 The types are the replacement types of the substitution list.
 

include/swift/AST/SubstitutionMap.h

@@ -153,7 +153,7 @@ class SubstitutionMap {
   /// existential.
   bool hasOpenedExistential() const;
 
-  /// Query whether any replacement type sin the map contain dynamic Self.
+  /// Query whether any replacement types in the map contain dynamic Self.
   bool hasDynamicSelf() const;
 
   /// Whether the replacement types are all canonical.

include/swift/Demangling/DemangleNodes.def

@@ -87,6 +87,7 @@ NODE(ResilientProtocolWitnessTable)
 NODE(GenericSpecialization)
 NODE(GenericSpecializationNotReAbstracted)
 NODE(GenericSpecializationParam)
+NODE(InlinedGenericFunction)
 NODE(GenericTypeMetadataPattern)
 CONTEXT_NODE(Getter)
 NODE(Global)

include/swift/SIL/TypeSubstCloner.h

@@ -24,6 +24,7 @@
 #include "swift/SIL/SILCloner.h"
 #include "swift/SIL/DynamicCasts.h"
 #include "swift/SILOptimizer/Utils/Local.h"
+#include "swift/SILOptimizer/Utils/SpecializationMangler.h"
 #include "llvm/Support/Debug.h"
 
 namespace swift {
@@ -277,6 +278,84 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
     super::visitDestroyValueInst(Destroy);
   }
 
+  /// One abstract function in the debug info can only have one set of variables
+  /// and types. This function determines whether applying the substitutions in
+  /// \p SubsMap on the generic signature \p Sig will change the generic type
+  /// parameters in the signature. This is used to decide whether it's necessary
+  /// to clone a unique copy of the function declaration with the substitutions
+  /// applied for the debug info.
+  static bool substitutionsChangeGenericTypeParameters(SubstitutionMap SubsMap,
+                                                       GenericSignature *Sig) {
+
+    // If there are no substitutions, just reuse
+    // the original decl.
+    if (SubsMap.empty())
+      return false;
+
+    auto Params = Sig->getSubstitutableParams();
+    return std::any_of(Params.begin(), Params.end(), [&](Type ParamType) {
+      Type Substitution = Type(ParamType).subst(SubsMap);
+      return !Substitution->isOpenedExistential() &&
+             (Substitution->getCanonicalType() !=
+              ParamType->getCanonicalType());
+    });
+  }
+
+  enum { ForInlining = true };
+  /// Helper function to clone the parent function of a SILDebugScope if
+  /// necessary when inlining said function into a new generic context.
+  /// \param SubsMap - the substitutions of the inlining/specialization process.
+  /// \param RemappedSig - the generic signature
+  static SILFunction *remapParentFunction(SILModule &M,
+                                          SILFunction *ParentFunction,
+                                          SubstitutionMap SubsMap,
+                                          GenericSignature *RemappedSig,
+                                          bool ForInlining = false) {
+    // If the original, non-inlined version of the function had no generic
+    // environment, there is no need to remap it.
+    auto *OriginalEnvironment = ParentFunction->getGenericEnvironment();
+    if (!RemappedSig || !OriginalEnvironment)
+      return ParentFunction;
+
+    if (SubsMap.hasArchetypes())
+      SubsMap = SubsMap.mapReplacementTypesOutOfContext();
+
+    if (!substitutionsChangeGenericTypeParameters(SubsMap, RemappedSig))
+      return ParentFunction;
+
+    // Clone the function with the substituted type for the debug info.
+    Mangle::GenericSpecializationMangler Mangler(
+        ParentFunction, SubsMap, IsNotSerialized, false, ForInlining);
+    std::string MangledName = Mangler.mangle(RemappedSig);
+
+    if (ParentFunction->getName() == MangledName)
+      return ParentFunction;
+    if (auto *CachedFn = M.lookUpFunction(MangledName))
+      ParentFunction = CachedFn;
+    else {
+      // Create a new function with this mangled name with an empty
+      // body. There won't be any IR generated for it (hence the linkage),
+      // but the symbol will be refered to by the debug info metadata.
+      ParentFunction = M.getOrCreateFunction(
+          ParentFunction->getLocation(), MangledName, SILLinkage::Shared,
+          ParentFunction->getLoweredFunctionType(), ParentFunction->isBare(),
+          ParentFunction->isTransparent(), ParentFunction->isSerialized(), 0,
+          ParentFunction->isThunk(), ParentFunction->getClassSubclassScope());
+      // Increment the ref count for the inlined function, so it doesn't
+      // get deleted before we can emit abstract debug info for it.
+      if (!ParentFunction->isZombie()) {
+        ParentFunction->setInlined();
+        // If the function was newly created with an empty body mark it as
+        // undead.
+        if (ParentFunction->empty()) {
+          M.eraseFunction(ParentFunction);
+          ParentFunction->setGenericEnvironment(OriginalEnvironment);
+        }
+      }
+    }
+    return ParentFunction;
+  }
+
   /// The Swift module that the cloned function belongs to.
   ModuleDecl *SwiftMod;
   /// The substitutions list for the specialization.
@@ -287,7 +366,7 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
   SILFunction &Original;
   /// True, if used for inlining.
   bool Inlining;
-};
+  };
 
 } // end namespace swift
 

include/swift/SILOptimizer/Utils/GenericCloner.h

@@ -34,6 +34,8 @@ class GenericCloner : public TypeSubstCloner<GenericCloner> {
   IsSerialized_t Serialized;
   const ReabstractionInfo &ReInfo;
   CloneCollector::CallbackType Callback;
+  llvm::SmallDenseMap<const SILDebugScope *, const SILDebugScope *, 8>
+      RemappedScopeCache;
 
 public:
   friend class SILCloner<GenericCloner>;
@@ -90,6 +92,9 @@ class GenericCloner : public TypeSubstCloner<GenericCloner> {
   /// by initCloned.
   void populateCloned();
   SILFunction *getCloned() { return &getBuilder().getFunction(); }
+
+  const SILDebugScope *remapScope(const SILDebugScope *DS);
+
 };
 
 } // end namespace swift

include/swift/SILOptimizer/Utils/SpecializationMangler.h

@@ -48,7 +48,8 @@ class SpecializationMangler : public Mangle::ASTMangler {
 protected:
   SpecializationMangler(SpecializationPass P, IsSerialized_t Serialized,
                         SILFunction *F)
-      : Pass(P), Serialized(Serialized), Function(F), ArgOpBuffer(ArgOpStorage) {}
+      : Pass(P), Serialized(Serialized), Function(F),
+        ArgOpBuffer(ArgOpStorage) {}
 
   SILFunction *getFunction() const { return Function; }
 
@@ -67,17 +68,17 @@ class GenericSpecializationMangler : public SpecializationMangler {
 
   SubstitutionMap SubMap;
   bool isReAbstracted;
+  bool isInlined;
 
 public:
-
-  GenericSpecializationMangler(SILFunction *F,
-                               SubstitutionMap SubMap,
-                               IsSerialized_t Serialized,
-                               bool isReAbstracted)
-    : SpecializationMangler(SpecializationPass::GenericSpecializer, Serialized, F),
-      SubMap(SubMap), isReAbstracted(isReAbstracted) {}
-
-  std::string mangle();
+  GenericSpecializationMangler(SILFunction *F, SubstitutionMap SubMap,
+                               IsSerialized_t Serialized, bool isReAbstracted,
+                               bool isInlined = false)
+      : SpecializationMangler(SpecializationPass::GenericSpecializer,
+                              Serialized, F),
+        SubMap(SubMap), isReAbstracted(isReAbstracted), isInlined(isInlined) {}
+
+  std::string mangle(GenericSignature *Sig = nullptr);
 };
 
 class PartialSpecializationMangler : public SpecializationMangler {
@@ -88,10 +89,10 @@ class PartialSpecializationMangler : public SpecializationMangler {
 public:
   PartialSpecializationMangler(SILFunction *F,
                                CanSILFunctionType SpecializedFnTy,
-                               IsSerialized_t Serialized,
-                               bool isReAbstracted)
-    : SpecializationMangler(SpecializationPass::GenericSpecializer, Serialized, F),
-      SpecializedFnTy(SpecializedFnTy), isReAbstracted(isReAbstracted) {}
+                               IsSerialized_t Serialized, bool isReAbstracted)
+      : SpecializationMangler(SpecializationPass::GenericSpecializer,
+                              Serialized, F),
+        SpecializedFnTy(SpecializedFnTy), isReAbstracted(isReAbstracted) {}
 
   std::string mangle();
 };

lib/Demangling/Demangler.cpp

@@ -1734,11 +1734,13 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
       Thunk = addChild(Thunk, popNode(Node::Kind::Type));
       return addChild(Thunk, Ty2);
     }
-    case'g':
+    case 'g':
       return demangleGenericSpecialization(Node::Kind::GenericSpecialization);
-    case'G':
+    case 'G':
       return demangleGenericSpecialization(Node::Kind::
                                           GenericSpecializationNotReAbstracted);
+    case 'i':
+      return demangleGenericSpecialization(Node::Kind::InlinedGenericFunction);
     case'p': {
       NodePointer Spec = demangleSpecAttributes(Node::Kind::
                                                 GenericPartialSpecialization);
@@ -1869,7 +1871,8 @@ NodePointer Demangler::demangleGenericSpecialization(Node::Kind SpecKind) {
   if (!TyList)
     return nullptr;
   for (NodePointer Ty : *TyList) {
-    Spec->addChild(createWithChild(Node::Kind::GenericSpecializationParam, Ty), *this);
+    Spec->addChild(createWithChild(Node::Kind::GenericSpecializationParam, Ty),
+                   *this);
   }
   return Spec;
 }

lib/Demangling/NodePrinter.cpp

@@ -351,6 +351,7 @@ class NodePrinter {
     case Node::Kind::GenericSpecialization:
     case Node::Kind::GenericSpecializationNotReAbstracted:
     case Node::Kind::GenericSpecializationParam:
+    case Node::Kind::InlinedGenericFunction:
     case Node::Kind::GenericTypeMetadataPattern:
     case Node::Kind::Getter:
     case Node::Kind::Global:
@@ -1183,6 +1184,9 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::GenericSpecializationNotReAbstracted:
     printSpecializationPrefix(Node, "generic not re-abstracted specialization");
     return nullptr;
+  case Node::Kind::InlinedGenericFunction:
+    printSpecializationPrefix(Node, "inlined generic function");
+    return nullptr;
   case Node::Kind::SpecializationIsFragile:
     Printer << "preserving fragile attribute";
     return nullptr;

lib/Demangling/OldRemangler.cpp

@@ -534,6 +534,7 @@ void Remangler::mangleGenericSpecialization(Node *node) {
   // Start another mangled name.
   Out << "__T";
 }
+
 void Remangler::mangleGenericSpecializationNotReAbstracted(Node *node) {
   Out << "TSr";
   mangleChildNodes(node); // GenericSpecializationParams
@@ -545,6 +546,17 @@ void Remangler::mangleGenericSpecializationNotReAbstracted(Node *node) {
   Out << "__T";
 }
 
+void Remangler::mangleInlinedGenericFunction(Node *node) {
+  Out << "TSi";
+  mangleChildNodes(node); // GenericSpecializationParams
+
+  // Specializations are just prepended to already-mangled names.
+  resetSubstitutions();
+
+  // Start another mangled name.
+  Out << "__T";
+}
+
 void Remangler::mangleGenericPartialSpecialization(Node *node) {
   unreachable("todo");
 }

lib/Demangling/Remangler.cpp

@@ -1122,8 +1122,20 @@ void Remangler::mangleGenericSpecialization(Node *node) {
   }
   assert(!FirstParam && "generic specialization with no substitutions");
 
-  Buffer << (node->getKind() ==
-               Node::Kind::GenericSpecializationNotReAbstracted ? "TG" : "Tg");
+  switch (node->getKind()) {
+  case Node::Kind::GenericSpecialization:
+    Buffer << "Tg";
+    break;
+  case Node::Kind::GenericSpecializationNotReAbstracted:
+    Buffer << "TG";
+    break;
+  case Node::Kind::InlinedGenericFunction:
+    Buffer << "Ti";
+    break;
+ default:
+   unreachable("unsupported node");
+  }
+
   for (NodePointer Child : *node) {
     if (Child->getKind() != Node::Kind::GenericSpecializationParam)
       mangle(Child);
@@ -1134,6 +1146,11 @@ void Remangler::mangleGenericSpecializationNotReAbstracted(Node *node) {
   mangleGenericSpecialization(node);
 }
 
+void Remangler::mangleInlinedGenericFunction(Node *node) {
+  mangleGenericSpecialization(node);
+}
+
+
 void Remangler::mangleGenericSpecializationParam(Node *node) {
   unreachable("handled inline");
 }
@@ -1161,6 +1178,7 @@ void Remangler::mangleGlobal(Node *node) {
       case Node::Kind::FunctionSignatureSpecialization:
       case Node::Kind::GenericSpecialization:
       case Node::Kind::GenericSpecializationNotReAbstracted:
+      case Node::Kind::InlinedGenericFunction:
       case Node::Kind::GenericPartialSpecialization:
       case Node::Kind::GenericPartialSpecializationNotReAbstracted:
       case Node::Kind::OutlinedBridgedMethod: