Merge pull request #17892 from slavapestov/unique-id-be-gone

SILOptimizer: Remove 'unique ID' from FSO mangling

Author: slavapestov

docs/ABI/Mangling.rst

@@ -797,7 +797,7 @@ The type is the function type of the specialized function.
 
 ::
 
-  specialization ::= spec-arg* 'Tf' SPEC-INFO UNIQUE-ID? ARG-SPEC-KIND* '_' ARG-SPEC-KIND  // Function signature specialization kind
+  specialization ::= spec-arg* 'Tf' SPEC-INFO 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``.
@@ -818,8 +818,6 @@ 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/Demangling/Demangler.h

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

include/swift/SILOptimizer/Utils/SpecializationMangler.h

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

lib/Demangling/Demangler.cpp

@@ -1873,7 +1873,7 @@ NodePointer Demangler::demangleGenericSpecialization(Node::Kind SpecKind) {
 
 NodePointer Demangler::demangleFunctionSpecialization() {
   NodePointer Spec = demangleSpecAttributes(
-        Node::Kind::FunctionSignatureSpecialization, /*demangleUniqueID*/ true);
+        Node::Kind::FunctionSignatureSpecialization);
   unsigned ParamIdx = 0;
   while (Spec && !nextIf('_')) {
     Spec = addChild(Spec, demangleFuncSpecParam(ParamIdx));
@@ -2069,24 +2069,14 @@ NodePointer Demangler::addFuncSpecParamNumber(NodePointer Param,
      Node::Kind::FunctionSignatureSpecializationParamPayload, Str));
 }
 
-NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind,
-                                              bool demangleUniqueID) {
+NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind) {
   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 = nullptr;
-  if (Idx >= 0) {
-    SpecNd = createNode(SpecKind, Idx);
-  } else {
-    SpecNd = createNode(SpecKind);
-  }
+  NodePointer SpecNd = createNode(SpecKind);
   if (isFragile)
     SpecNd->addChild(createNode(Node::Kind::SpecializationIsFragile),
                      *this);

lib/SILOptimizer/FunctionSignatureTransforms/FunctionSignatureOpts.cpp

@@ -186,12 +186,8 @@ FunctionSignatureTransformDescriptor::createOptimizedSILFunctionName() {
   }
 
   SILModule &M = F->getModule();
-  int UniqueID = 0;
-  std::string MangledName;
-  do {
-    MangledName = Mangler.mangle(UniqueID);
-    ++UniqueID;
-  } while (M.hasFunction(MangledName));
+  auto MangledName = Mangler.mangle();
+  assert(!M.hasFunction(MangledName));
 
   return MangledName;
 }

lib/SILOptimizer/Utils/SpecializationMangler.cpp

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