Merge pull request #6415 from eeckstein/mangling-changes

Mangling: a few small changes and fixes

Author: eeckstein

docs/ABI.rst

@@ -1343,7 +1343,7 @@ The type is the function type of the specialized function.
 
 ::
 
-  specialization ::= spec-arg* 'Tf' SPEC-INFO ARG-SPEC-KIND* '_' ARG-SPEC-KIND  // Function signature specialization kind
+  specialization ::= spec-arg* 'Tf' SPEC-INFO UNIQUE-ID? ARG-SPEC-KIND* '_' ARG-SPEC-KIND  // Function signature specialization kind
 
 The ``<ARG-SPEC-KIND>`` describes how arguments are specialized.
 Some kinds need arguments, which precede ``Tf``.
@@ -1364,6 +1364,8 @@ Some kinds need arguments, which precede ``Tf``.
 
   FRAGILE ::= 'q'
 
+  UNIQUE-ID ::= NATURAL                      // Used to make unique function names
+
   ARG-SPEC-KIND ::= 'n'                      // Unmodified argument
   ARG-SPEC-KIND ::= 'c'                      // Consumes n 'type' arguments which are closed over types in argument order
                                              // and one 'identifier' argument which is the closure symbol name

include/swift/Basic/Demangler.h

@@ -223,7 +223,8 @@ class Demangler {
   NodePointer addFuncSpecParamNumber(NodePointer Param,
                               FunctionSigSpecializationParamKind Kind);
 
-  NodePointer demangleSpecAttributes(Node::Kind SpecKind);
+  NodePointer demangleSpecAttributes(Node::Kind SpecKind,
+                                     bool demangleUniqueID = false);
 
   NodePointer demangleWitness();
   NodePointer demangleSpecialType();

include/swift/SILOptimizer/Utils/SpecializationMangler.h

@@ -150,7 +150,7 @@ class FunctionSignatureSpecializationMangler : public SpecializationMangler {
   void setArgumentBoxToStack(unsigned ArgNo);
   void setReturnValueOwnedToUnowned();
 
-  std::string mangle();
+  std::string mangle(int UniqueID = 0);
 
 private:
   void mangleConstantProp(LiteralInst *LI);

lib/AST/ASTMangler.cpp

@@ -454,7 +454,7 @@ void ASTMangler::appendType(Type type) {
       TypeAliasDecl *decl = NameAliasTy->getDecl();
       if (decl->getModuleContext() == decl->getASTContext().TheBuiltinModule) {
         // It's not possible to mangle the context of the builtin module.
-        return appendType(decl->getDeclaredInterfaceType());
+        return appendType(NameAliasTy->getSinglyDesugaredType());
       }
 
       // For the DWARF output we want to mangle the type alias + context,

lib/Basic/Demangle.cpp

@@ -3610,12 +3610,22 @@ void NodePrinter::print(NodePointer pointer, bool asContext, bool suppressType)
     NodePointer child0 = pointer->getChild(0);
     NodePointer child1 = pointer->getChild(1);
     NodePointer child2 = pointer->getChild(2);
-    print(child0);
-    if (Options.DisplayProtocolConformances) {
+    if (pointer->getNumChildren() == 4) {
+      // TODO: check if this is correct
+      Printer << "property behavior storage of ";
+      print(child2);
+      Printer << " in ";
+      print(child0);
       Printer << " : ";
       print(child1);
-      Printer << " in ";
-      print(child2);
+    } else {
+      print(child0);
+      if (Options.DisplayProtocolConformances) {
+        Printer << " : ";
+        print(child1);
+        Printer << " in ";
+        print(child2);
+      }
     }
     return;
   }

lib/Basic/Demangler.cpp

@@ -858,9 +858,13 @@ NodePointer Demangler::demangleMetatype() {
     case 'A':
       return createWithChild(Node::Kind::ReflectionMetadataAssocTypeDescriptor,
                              popProtocolConformance());
-    case 'C':
+    case 'C': {
+      NodePointer Ty = popNode(Node::Kind::Type);
+      if (!Ty || !isNominal(Ty->getChild(0)->getKind()))
+        return nullptr;
       return createWithChild(Node::Kind::ReflectionMetadataSuperclassDescriptor,
-                             popNode(isNominal));
+                             Ty->getChild(0));
+    }
     default:
       return nullptr;
   }
@@ -1016,12 +1020,20 @@ NodePointer Demangler::popProtocolConformance() {
   NodePointer Module = popModule();
   NodePointer Proto = popProtocol();
   NodePointer Type = popNode(Node::Kind::Type);
+  NodePointer Ident;
+  if (!Type) {
+    // Property behavior conformance
+    Ident = popNode(Node::Kind::Identifier);
+    Type = popNode(Node::Kind::Type);
+  }
   if (GenSig) {
     Type = createType(createWithChildren(Node::Kind::DependentGenericType,
                                          GenSig, Type));
   }
-  return createWithChildren(Node::Kind::ProtocolConformance,
-                            Type, Proto, Module);
+  NodePointer Conf = createWithChildren(Node::Kind::ProtocolConformance,
+                                        Type, Proto, Module);
+  addChild(Conf, Ident);
+  return Conf;
 }
 
 NodePointer Demangler::demangleThunkOrSpecialization() {
@@ -1089,7 +1101,7 @@ NodePointer Demangler::demangleGenericSpecialization(Node::Kind SpecKind) {
 
 NodePointer Demangler::demangleFunctionSpecialization() {
   NodePointer Spec = demangleSpecAttributes(
-                                  Node::Kind::FunctionSignatureSpecialization);
+        Node::Kind::FunctionSignatureSpecialization, /*demangleUniqueID*/ true);
   unsigned ParamIdx = 0;
   while (Spec && !nextIf('_')) {
     Spec = addChild(Spec, demangleFuncSpecParam(ParamIdx));
@@ -1226,15 +1238,27 @@ NodePointer Demangler::addFuncSpecParamNumber(NodePointer Param,
      Node::Kind::FunctionSignatureSpecializationParamPayload, Str));
 }
 
-NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind) {
-  NodePointer SpecNd = NodeFactory::create(SpecKind);
-  if (nextIf('q'))
-    SpecNd->addChild(NodeFactory::create(Node::Kind::SpecializationIsFragile));
+NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind,
+                                              bool demangleUniqueID) {
+  bool isFragile = nextIf('q');
 
   int PassID = (int)nextChar() - '0';
   if (PassID < 0 || PassID > 9)
     return nullptr;
 
+  int Idx = -1;
+  if (demangleUniqueID)
+    Idx = demangleNatural();
+
+  NodePointer SpecNd;
+  if (Idx >= 0) {
+    SpecNd = NodeFactory::create(SpecKind, Idx);
+  } else {
+    SpecNd = NodeFactory::create(SpecKind);
+  }
+  if (isFragile)
+    SpecNd->addChild(NodeFactory::create(Node::Kind::SpecializationIsFragile));
+
   SpecNd->addChild(NodeFactory::create(Node::Kind::SpecializationPassID,
                                        PassID));
   return SpecNd;

lib/Basic/Mangler.cpp

@@ -104,12 +104,12 @@ static bool areTreesEqual(Demangle::NodePointer Old, Demangle::NodePointer New)
   return true;
 }
 
-static bool containsDependentAssociatedTypeRef(Demangle::NodePointer Nd) {
-  if (Nd->getKind() == Demangle::Node::Kind::DependentAssociatedTypeRef)
+static bool treeContains(Demangle::NodePointer Nd, Demangle::Node::Kind Kind) {
+  if (Nd->getKind() == Kind)
     return true;
 
   for (auto Child : *Nd) {
-    if (containsDependentAssociatedTypeRef(Child))
+    if (treeContains(Child, Kind))
       return true;
   }
   return false;
@@ -164,7 +164,13 @@ std::string NewMangling::selectMangling(const std::string &Old,
   NodePointer OldNode = demangleSymbolAsNode(Old);
   NodePointer NewNode = demangleSymbolAsNode(New);
 
-  if (OldNode) {
+  if (StringRef(New).startswith(MANGLING_PREFIX_STR) &&
+      (!NewNode || treeContains(NewNode, Demangle::Node::Kind::Suffix))) {
+    llvm::errs() << "Can't demangle " << New << '\n';
+    assert(false);
+  }
+  
+  if (OldNode && !treeContains(OldNode, Demangle::Node::Kind::Suffix)) {
     if (!areTreesEqual(OldNode, NewNode)) {
       llvm::errs() << "Mangling differs at #" << numCmp << ":\n"
                       "old: " << Old << "\n"
@@ -180,7 +186,8 @@ std::string NewMangling::selectMangling(const std::string &Old,
       std::string Remangled = mangleNodeNew(NewNode);
       if (New != Remangled) {
         bool isEqual = false;
-        if (containsDependentAssociatedTypeRef(NewNode) ||
+        if (treeContains(NewNode,
+                         Demangle::Node::Kind::DependentAssociatedTypeRef) ||
             // Does the mangling contain an identifier which is the name of
             // an old-mangled function?
             New.find("_T") != std::string::npos) {
@@ -262,6 +269,11 @@ void NewMangling::printManglingStats() {
 }
 
 void Mangler::beginMangling() {
+  Storage.clear();
+  Substitutions.clear();
+  StringSubstitutions.clear();
+  lastSubstIdx = -2;
+  Words.clear();
   Buffer << MANGLING_PREFIX_STR;
 }
 

lib/Basic/Remangler.cpp

@@ -860,6 +860,11 @@ void Remangler::mangleFunctionSignatureSpecialization(Node *node) {
       }
     }
     mangle(Child.get());
+
+    if (Child->getKind() == Node::Kind::SpecializationPassID &&
+        node->hasIndex()) {
+      Buffer << node->getIndex();
+    }
   }
   if (!returnValMangled)
     Buffer << "_n";
@@ -1349,6 +1354,8 @@ void Remangler::mangleProtocolConformance(Node *node) {
     Ty = Ty->getChild(1).get();
   }
   mangle(Ty);
+  if (node->getNumChildren() == 4)
+    mangleChildNode(node, 3);
   manglePureProtocol(node->getChild(1).get());
   mangleChildNode(node, 2);
   if (GenSig)

lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp

@@ -364,8 +364,16 @@ std::string FunctionSignatureTransform::createOptimizedSILFunctionName() {
   }
 
   OldFM.mangle();
-  std::string Old = OldFM.getMangler().finalize();
-  std::string New = NewFM.mangle();
+  SILModule &M = F->getModule();
+  std::string Old = getUniqueName(OldFM.getMangler().finalize(), M);
+
+  int UniqueID = 0;
+  std::string New;
+  do {
+    New = NewFM.mangle(UniqueID);
+    ++UniqueID;
+  } while (M.lookUpFunction(New));
+
   return NewMangling::selectMangling(Old, New);
 }
 
@@ -472,7 +480,7 @@ CanSILFunctionType FunctionSignatureTransform::createOptimizedSILFunctionType()
 void FunctionSignatureTransform::createFunctionSignatureOptimizedFunction() {
   // Create the optimized function !
   SILModule &M = F->getModule();
-  std::string Name = getUniqueName(createOptimizedSILFunctionName(), M);
+  std::string Name = createOptimizedSILFunctionName();
   SILLinkage linkage = F->getLinkage();
   if (isAvailableExternally(linkage))
     linkage = SILLinkage::Shared;

lib/SILOptimizer/Utils/SpecializationMangler.cpp

@@ -309,9 +309,13 @@ mangleReturnValue(ReturnValueModifierIntBase RetMod) {
   }
 }
 
-std::string FunctionSignatureSpecializationMangler::mangle() {
+std::string FunctionSignatureSpecializationMangler::mangle(int UniqueID) {
+  ArgOpStorage.clear();
   beginMangling();
 
+  if (UniqueID)
+    ArgOpBuffer << UniqueID;
+
   for (unsigned i : indices(Args)) {
     ArgumentModifierIntBase ArgMod;
     NullablePtr<SILInstruction> Inst;