Mangling: add specialization mangling for more complex constant propagated function arguments

So far, constant propagated arguments could only be builtin literals.
Now we support arbitrary structs (with constant arguments), e.g. `Int`.
This requires a small addition in the mangling scheme for function specializations.
Also, the de-mangling tree now looks a bit different to support a "tree" of structs and literals.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/FunctionPassContext.swift

@@ -109,6 +109,15 @@ struct FunctionPassContext : MutatingContext {
     }
   }
 
+  func mangle(withConstantCaptureArguments constArgs: [(argumentIndex: Int, argument: Value)],
+              from applySiteCallee: Function
+  ) -> String {
+    let bridgedConstArgs = constArgs.map { ($0.argumentIndex, $0.argument.bridged) }
+    return bridgedConstArgs.withBridgedArrayRef{ bridgedConstArgsArray in
+      String(taking: bridgedPassContext.mangleWithConstCaptureArgs(bridgedConstArgsArray, applySiteCallee.bridged))
+    }
+  }
+
   func mangle(withBoxToStackPromotedArguments argIndices: [Int], from original: Function) -> String {
     argIndices.withBridgedArrayRef { bridgedArgIndices in
       String(taking: bridgedPassContext.mangleWithBoxToStackPromotedArgs(bridgedArgIndices, original.bridged))

docs/ABI/Mangling.rst

@@ -1374,6 +1374,7 @@ Some kinds need arguments, which precede ``Tf``.
   CONST-PROP ::= 'd' NATURAL-ZERO            // float-as-64-bit-integer
   CONST-PROP ::= 's' ENCODING                // string literal. Consumes one identifier argument.
   CONST-PROP ::= 'k'                         // keypath. Consumes one identifier - the SHA1 of the keypath and two types (root and value).
+  CONST-PROP ::= 'S' CONST-PROP*             // struct with operands. Consumes one type argument - the struct type.
 
   ENCODING ::= 'b'                           // utf8
   ENCODING ::= 'w'                           // utf16

include/swift/Demangling/Demangle.h

@@ -116,6 +116,7 @@ enum class FunctionSigSpecializationParamKind : unsigned {
   BoxToStack = 7,
   InOutToOut = 8,
   ConstantPropKeyPath = 9,
+  ConstantPropStruct = 10,
 
   // Option Set Flags use bits 6-31. This gives us 26 bits to use for option
   // flags.
@@ -971,6 +972,9 @@ class NodePrinter {
   virtual void printGenericSignature(NodePointer Node, unsigned depth);
 
   void printFunctionSigSpecializationParams(NodePointer Node, unsigned depth);
+  void printNextParamChildNode(NodePointer nd, unsigned &idx,
+                               FunctionSigSpecializationParamKind kind,
+                               unsigned depth);
 
   void printSpecializationPrefix(NodePointer node, StringRef Description,
                                  unsigned depth,

include/swift/SILOptimizer/OptimizerBridging.h

@@ -189,6 +189,8 @@ struct BridgedPassContext {
   BridgedOwnedString mangleWithDeadArgs(BridgedArrayRef bridgedDeadArgIndices, BridgedFunction function) const;
   BridgedOwnedString mangleWithClosureArgs(BridgedArrayRef closureArgIndices,
                                                                BridgedFunction applySiteCallee) const;
+  BridgedOwnedString mangleWithConstCaptureArgs(BridgedArrayRef bridgedConstArgs,
+                                                BridgedFunction applySiteCallee) const;
   BridgedOwnedString mangleWithBoxToStackPromotedArgs(BridgedArrayRef bridgedPromotedArgIndices,
                                                       BridgedFunction bridgedOriginalFunction) const;
 

lib/Demangling/Demangler.cpp

@@ -3378,43 +3378,40 @@ NodePointer Demangler::demangleFunctionSpecialization() {
     if (Param->getKind() != Node::Kind::FunctionSignatureSpecializationParam)
       continue;
 
-    if (Param->getNumChildren() == 0)
-      continue;
-    NodePointer KindNd = Param->getFirstChild();
-    assert(KindNd->getKind() ==
-             Node::Kind::FunctionSignatureSpecializationParamKind);
-    auto ParamKind = (FunctionSigSpecializationParamKind)KindNd->getIndex();
-    switch (ParamKind) {
-      case FunctionSigSpecializationParamKind::ConstantPropFunction:
-      case FunctionSigSpecializationParamKind::ConstantPropGlobal:
-      case FunctionSigSpecializationParamKind::ConstantPropString:
-      case FunctionSigSpecializationParamKind::ConstantPropKeyPath:
-      case FunctionSigSpecializationParamKind::ClosureProp: {
-        size_t FixedChildren = Param->getNumChildren();
-        while (NodePointer Ty = popNode(Node::Kind::Type)) {
-          if (ParamKind != FunctionSigSpecializationParamKind::ClosureProp &&
-              ParamKind != FunctionSigSpecializationParamKind::ConstantPropKeyPath)
-            return nullptr;
-          Param = addChild(Param, Ty);
-        }
-        NodePointer Name = popNode(Node::Kind::Identifier);
-        if (!Name)
-          return nullptr;
-        StringRef Text = Name->getText();
-        if (ParamKind ==
-                FunctionSigSpecializationParamKind::ConstantPropString &&
-            !Text.empty() && Text[0] == '_') {
-          // A '_' escapes a leading digit or '_' of a string constant.
-          Text = Text.drop_front(1);
+    size_t fixedChildren = Param->getNumChildren();
+    NodePointer paramToAdd = Param;
+    for (size_t childIdx = 0; childIdx < fixedChildren; ++childIdx) {
+      NodePointer KindNd = Param->getChild(fixedChildren - childIdx - 1);
+      if (KindNd->getKind() != Node::Kind::FunctionSignatureSpecializationParamKind)
+        continue;
+
+      auto ParamKind = (FunctionSigSpecializationParamKind)KindNd->getIndex();
+      switch (ParamKind) {
+        case FunctionSigSpecializationParamKind::ClosureProp: {
+          while (NodePointer Ty = popNode(Node::Kind::Type)) {
+            paramToAdd = addChild(paramToAdd, Ty);
+          }
+          break;
         }
-        addChild(Param, createNodeWithAllocatedText(
-          Node::Kind::FunctionSignatureSpecializationParamPayload, Text));
-        Param->reverseChildren(FixedChildren);
-        break;
+        case FunctionSigSpecializationParamKind::ConstantPropKeyPath:
+          paramToAdd = addChild(paramToAdd, popNode(Node::Kind::Type));
+          paramToAdd = addChild(paramToAdd, popNode(Node::Kind::Type));
+          break;
+        case FunctionSigSpecializationParamKind::ConstantPropStruct:
+          paramToAdd = addChild(paramToAdd, popNode(Node::Kind::Type));
+          continue;
+        case FunctionSigSpecializationParamKind::ConstantPropFunction:
+        case FunctionSigSpecializationParamKind::ConstantPropGlobal:
+        case FunctionSigSpecializationParamKind::ConstantPropString:
+          break;
+        default:
+          continue;
       }
-      default:
-        break;
+      paramToAdd = addChild(paramToAdd, popNode(Node::Kind::Identifier));
     }
+    if (!paramToAdd)
+      return nullptr;
+    Param->reverseChildren(fixedChildren);
   }
   return Spec;
 }
@@ -3433,58 +3430,79 @@ NodePointer Demangler::demangleFuncSpecParam(Node::Kind Kind) {
         Node::Kind::FunctionSignatureSpecializationParamKind,
         uint64_t(FunctionSigSpecializationParamKind::ClosureProp)));
     case 'p': {
-      switch (nextChar()) {
-        case 'f':
-          // Consumes an identifier parameter, which will be added later.
-          return addChild(
-              Param,
-              createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
-                         Node::IndexType(FunctionSigSpecializationParamKind::
-                                             ConstantPropFunction)));
-        case 'g':
-          // Consumes an identifier parameter, which will be added later.
-          return addChild(
-              Param,
-              createNode(
-                  Node::Kind::FunctionSignatureSpecializationParamKind,
-                  Node::IndexType(
-                      FunctionSigSpecializationParamKind::ConstantPropGlobal)));
-        case 'i':
-          return addFuncSpecParamNumber(Param,
-                    FunctionSigSpecializationParamKind::ConstantPropInteger);
-        case 'd':
-          return addFuncSpecParamNumber(Param,
-                      FunctionSigSpecializationParamKind::ConstantPropFloat);
-        case 's': {
-          // Consumes an identifier parameter (the string constant),
-          // which will be added later.
-          const char *Encoding = nullptr;
-          switch (nextChar()) {
-            case 'b': Encoding = "u8"; break;
-            case 'w': Encoding = "u16"; break;
-            case 'c': Encoding = "objc"; break;
-            default: return nullptr;
+      for (;;) {
+        switch (nextChar()) {
+          case 'S':
+            // Consumes an identifier parameter, which will be added later.
+            addChild(
+                Param,
+                createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
+                           Node::IndexType(FunctionSigSpecializationParamKind::
+                                               ConstantPropStruct)));
+            break;
+          case 'f':
+            // Consumes an identifier parameter, which will be added later.
+            addChild(
+                Param,
+                createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
+                           Node::IndexType(FunctionSigSpecializationParamKind::
+                                               ConstantPropFunction)));
+            break;
+          case 'g':
+            // Consumes an identifier parameter, which will be added later.
+            addChild(
+                Param,
+                createNode(
+                    Node::Kind::FunctionSignatureSpecializationParamKind,
+                    Node::IndexType(
+                        FunctionSigSpecializationParamKind::ConstantPropGlobal)));
+            break;
+          case 'i':
+            if (!addFuncSpecParamNumber(Param,
+                      FunctionSigSpecializationParamKind::ConstantPropInteger)) {
+              return nullptr;
+            }
+            break;
+          case 'd':
+            if (!addFuncSpecParamNumber(Param,
+                        FunctionSigSpecializationParamKind::ConstantPropFloat)) {
+              return nullptr;
+            }
+            break;
+          case 's': {
+            // Consumes an identifier parameter (the string constant),
+            // which will be added later.
+            const char *Encoding = nullptr;
+            switch (nextChar()) {
+              case 'b': Encoding = "u8"; break;
+              case 'w': Encoding = "u16"; break;
+              case 'c': Encoding = "objc"; break;
+              default: return nullptr;
+            }
+            addChild(Param,
+                     createNode(
+                         Node::Kind::FunctionSignatureSpecializationParamKind,
+                         Node::IndexType(
+                             swift::Demangle::FunctionSigSpecializationParamKind::
+                                 ConstantPropString)));
+            addChild(Param, createNode(
+                    Node::Kind::FunctionSignatureSpecializationParamPayload,
+                    Encoding));
+            break;
           }
-          addChild(Param,
-                   createNode(
-                       Node::Kind::FunctionSignatureSpecializationParamKind,
-                       Node::IndexType(
-                           swift::Demangle::FunctionSigSpecializationParamKind::
-                               ConstantPropString)));
-          return addChild(Param, createNode(
-                  Node::Kind::FunctionSignatureSpecializationParamPayload,
-                  Encoding));
-        }
-        case 'k': {
-          // Consumes two types and a SHA1 identifier.
-          return addChild(
-              Param,
-              createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
-                         Node::IndexType(FunctionSigSpecializationParamKind::
-                                             ConstantPropKeyPath)));
+          case 'k': {
+            // Consumes two types and a SHA1 identifier.
+            addChild(
+                Param,
+                createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
+                           Node::IndexType(FunctionSigSpecializationParamKind::
+                                               ConstantPropKeyPath)));
+            break;
+          }
+          default:
+            pushBack();
+            return Param;
         }
-        default:
-          return nullptr;
       }
     }
     case 'e': {