[PGO] Fix name encoding for ObjC-like functions

[vsk]

Summary

Function names in ObjC can have spaces in them. This interacts poorly with name compression, which uses spaces to separate PGO names. Fix the issue by using a different separator and add a test.

I chose "\01" as the separator because 1) it's non-printable, 2) we strip it from PGO names, and 3) it's the next natural choice once "\00" is discarded (that one's overloaded).

[davidxl]

Can you define a symbolic constant for it in InstrProf.h? Otherwise lgtm.

llvm/trunk/include/llvm/ProfileData/InstrProf.h

 }
 
 /// Return the name of the profile runtime interface that overrides the default
 /// profile data file name.
 inline StringRef getInstrProfFileOverriderFuncName() {
   return "__llvm_profile_override_default_filename";
 }
 
+/// Return the marker used to separate PGO names during serialization.
+inline StringRef getInstrProfNameSeparator() { return "\01"; }
+
 /// Return the modified name for function \c F suitable to be
 /// used the key for profile lookup.
 std::string getPGOFuncName(const Function &F,
                            uint64_t Version = INSTR_PROF_INDEX_VERSION);
 
 /// Return the modified name for a function suitable to be
 /// used the key for profile lookup. The function's original
 /// name is \c RawFuncName and has linkage of type \c Linkage.

llvm/trunk/lib/ProfileData/InstrProf.cpp

void InstrProfSymtab::create(const Module &M) {
 
   finalizeSymtab();
 }
 
 int collectPGOFuncNameStrings(const std::vector<std::string> &NameStrs,
                               bool doCompression, std::string &Result) {
   uint8_t Header[16], *P = Header;
   std::string UncompressedNameStrings =
-      join(NameStrs.begin(), NameStrs.end(), StringRef(" "));
+      join(NameStrs.begin(), NameStrs.end(), getInstrProfNameSeparator());
 
   unsigned EncLen = encodeULEB128(UncompressedNameStrings.length(), P);
   P += EncLen;
 
   auto WriteStringToResult = [&](size_t CompressedLen,
                                  const std::string &InputStr) {
     EncLen = encodeULEB128(CompressedLen, P);
     P += EncLen;
if (isCompressed) {
                               UncompressedNameStrings.size());
     } else {
       NameStrings =
           StringRef(reinterpret_cast<const char *>(P), UncompressedSize);
       P += UncompressedSize;
     }
     // Now parse the name strings.
     SmallVector<StringRef, 0> Names;
-    NameStrings.split(Names, ' ');
+    NameStrings.split(Names, getInstrProfNameSeparator());
     for (StringRef &Name : Names)
       Symtab.addFuncName(Name);
 
     while (P < EndP && *P == 0)
       P++;
   }
   Symtab.finalizeSymtab();
   return 0;

llvm/trunk/unittests/ProfileData/InstrProfTest.cpp

TEST_P(MaybeSparseInstrProfTest, instr_prof_symtab_compression_test) {
   std::vector<std::string> FuncNames1;
   std::vector<std::string> FuncNames2;
   for (int I = 0; I < 3; I++) {
     std::string str;
     raw_string_ostream OS(str);
     OS << "func_" << I;
     FuncNames1.push_back(OS.str());
     str.clear();
-    OS << "fooooooooooooooo_" << I;
+    OS << "f oooooooooooooo_" << I;
     FuncNames1.push_back(OS.str());
     str.clear();
     OS << "BAR_" << I;
     FuncNames2.push_back(OS.str());
     str.clear();
     OS << "BlahblahBlahblahBar_" << I;
     FuncNames2.push_back(OS.str());
   }
for (int Padding = 0; Padding < 2; Padding++) {
       InstrProfSymtab Symtab;
       Symtab.create(StringRef(FuncNameStrings));
 
       // Now do the checks:
       // First sampling some data points:
       StringRef R = Symtab.getFuncName(IndexedInstrProf::ComputeHash(FuncNames1[0]));
       ASSERT_EQ(StringRef("func_0"), R);
       R = Symtab.getFuncName(IndexedInstrProf::ComputeHash(FuncNames1[1]));
-      ASSERT_EQ(StringRef("fooooooooooooooo_0"), R);
+      ASSERT_EQ(StringRef("f oooooooooooooo_0"), R);
       for (int I = 0; I < 3; I++) {
         std::string N[4];
         N[0] = FuncNames1[2 * I];
         N[1] = FuncNames1[2 * I + 1];
         N[2] = FuncNames2[2 * I];
         N[3] = FuncNames2[2 * I + 1];
         for (int J = 0; J < 4; J++) {
           StringRef R = Symtab.getFuncName(IndexedInstrProf::ComputeHash(N[J]));