Merge pull request #34986 from eeckstein/fix-generic-spec

GenericSpecializer: use an alternative mangling if the function has re-abstracted resilient type parameters.

Author: eeckstein

docs/ABI/Mangling.rst

@@ -1008,6 +1008,8 @@ Function Specializations
 ::
 
   specialization ::= type '_' type* 'Tg' SPEC-INFO     // Generic re-abstracted specialization
+  specialization ::= type '_' type* 'TB' SPEC-INFO     // Alternative mangling for generic re-abstracted specializations,
+                                                       // used for functions with re-abstracted resilient parameter types.
   specialization ::= type '_' type* 'Ts' SPEC-INFO     // Generic re-abstracted prespecialization
   specialization ::= type '_' type* 'TG' SPEC-INFO     // Generic not re-abstracted specialization
   specialization ::= type '_' type* 'Ti' SPEC-INFO     // Inlined function with generic substitutions.

include/swift/AST/TypeExpansionContext.h

@@ -89,6 +89,10 @@ class TypeExpansionContext {
       other.expansion == this->expansion;
   }
 
+  bool operator!=(const TypeExpansionContext &other) const {
+    return !operator==(other);
+  }
+
   bool operator<(const TypeExpansionContext other) const {
     assert(other.inContext != this->inContext ||
            other.isContextWholeModule == this->isContextWholeModule);

include/swift/Demangling/DemangleNodes.def

@@ -104,6 +104,7 @@ NODE(GenericProtocolWitnessTableInstantiationFunction)
 NODE(ResilientProtocolWitnessTable)
 NODE(GenericSpecialization)
 NODE(GenericSpecializationNotReAbstracted)
+NODE(GenericSpecializationInResilienceDomain)
 NODE(GenericSpecializationParam)
 NODE(GenericSpecializationPrespecialized)
 NODE(InlinedGenericFunction)

include/swift/SIL/GenericSpecializationMangler.h

@@ -69,31 +69,36 @@ class SpecializationMangler : public Mangle::ASTMangler {
 // The mangler for specialized generic functions.
 class GenericSpecializationMangler : public SpecializationMangler {
 
-  SubstitutionMap SubMap;
-  bool isReAbstracted;
-  bool isInlined;
-  bool isPrespecializaton;
+  GenericSpecializationMangler(std::string origFuncName)
+      : SpecializationMangler(SpecializationPass::GenericSpecializer,
+                              IsNotSerialized, origFuncName) {}
+
+  GenericSignature getGenericSignature() {
+    assert(Function && "Need a SIL function to get a generic signature");
+    return Function->getLoweredFunctionType()->getInvocationGenericSignature();
+  }
+
+  void appendSubstitutions(GenericSignature sig, SubstitutionMap subs);
+
+  std::string manglePrespecialized(GenericSignature sig,
+                                      SubstitutionMap subs);
 
 public:
-  GenericSpecializationMangler(SILFunction *F, SubstitutionMap SubMap,
-                               IsSerialized_t Serialized, bool isReAbstracted,
-                               bool isInlined = false,
-                               bool isPrespecializaton = false)
+  GenericSpecializationMangler(SILFunction *F, IsSerialized_t Serialized)
       : SpecializationMangler(SpecializationPass::GenericSpecializer,
-                              Serialized, F),
-        SubMap(SubMap), isReAbstracted(isReAbstracted), isInlined(isInlined),
-        isPrespecializaton(isPrespecializaton) {}
+                              Serialized, F) {}
 
-  GenericSpecializationMangler(std::string origFuncName, SubstitutionMap SubMap)
-      : SpecializationMangler(SpecializationPass::GenericSpecializer,
-                              IsNotSerialized, origFuncName),
-        SubMap(SubMap), isReAbstracted(true), isInlined(false),
-        isPrespecializaton(true) {}
+  std::string mangleNotReabstracted(SubstitutionMap subs);
 
-  std::string mangle(GenericSignature Sig = GenericSignature());
+  std::string mangleReabstracted(SubstitutionMap subs, bool alternativeMangling);
 
-  // TODO: This utility should move from the libswiftSILOptimizer to
-  // libswiftSIL.
+  std::string mangleForDebugInfo(GenericSignature sig, SubstitutionMap subs,
+                                 bool forInlining);
+
+  std::string manglePrespecialized(SubstitutionMap subs) {
+    return manglePrespecialized(getGenericSignature(), subs);
+  }
+                                    
   static std::string manglePrespecialization(std::string unspecializedName,
                                              GenericSignature genericSig,
                                              GenericSignature specializedSig);

include/swift/SIL/TypeSubstCloner.h

@@ -428,9 +428,10 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
       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);
+    Mangle::GenericSpecializationMangler Mangler(ParentFunction,
+                                                 IsNotSerialized);
+    std::string MangledName =
+      Mangler.mangleForDebugInfo(RemappedSig, SubsMap, ForInlining);
 
     if (ParentFunction->getName() == MangledName)
       return ParentFunction;

include/swift/SILOptimizer/Utils/Generics.h

@@ -61,6 +61,19 @@ class ReabstractionInfo {
   /// argument has a trivial type.
   SmallBitVector TrivialArgs;
 
+  /// Set to true if the function has a re-abstracted (= converted from
+  /// indirect to direct) resilient argument or return type. This can happen if
+  /// the function is compiled within the type's resilience domain, i.e. in
+  /// its module (where the type is loadable).
+  /// In this case we need to generate a different mangled name for the
+  /// function to distinguish it from functions in other modules, which cannot
+  /// re-abstract this resilient type.
+  /// Fortunately, a flag is sufficient to describe this: either a function has
+  /// re-abstracted resilient types or not. It cannot happen that two
+  /// functions have two different subsets of re-abstracted resilient parameter
+  /// types.
+  bool hasConvertedResilientParams = false;
+
   /// If set, indirect to direct conversions should be performed by the generic
   /// specializer.
   bool ConvertIndirectToDirect;
@@ -128,6 +141,12 @@ class ReabstractionInfo {
   // Is the generated specialization going to be serialized?
   IsSerialized_t Serialized;
 
+  enum TypeCategory {
+    NotLoadable,
+    Loadable,
+    LoadableAndTrivial
+  };
+  
   unsigned param2ArgIndex(unsigned ParamIdx) const  {
     return ParamIdx + NumFormalIndirectResults;
   }
@@ -138,6 +157,15 @@ class ReabstractionInfo {
                                            bool HasUnboundGenericParams);
 
   void createSubstitutedAndSpecializedTypes();
+  
+  TypeCategory getReturnTypeCategory(const SILResultInfo &RI,
+                                     const SILFunctionConventions &substConv,
+                                     TypeExpansionContext typeExpansion);
+
+  TypeCategory getParamTypeCategory(const SILParameterInfo &PI,
+                                    const SILFunctionConventions &substConv,
+                                    TypeExpansionContext typeExpansion);
+
   bool prepareAndCheck(ApplySite Apply, SILFunction *Callee,
                        SubstitutionMap ParamSubs,
                        OptRemark::Emitter *ORE = nullptr);
@@ -175,6 +203,12 @@ class ReabstractionInfo {
   IsSerialized_t isSerialized() const {
     return Serialized;
   }
+  
+  /// Returns true if the specialized function needs an alternative mangling.
+  /// See hasConvertedResilientParams.
+  bool needAlternativeMangling() const {
+    return hasConvertedResilientParams;
+  }
 
   TypeExpansionContext getResilienceExpansion() const {
     auto resilience = (Serialized ? ResilienceExpansion::Minimal

lib/Demangling/Demangler.cpp

@@ -108,6 +108,7 @@ bool swift::Demangle::isFunctionAttr(Node::Kind kind) {
     case Node::Kind::GenericSpecializationNotReAbstracted:
     case Node::Kind::GenericPartialSpecialization:
     case Node::Kind::GenericPartialSpecializationNotReAbstracted:
+    case Node::Kind::GenericSpecializationInResilienceDomain:
     case Node::Kind::ObjCAttribute:
     case Node::Kind::NonObjCAttribute:
     case Node::Kind::DynamicAttribute:
@@ -2317,6 +2318,9 @@ NodePointer Demangler::popProtocolConformance() {
     case 'G':
       return demangleGenericSpecialization(Node::Kind::
                                           GenericSpecializationNotReAbstracted);
+    case 'B':
+      return demangleGenericSpecialization(Node::Kind::
+                                      GenericSpecializationInResilienceDomain);
     case 's':
       return demangleGenericSpecialization(
           Node::Kind::GenericSpecializationPrespecialized);

lib/Demangling/NodePrinter.cpp

@@ -388,6 +388,7 @@ class NodePrinter {
     case Node::Kind::GenericPartialSpecializationNotReAbstracted:
     case Node::Kind::GenericSpecialization:
     case Node::Kind::GenericSpecializationNotReAbstracted:
+    case Node::Kind::GenericSpecializationInResilienceDomain:
     case Node::Kind::GenericSpecializationParam:
     case Node::Kind::GenericSpecializationPrespecialized:
     case Node::Kind::InlinedGenericFunction:
@@ -1415,6 +1416,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
             "generic not-reabstracted partial specialization", "Signature = ");
     return nullptr;
   case Node::Kind::GenericSpecialization:
+  case Node::Kind::GenericSpecializationInResilienceDomain:
     printSpecializationPrefix(Node, "generic specialization");
     return nullptr;
   case Node::Kind::GenericSpecializationPrespecialized:

lib/Demangling/OldRemangler.cpp

@@ -369,6 +369,9 @@ void Remangler::mangleGenericSpecializationPrespecialized(Node *node) {
 void Remangler::mangleGenericSpecializationNotReAbstracted(Node *node) {
   unreachable("unsupported");
 }
+void Remangler::mangleGenericSpecializationInResilienceDomain(Node *node) {
+  unreachable("unsupported");
+}
 
 void Remangler::mangleInlinedGenericFunction(Node *node) {
   unreachable("unsupported");

lib/Demangling/Remangler.cpp

@@ -300,6 +300,7 @@ class Remangler : public RemanglerBase {
     mangleChildNodesReversed(FuncType);
   }
 
+  void mangleGenericSpecializationNode(Node *node, const char *operatorStr);
   void mangleAnyNominalType(Node *node);
   void mangleAnyGenericType(Node *node, StringRef TypeOp);
   void mangleGenericArgs(Node *node, char &Separator,
@@ -1298,7 +1299,8 @@ void Remangler::mangleGenericPartialSpecializationNotReAbstracted(Node *node) {
   mangleGenericPartialSpecialization(node);
 }
 
-void Remangler::mangleGenericSpecialization(Node *node) {
+void Remangler::
+mangleGenericSpecializationNode(Node *node, const char *operatorStr) {
   bool FirstParam = true;
   for (NodePointer Child : *node) {
     if (Child->getKind() == Node::Kind::GenericSpecializationParam) {
@@ -1308,39 +1310,32 @@ void Remangler::mangleGenericSpecialization(Node *node) {
   }
   assert(!FirstParam && "generic specialization with no substitutions");
 
-  switch (node->getKind()) {
-  case Node::Kind::GenericSpecialization:
-    Buffer << "Tg";
-    break;
-  case Node::Kind::GenericSpecializationPrespecialized:
-    Buffer << "Ts";
-    break;
-  case Node::Kind::GenericSpecializationNotReAbstracted:
-    Buffer << "TG";
-    break;
-  case Node::Kind::InlinedGenericFunction:
-    Buffer << "Ti";
-    break;
- default:
-   unreachable("unsupported node");
-  }
+  Buffer << operatorStr;
 
   for (NodePointer Child : *node) {
     if (Child->getKind() != Node::Kind::GenericSpecializationParam)
       mangle(Child);
   }
 }
 
+void Remangler::mangleGenericSpecialization(Node *node) {
+  mangleGenericSpecializationNode(node, "Tg");
+}
+
 void Remangler::mangleGenericSpecializationPrespecialized(Node *node) {
-  mangleGenericSpecialization(node);
+  mangleGenericSpecializationNode(node, "Ts");
 }
 
 void Remangler::mangleGenericSpecializationNotReAbstracted(Node *node) {
-  mangleGenericSpecialization(node);
+  mangleGenericSpecializationNode(node, "TG");
+}
+
+void Remangler::mangleGenericSpecializationInResilienceDomain(Node *node) {
+  mangleGenericSpecializationNode(node, "TB");
 }
 
 void Remangler::mangleInlinedGenericFunction(Node *node) {
-  mangleGenericSpecialization(node);
+  mangleGenericSpecializationNode(node, "Ti");
 }
 
 
@@ -1372,6 +1367,7 @@ void Remangler::mangleGlobal(Node *node) {
       case Node::Kind::GenericSpecialization:
       case Node::Kind::GenericSpecializationPrespecialized:
       case Node::Kind::GenericSpecializationNotReAbstracted:
+      case Node::Kind::GenericSpecializationInResilienceDomain:
       case Node::Kind::InlinedGenericFunction:
       case Node::Kind::GenericPartialSpecialization:
       case Node::Kind::GenericPartialSpecializationNotReAbstracted:

lib/SIL/Utils/GenericSpecializationMangler.cpp

@@ -74,32 +74,53 @@ std::string SpecializationMangler::finalize() {
 //                           Generic Specialization
 //===----------------------------------------------------------------------===//
 
-std::string GenericSpecializationMangler::mangle(GenericSignature Sig) {
-  beginMangling();
-
-  if (!Sig) {
-    assert(Function &&
-           "Need a SIL function if no generic signature is provided");
-    SILFunctionType *FTy = Function->getLoweredFunctionType();
-    Sig = FTy->getInvocationGenericSignature();
-  }
-
+void GenericSpecializationMangler::
+appendSubstitutions(GenericSignature sig, SubstitutionMap subs) {
   bool First = true;
-  Sig->forEachParam([&](GenericTypeParamType *ParamType, bool Canonical) {
+  sig->forEachParam([&](GenericTypeParamType *ParamType, bool Canonical) {
     if (Canonical) {
-      appendType(Type(ParamType).subst(SubMap)->getCanonicalType());
+      appendType(Type(ParamType).subst(subs)->getCanonicalType());
       appendListSeparator(First);
     }
   });
   assert(!First && "no generic substitutions");
+}
 
-  if (isInlined)
-    appendSpecializationOperator("Ti");
-  else
-    appendSpecializationOperator(
-        isPrespecializaton ? "Ts" : (isReAbstracted ? "Tg" : "TG"));
+std::string GenericSpecializationMangler::
+manglePrespecialized(GenericSignature sig, SubstitutionMap subs) {
+  beginMangling();
+  appendSubstitutions(sig, subs);
+  appendSpecializationOperator("Ts");
+  return finalize();
+}
+                                  
+std::string GenericSpecializationMangler::
+mangleNotReabstracted(SubstitutionMap subs) {
+  beginMangling();
+  appendSubstitutions(getGenericSignature(), subs);
+  appendSpecializationOperator("TG");
   return finalize();
 }
+                                  
+std::string GenericSpecializationMangler::
+mangleReabstracted(SubstitutionMap subs, bool alternativeMangling) {
+  beginMangling();
+  appendSubstitutions(getGenericSignature(), subs);
+  
+  // See ReabstractionInfo::hasConvertedResilientParams for why and when to use
+  // the alternative mangling.
+  appendSpecializationOperator(alternativeMangling ? "TB" : "Tg");
+  return finalize();
+}
+
+std::string GenericSpecializationMangler::
+mangleForDebugInfo(GenericSignature sig, SubstitutionMap subs, bool forInlining) {
+  beginMangling();
+  appendSubstitutions(sig, subs);
+  appendSpecializationOperator(forInlining ? "Ti" : "TG");
+  return finalize();
+}
+
 
 static SubstitutionMap
 getSubstitutionMapForPrespecialization(GenericSignature genericSig,
@@ -132,6 +153,6 @@ std::string GenericSpecializationMangler::manglePrespecialization(
     GenericSignature specializedSig) {
   auto subs =
       getSubstitutionMapForPrespecialization(genericSig, specializedSig);
-  GenericSpecializationMangler mangler(unspecializedName, subs);
-  return mangler.mangle(genericSig);
+  GenericSpecializationMangler mangler(unspecializedName);
+  return mangler.manglePrespecialized(genericSig, subs);
 }

lib/SILOptimizer/IPO/UsePrespecialized.cpp

@@ -105,9 +105,9 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
     // Create a name of the specialization. All external pre-specializations
     // are serialized without bodies. Thus use IsNotSerialized here.
     Mangle::GenericSpecializationMangler NewGenericMangler(ReferencedF,
-                                              Subs, IsNotSerialized,
-                                              /*isReAbstracted*/ true);
-    std::string ClonedName = NewGenericMangler.mangle();
+                                                           IsNotSerialized);
+    std::string ClonedName = NewGenericMangler.mangleReabstracted(Subs,
+       ReInfo.needAlternativeMangling());
 
     SILFunction *NewF = nullptr;
     // If we already have this specialization, reuse it.