[Mangler] Add methods for encoding already-mangled symbols.

This commit is related to the work of encoding mangled names more efficiently by
compressing them. This commit adds two new methods to the mangler that allows it
to identify requests to mangle strings that are already mangled.  Right now the
mangler does not do anything with this information.

This API is needed in all of the places in the compiler where we compose mangled
names. For example, when the optimizer is cloning functions it adds a prefix to
an existing name.

I verified that this change is correct by adding a compress/decompress methods
that add a prefix to the mangled names with assertions to catch compression of
already compressed symbols or decompression of non-compressed named.  I plan to
commit the verification code together with the compression implementation later
on.

Author: nadavrot

include/swift/AST/Mangle.h

@@ -169,6 +169,14 @@ class Mangler {
   /// Adds the char \p C into the mangled name.
   void append(char C);
 
+  /// Add the already mangled symbol \p Name as an indentifier. (using the
+  /// length prefix).
+  void mangleIdentifierSymbol(StringRef Name);
+
+  /// Add the already mangled symbol \p Name. This gives the mangler the
+  /// opportunity to decode \p Name before adding it to the mangled name.
+  void appendSymbol(StringRef Name);
+
   /// Mangle the integer \p Nat into the name.
   void mangleNatural(const APInt &Nat);
 

include/swift/SIL/Mangle.h

@@ -82,7 +82,7 @@ class SpecializationManglerBase {
 
   void mangleFunctionName() {
     M.append("_");
-    M.append(Function->getName());
+    M.appendSymbol(Function->getName());
   }
 };
 

lib/AST/Mangle.cpp

@@ -1850,6 +1850,18 @@ void Mangler::mangleNatural(const APInt &Nat) {
   Buffer << Nat;
 }
 
+void Mangler::mangleIdentifierSymbol(StringRef Name) {
+  // Mangle normal identifiers as:
+  //   count identifier-char+
+  // where the count is the number of characters in the identifier,
+  // and where individual identifier characters represent themselves.
+  Buffer << Name.size() << Name;
+}
+
+void Mangler::appendSymbol(StringRef Name) {
+   Buffer << Name;
+}
+
 void Mangler::mangleGlobalVariableFull(const VarDecl *decl) {
   // As a special case, Clang functions and globals don't get mangled at all.
   // FIXME: When we can import C++, use Clang's mangler.

lib/IRGen/Linking.cpp

@@ -299,10 +299,10 @@ void LinkEntity::mangle(raw_ostream &buffer) const {
   }
 
   case Kind::SILFunction:
-    mangler.append(getSILFunction()->getName());
+    mangler.appendSymbol(getSILFunction()->getName());
     return mangler.finalize(buffer);
   case Kind::SILGlobalVariable:
-    mangler.append(getSILGlobalVariable()->getName());
+    mangler.appendSymbol(getSILGlobalVariable()->getName());
     return mangler.finalize(buffer);
   }
   llvm_unreachable("bad entity kind!");

lib/SIL/Mangle.cpp

@@ -146,13 +146,13 @@ FunctionSignatureSpecializationMangler::mangleConstantProp(LiteralInst *LI) {
   case ValueKind::FunctionRefInst: {
     SILFunction *F = cast<FunctionRefInst>(LI)->getReferencedFunction();
     M.append("fr");
-    M.mangleIdentifier(F->getName());
+    M.mangleIdentifierSymbol(F->getName());
     break;
   }
   case ValueKind::GlobalAddrInst: {
     SILGlobalVariable *G = cast<GlobalAddrInst>(LI)->getReferencedGlobal();
     M.append("g");
-    M.mangleIdentifier(G->getName());
+    M.mangleIdentifierSymbol(G->getName());
     break;
   }
   case ValueKind::IntegerLiteralInst: {
@@ -196,7 +196,7 @@ mangleClosureProp(PartialApplyInst *PAI) {
   // closure specialization if we know the function_ref in question. When this
   // restriction is removed, the assert here will fire.
   auto *FRI = cast<FunctionRefInst>(PAI->getCallee());
-  M.mangleIdentifier(FRI->getReferencedFunction()->getName());
+  M.mangleIdentifierSymbol(FRI->getReferencedFunction()->getName());
 
   // Then we mangle the types of the arguments that the partial apply is
   // specializing.
@@ -216,7 +216,7 @@ void FunctionSignatureSpecializationMangler::mangleClosureProp(
   // closure specialization if we know the function_ref in question. When this
   // restriction is removed, the assert here will fire.
   auto *FRI = cast<FunctionRefInst>(TTTFI->getCallee());
-  M.mangleIdentifier(FRI->getReferencedFunction()->getName());
+  M.mangleIdentifierSymbol(FRI->getReferencedFunction()->getName());
 }
 
 void FunctionSignatureSpecializationMangler::mangleArgument(