Merge pull request #18366 from adrian-prantl/28859432

 Add debug info support for inlined and specialized generic variables.

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

@@ -23,7 +23,9 @@
 #include "swift/AST/Type.h"
 #include "swift/SIL/SILCloner.h"
 #include "swift/SIL/DynamicCasts.h"
+#include "swift/SIL/SILFunctionBuilder.h"
 #include "swift/SILOptimizer/Utils/Local.h"
+#include "swift/SILOptimizer/Utils/SpecializationMangler.h"
 #include "llvm/Support/Debug.h"
 
 namespace swift {
@@ -277,6 +279,92 @@ 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) {
+      // FIXME: It would be more elegant to run
+      // SubsMap.mapReplacementTypesOutOfContext() bup front, but it can assert.
+      Type Substitution = Type(ParamType).subst(SubsMap)->mapTypeOutOfContext();
+      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 (!substitutionsChangeGenericTypeParameters(SubsMap, RemappedSig))
+      return ParentFunction;
+
+    if (SubsMap.hasArchetypes())
+      SubsMap = SubsMap.mapReplacementTypesOutOfContext();
+
+    // This is a bug in mapReplacementTypesOutOfContext(). Archetypes can't be
+    // mangled, only type parameters can; ignore this for now.
+    if (SubsMap.hasArchetypes())
+      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.
+      SILFunctionBuilder B(M);
+      ParentFunction = B.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 +375,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: