Change mangling for the Swift module from 'Ss' to 's'.

'Ss' appears in manglings tens of thousands of times in the standard library and is also incredibly frequent in other modules. This alone is enough to shrink the standard library by 59KB.

Swift SVN r32409

Author: jckarter

docs/ABI.rst

@@ -765,7 +765,7 @@ Globals
   entity ::= static? entity-kind context entity-name
   entity-kind ::= 'F'                    // function (ctor, accessor, etc.)
   entity-kind ::= 'v'                    // variable (let/var)
-  entity-kind ::= 's'                    // subscript itself (not the individual accessors)
+  entity-kind ::= 'i'                    // subscript ('i'ndex) itself (not the individual accessors)
   entity-kind ::= 'I'                    // initializer
   entity-name ::= decl-name type         // named declaration
   entity-name ::= 'A' index              // default argument generator
@@ -796,15 +796,15 @@ Globals
   addressor-kind ::= 'p'                 // pinning addressor (native owner)
 
 An ``entity`` starts with a ``nominal-type-kind`` (``[COPV]``), a
-substitution (``[S]``) of a nominal type, or an ``entity-kind``
-(``[FIsv]``).
+substitution (``[Ss]``) of a nominal type, or an ``entity-kind``
+(``[FIiv]``).
 
 An ``entity-name`` starts with ``[AaCcDggis]`` or a ``decl-name``.
 A ``decl-name`` starts with ``[LP]`` or an ``identifier`` (``[0-9oX]``).
 
 A ``context`` starts with either an ``entity``, an ``extension`` (which starts
-with ``[E]``), or a ``module``, which might be an ``identifier`` (``[0-9oX]``)
-or a substitution of a module (``[S]``).
+with ``[Ee]``), or a ``module``, which might be an ``identifier`` (``[0-9oX]``)
+or a substitution of a module (``[Ss]``).
 
 A global mangling starts with an ``entity`` or ``[MTWw]``.
 
@@ -1137,22 +1137,33 @@ if it mangled again.) The result type will mangle using the substitution for
 ``zim.zang``, ``CS0_zoo`` (and acquire substitution ``S3_``). The full
 function type thus mangles as ``fTCC3zim4zang4zungCS1_CS_7zippity_CS0_zoo``.
 
+::
+
+  substitution ::= 's'
+
+The special substitution ``s`` is used for the ``Swift`` standard library
+module.
+
 Predefined Substitutions
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 ::
 
+  known-module ::= 's'                       // Swift
   known-module ::= 'SC'                      // C
   known-module ::= 'So'                      // Objective-C
-  known-module ::= 'Ss'                      // Swift
   known-nominal-type ::= 'Sa'                // Swift.Array
   known-nominal-type ::= 'Sb'                // Swift.Bool
   known-nominal-type ::= 'Sc'                // Swift.UnicodeScalar
   known-nominal-type ::= 'Sd'                // Swift.Float64
   known-nominal-type ::= 'Sf'                // Swift.Float32
   known-nominal-type ::= 'Si'                // Swift.Int
+  known-nominal-type ::= 'SP'                // Swift.UnsafePointer
+  known-nominal-type ::= 'Sp'                // Swift.UnsafeMutablePointer
   known-nominal-type ::= 'SQ'                // Swift.ImplicitlyUnwrappedOptional
   known-nominal-type ::= 'Sq'                // Swift.Optional
+  known-nominal-type ::= 'SR'                // Swift.UnsafeBufferPointer
+  known-nominal-type ::= 'Sr'                // Swift.UnsafeMutableBufferPointer
   known-nominal-type ::= 'SS'                // Swift.String
   known-nominal-type ::= 'Su'                // Swift.UInt
 

docs/DebuggingTheCompiler.rst

@@ -257,4 +257,4 @@ function in the current frame::
     Address: CollectionType3[0x0000000100004db0] (CollectionType3.__TEXT.__text + 16000)
     Summary: CollectionType3`ext.CollectionType3.CollectionType3.MutableCollectionType2<A where A: CollectionType3.MutableCollectionType2>.(subscript.materializeForSet : (Swift.Range<A.Index>) -> Swift.MutableSlice<A>).(closure #1)
     Module: file = "/Volumes/Files/work/solon/build/build-swift/validation-test-macosx-x86_64/stdlib/Output/CollectionType.swift.gyb.tmp/CollectionType3", arch = "x86_64"
-    Symbol: id = {0x0000008c}, range = [0x0000000100004db0-0x00000001000056f0), name="ext.CollectionType3.CollectionType3.MutableCollectionType2<A where A: CollectionType3.MutableCollectionType2>.(subscript.materializeForSet : (Swift.Range<A.Index>) -> Swift.MutableSlice<A>).(closure #1)", mangled="_TFFeRq_15CollectionType322MutableCollectionType2_S_S0_m9subscriptFGVSs5Rangeqq_Ss16MutableIndexable5Index_GVSs12MutableSliceq__U_FTBpRBBRQPS0_MS4__T_"
+    Symbol: id = {0x0000008c}, range = [0x0000000100004db0-0x00000001000056f0), name="ext.CollectionType3.CollectionType3.MutableCollectionType2<A where A: CollectionType3.MutableCollectionType2>.(subscript.materializeForSet : (Swift.Range<A.Index>) -> Swift.MutableSlice<A>).(closure #1)", mangled="_TFFeRq_15CollectionType322MutableCollectionType2_S_S0_m9subscriptFGVs5Rangeqq_s16MutableIndexable5Index_GVs12MutableSliceq__U_FTBpRBBRQPS0_MS4__T_"

docs/SIL.rst

@@ -162,7 +162,7 @@ Here is an example of a ``.sil`` file::
   sil @_T5norms11taxicabNormfT1aV5norms5Point_Sd : $(Point) -> Double {
   bb0(%0 : $Point):
     // func Swift.+(Double, Double) -> Double
-    %1 = function_ref @_TSsoi1pfTSdSd_Sd
+    %1 = function_ref @_Tsoi1pfTSdSd_Sd
     %2 = struct_extract %0 : $Point, #Point.x
     %3 = struct_extract %0 : $Point, #Point.y
     %4 = apply %1(%2, %3) : $(Double, Double) -> Double

lib/AST/Mangle.cpp

@@ -315,9 +315,9 @@ void Mangler::mangleModule(const Module *module) {
 
   // Try the special 'swift' substitution.
   // context ::= known-module
-  // known-module ::= 'Ss'
+  // known-module ::= 's'
   if (module->isStdlibModule()) {
-    Buffer << "Ss";
+    Buffer << "s";
     return;
   }
 
@@ -1686,7 +1686,7 @@ void Mangler::mangleEntity(const ValueDecl *decl,
   if (isa<VarDecl>(decl)) {
     Buffer << 'v';
   } else if (isa<SubscriptDecl>(decl)) {
-    Buffer << 's';
+    Buffer << 'i';
   } else if (isa<GenericTypeParamDecl>(decl)) {
     shouldBindParent = BindGenerics::None;
     Buffer << 't';

lib/Basic/Demangle.cpp

@@ -1002,8 +1002,6 @@ class Demangler {
       return NodeFactory::create(Node::Kind::Module, MANGLING_MODULE_OBJC);
     if (Mangled.nextIf('C'))
       return NodeFactory::create(Node::Kind::Module, MANGLING_MODULE_C);
-    if (Mangled.nextIf('s'))
-      return NodeFactory::create(Node::Kind::Module, STDLIB_NAME);
     if (Mangled.nextIf('a'))
       return createSwiftType(Node::Kind::Structure, "Array");
     if (Mangled.nextIf('b'))
@@ -1016,10 +1014,18 @@ class Demangler {
       return createSwiftType(Node::Kind::Structure, "Float");
     if (Mangled.nextIf('i'))
       return createSwiftType(Node::Kind::Structure, "Int");
+    if (Mangled.nextIf('P'))
+      return createSwiftType(Node::Kind::Structure, "UnsafePointer");
+    if (Mangled.nextIf('p'))
+      return createSwiftType(Node::Kind::Structure, "UnsafeMutablePointer");
     if (Mangled.nextIf('q'))
       return createSwiftType(Node::Kind::Enum, "Optional");
     if (Mangled.nextIf('Q'))
       return createSwiftType(Node::Kind::Enum, "ImplicitlyUnwrappedOptional");
+    if (Mangled.nextIf('R'))
+      return createSwiftType(Node::Kind::Structure, "UnsafeBufferPointer");
+    if (Mangled.nextIf('r'))
+      return createSwiftType(Node::Kind::Structure, "UnsafeMutableBufferPointer");
     if (Mangled.nextIf('S'))
       return createSwiftType(Node::Kind::Structure, "String");
     if (Mangled.nextIf('u'))
@@ -1033,6 +1039,9 @@ class Demangler {
   }
 
   NodePointer demangleModule() {
+    if (Mangled.nextIf('s')) {
+      return NodeFactory::create(Node::Kind::Module, STDLIB_NAME);
+    }
     if (Mangled.nextIf('S')) {
       NodePointer module = demangleSubstitutionIndex();
       if (!module)
@@ -1095,6 +1104,19 @@ class Demangler {
       return proto;
     }
 
+    if (Mangled.nextIf('s')) {
+      NodePointer stdlib = NodeFactory::create(Node::Kind::Module, STDLIB_NAME);
+
+      NodePointer name = demangleDeclName();
+      if (!name) return nullptr;
+
+      auto proto = NodeFactory::create(Node::Kind::Protocol);
+      proto->addChild(std::move(stdlib));
+      proto->addChild(std::move(name));
+      Substitutions.push_back(proto);
+      return proto;
+    }
+
     return demangleDeclarationName(Node::Kind::Protocol);
   }
 
@@ -1148,6 +1170,8 @@ class Demangler {
     }
     if (Mangled.nextIf('S'))
       return demangleSubstitutionIndex();
+    if (Mangled.nextIf('s'))
+      return NodeFactory::create(Node::Kind::Module, STDLIB_NAME);
     if (isStartOfEntity(Mangled.peek()))
       return demangleEntity();
     return demangleModule();
@@ -1198,7 +1222,7 @@ class Demangler {
       entityBasicKind = Node::Kind::Variable;
     } else if (Mangled.nextIf('I')) {
       entityBasicKind = Node::Kind::Initializer;
-    } else if (Mangled.nextIf('s')) {
+    } else if (Mangled.nextIf('i')) {
       entityBasicKind = Node::Kind::Subscript;
     } else {
       return demangleNominalType();
@@ -1356,7 +1380,7 @@ class Demangler {
         if (!Mangled)
           return nullptr;
         char c = Mangled.peek();
-        if (c != '_' && c != 'S'
+        if (c != '_' && c != 'S' && c != 's'
             && (nodeKind == Node::Kind::AssociatedType || c != 'U')
             && !isStartOfIdentifier(c))
           break;
@@ -1589,6 +1613,10 @@ class Demangler {
       else
         return makeAssociatedType(sub);
     }
+    if (Mangled.nextIf('s')) {
+      NodePointer stdlib = NodeFactory::create(Node::Kind::Module, STDLIB_NAME);
+      return makeAssociatedType(stdlib);
+    }
     if (Mangled.nextIf('d')) {
       Node::IndexType depth, index;
       if (!demangleIndex(depth))

lib/Basic/Remangle.cpp

@@ -351,7 +351,7 @@ bool Remangler::trySubstitution(Node *node, SubstitutionEntry &entry) {
   SUCCESS_IF_IS(node->getChild(1)->getText(), EXPECTED, SUBSTITUTION)
 
   case Node::Kind::Module:
-    SUCCESS_IF_TEXT_IS(STDLIB_NAME, "Ss");
+    SUCCESS_IF_TEXT_IS(STDLIB_NAME, "s");
     SUCCESS_IF_TEXT_IS(MANGLING_MODULE_OBJC, "So");
     SUCCESS_IF_TEXT_IS(MANGLING_MODULE_C, "SC");
     break;
@@ -734,7 +734,7 @@ void Remangler::mangleVariable(Node *node, EntityContext &ctx) {
 }
 
 void Remangler::mangleSubscript(Node *node, EntityContext &ctx) {
-  mangleNamedAndTypedEntity(node, 's', "", ctx);
+  mangleNamedAndTypedEntity(node, 'i', "", ctx);
 }
 
 void Remangler::mangleInitializer(Node *node, EntityContext &ctx) {

lib/SILAnalysis/ARC/ARCAnalysis.cpp

@@ -588,7 +588,7 @@ mayGuaranteedUseValue(SILInstruction *User, SILValue Ptr, AliasAnalysis *AA) {
 
 static bool ignoreableApplyInstInUnreachableBlock(ApplyInst *AI) {
   const char *fatalName =
-    "_TFSs18_fatalErrorMessageFTVSs12StaticStringS_S_Su_T_";
+    "_TFs18_fatalErrorMessageFTVs12StaticStringS_S_Su_T_";
   auto *FRI = dyn_cast<FunctionRefInst>(AI->getCallee());
 
   // We use endswith here since if we specialize fatal error we will always

lib/SILAnalysis/CFG.cpp

@@ -36,7 +36,7 @@ static bool isSafeNonExitTerminator(TermInst *TI) {
 
 static bool isTrapNoReturnFunction(ApplyInst *AI) {
   const char *fatalName =
-      "_TFSs18_fatalErrorMessageFTVSs12StaticStringS_S_Su_T_";
+      "_TFs18_fatalErrorMessageFTVs12StaticStringS_S_Su_T_";
   auto *FRI = dyn_cast<FunctionRefInst>(AI->getCallee());
 
   // We use endswith here since if we specialize fatal error we will always

lib/SwiftDemangle/MangleHack.cpp

@@ -29,7 +29,7 @@ _swift_mangleSimpleClass(const char *module, const char *class_) {
   size_t classLength = strlen(class_);
   char *value = nullptr;
   if (strcmp(module, swift::STDLIB_NAME) == 0) {
-    int result = asprintf(&value, "_TtCSs%zu%s", classLength, class_);
+    int result = asprintf(&value, "_TtCs%zu%s", classLength, class_);
     assert(result > 0);
     (void)result;
   } else {
@@ -48,7 +48,7 @@ _swift_mangleSimpleProtocol(const char *module, const char *protocol) {
   size_t protocolLength = strlen(protocol);
   char *value = nullptr;
   if (strcmp(module, swift::STDLIB_NAME) == 0) {
-    int result = asprintf(&value, "_TtPSs%zu%s_", protocolLength, protocol);
+    int result = asprintf(&value, "_TtPs%zu%s_", protocolLength, protocol);
     assert(result > 0);
     (void)result;
   } else {

stdlib/public/runtime/Casting.cpp

@@ -1401,10 +1401,10 @@ static bool _dynamicCastUnknownClassIndirect(OpaqueValue *dest,
 }
 
 #if SWIFT_OBJC_INTEROP
-extern "C" const ProtocolDescriptor _TMpSs9ErrorType;
+extern "C" const ProtocolDescriptor _TMps9ErrorType;
 
 static const WitnessTable *findErrorTypeWitness(const Metadata *srcType) {
-  return swift_conformsToProtocol(srcType, &_TMpSs9ErrorType);
+  return swift_conformsToProtocol(srcType, &_TMps9ErrorType);
 }
 
 static const Metadata *getNSErrorTypeMetadata() {
@@ -2659,12 +2659,12 @@ swift::swift_conformsToProtocol(const Metadata *type,
 // The return type is incorrect.  It is only important that it is
 // passed using 'sret'.
 extern "C" OpaqueExistentialContainer
-_TFSs24_injectValueIntoOptionalU__FQ_GSqQ__(OpaqueValue *value,
+_TFs24_injectValueIntoOptionalU__FQ_GSqQ__(OpaqueValue *value,
                                             const Metadata *T);
 // The return type is incorrect.  It is only important that it is
 // passed using 'sret'.
 extern "C" OpaqueExistentialContainer
-_TFSs26_injectNothingIntoOptionalU__FT_GSqQ__(const Metadata *T);
+_TFs26_injectNothingIntoOptionalU__FT_GSqQ__(const Metadata *T);
 
 static inline bool swift_isClassOrObjCExistentialImpl(const Metadata *T) {
   auto kind = T->getKind();
@@ -2726,7 +2726,7 @@ struct _ObjectiveCBridgeableWitnessTable {
 
 } // unnamed namespace
 
-extern "C" const ProtocolDescriptor _TMpSs21_ObjectiveCBridgeable;
+extern "C" const ProtocolDescriptor _TMps21_ObjectiveCBridgeable;
 
 /// Dynamic cast from a value type that conforms to the _ObjectiveCBridgeable
 /// protocol to a class type, first by bridging the value to its Objective-C
@@ -2906,11 +2906,11 @@ static bool _dynamicCastClassToValueViaObjCBridgeable(
 //===----------------------------------------------------------------------===//
 
 extern "C" const _ObjectiveCBridgeableWitnessTable
-_TWPVSs19_BridgeableMetatypeSs21_ObjectiveCBridgeableSs;
+_TWPVs19_BridgeableMetatypes21_ObjectiveCBridgeables;
 
 static const _ObjectiveCBridgeableWitnessTable *
 findBridgeWitness(const Metadata *T) {
-  auto w = swift_conformsToProtocol(T, &_TMpSs21_ObjectiveCBridgeable);
+  auto w = swift_conformsToProtocol(T, &_TMps21_ObjectiveCBridgeable);
   if (LLVM_LIKELY(w))
     return reinterpret_cast<const _ObjectiveCBridgeableWitnessTable *>(w);
   // Class and ObjC existential metatypes can be bridged, but metatypes can't
@@ -2920,14 +2920,14 @@ findBridgeWitness(const Metadata *T) {
   case MetadataKind::Metatype: {
     auto metaTy = static_cast<const MetatypeMetadata *>(T);
     if (metaTy->InstanceType->isAnyClass())
-      return &_TWPVSs19_BridgeableMetatypeSs21_ObjectiveCBridgeableSs;
+      return &_TWPVs19_BridgeableMetatypes21_ObjectiveCBridgeables;
     break;
   }
   case MetadataKind::ExistentialMetatype: {
     auto existentialMetaTy =
       static_cast<const ExistentialMetatypeMetadata *>(T);
     if (existentialMetaTy->isObjC())
-      return &_TWPVSs19_BridgeableMetatypeSs21_ObjectiveCBridgeableSs;
+      return &_TWPVs19_BridgeableMetatypes21_ObjectiveCBridgeables;
     break;
   }
 

stdlib/public/runtime/ErrorObject.mm

@@ -171,7 +171,7 @@ static Class getSwiftNativeNSErrorClass() {
   // Swift source.
 
   static auto TheWitnessTable = dlsym(RTLD_DEFAULT,
-                                   "_TWPCSo7CFErrorSs9ErrorType10Foundation");
+                                   "_TWPCSo7CFErrors9ErrorType10Foundation");
   assert(TheWitnessTable &&
          "Foundation overlay not loaded, or CFError: ErrorType conformance "
          "not available");

stdlib/public/runtime/GlobalObjects.cpp

@@ -21,12 +21,12 @@
 namespace swift {
 
 // _direct type metadata for Swift._EmptyArrayStorage
-extern "C" ClassMetadata _TMdCSs18_EmptyArrayStorage;
+extern "C" ClassMetadata _TMdCs18_EmptyArrayStorage;
 
 extern "C" _SwiftEmptyArrayStorage _swiftEmptyArrayStorage = {
   // HeapObject header;
   {
-    &_TMdCSs18_EmptyArrayStorage, // is-a pointer
+    &_TMdCs18_EmptyArrayStorage, // is-a pointer
   },
 
   // _SwiftArrayBodyStorage body;