[Support] Upstream anonymization and manipulating of BCSymbolMaps

[JDevlieghere]

Summary

This patch upstreams support for Apple's implementation of anonymization.
The code is used internally to read and write BCSymbolMaps in the embedded
bitcode workflow. We need this logic upstream in order to upstream the part of
dsymutil that deals with dSYMs generated for bitcode-enabled App Store builds.

If there's interest from the community I'd be more than happy to upstream the
anonymization pass as well.

This is a slightly modified version of the code originally written by Steven Wu.

[dexonsmith]

Thanks for working on this! I've just done a pass through for style, and I have a few nits to pick.

If there's interest from the community I'd be more than happy to upstream the
anonymization pass as well.

I don't see any reason to hold it back...

llvm/include/llvm/Support/Anonymization.h

36

Why is Alloc() listed here?

59

Not sure this comment adds any value.

62

Should this have three slashes (///) so doxygen understands it?

69

Should this be a doxygen comment? Also, it should likely start witha capital and end with a period.

73–79

Should this be a doxygen comment? Same with comments that follow.

80

I feel like this should have names for the parameters. It's not obvious from the declaration how this API is used.

82

Misspelled "implementation"; also, it's not clear to me that this comment adds value.

83

Should this have a name for the parameter?

87–88

I think this should be a doxygen comment.

96

I think I prefer = default to {}.

105

This won't serve as a vtable anchor for Anonymizer, because it's pure virtual. I think you should give it an implementation in the source file.

119

Since IR is an acronym, this seems better to me as IRPrefix.

120

I see no reason to list Anonymizer() here.

130

Variable name should start with a capital.

133–137

I would have expected Prefix and Suffix, since "pre" and "suf" don't seem entirely obvious, and IRPrefix and IRNum, since "ir" is an acronym.

llvm/lib/Support/Anonymization.cpp

22

reverse and keepPrefix should be Reverse and KeepPrefix.

[aprantl]

llvm/include/llvm/Support/Anonymization.h

42

cann you add an anonymous enum { keepPrefix = true; };

46

Reverse

59

///

[steven_wu]

Thanks for working on this Jonas. Duncan and Adrian has already covered pretty much all I want to say. A small additional comments.

llvm/include/llvm/Support/Anonymization.h

57

With the current LLVM infrastructure, it would be good to return Error to deal with the incompatible format.

llvm/unittests/Support/AnonymizationTest.cpp

15

It would be good to test looking up index doesn't exist or serialization of the reverse map as well.

[zturner]

llvm/include/llvm/Support/Anonymization.h

11

It's not entirely clear what "anonymization" means. Can you improve this comment here?

Also, the summary said it's needed for dsymutil. Does it need to be in Support?

[JDevlieghere]

Address feedback from Duncan, Adrian and Steven. Thanks everyone!

[JDevlieghere]

llvm/include/llvm/Support/Anonymization.h

11

I hope it will become more clean once I have a diff for the module pass. The latter is also the reason this lives in support, we need it there as well as in dsymutil.

[JDevlieghere]

ping

[steven_wu]

Are you planning to upstream the module pass to justify this to be part of Support library?

Otherwise, LGTM.

[JDevlieghere]

In D45930#1094500, @steven_wu wrote:

Are you planning to upstream the module pass to justify this to be part of Support library?

Otherwise, LGTM.

Thanks Steven. Definitely, I just want to make sure everyone is okay with the API before starting on that :-)

[dexonsmith]

llvm/include/llvm/Support/Anonymization.h

32

Can you explain how?

55

s/textural/textual/

107

It's not really clear what the difference is between the two maps. When should a derived class use which? (Can you add comments, either here or in the class comment, explaining?)

It's also a little strange that their names distinguish whether they are "reversible", but I don't see anything in the base class about a reverse map. Should the reverse map be moved to here?

108

Should this be IrreversibleForwardMap?

144

Since "ir" is an acronym, can we make this IRNum? That will match IRPrefix as well.

llvm/lib/Support/Anonymization.cpp

21

s/KeepPrefixfix/KeepPrefix/

28–29

It's unfortunate to hit the StringMap twice in a row like this. Is that necessary?

28–32

This code looks identical in structure to the code following for the other map. Can it be factored out into a private function that takes a MapTy&?

31–32

It might be simpler to skip the local variable:

return ForwardMap[S] = anonymizeImpl(...)

43–45

Hitting the map twice seems unnecessary here.

[dexonsmith]

llvm/include/llvm/Support/Anonymization.h

151

The virtual seems unnecessary here, since we have override. I did a quick grep of llvm/include/llvm and other headers seem to agree with me.

llvm/lib/Support/Anonymization.cpp

54

Another "fixfix" typo here.

59

Missing period at the end of the sentence. Also, I think "If S" would be more clear (but if you disagree, please make it "If the symbol").

68–71

Is there a reason this isn't inside the previous if statement? I wonder if the assertion would be obvious enough to skip in that case.

69

It's not obvious why it's reasonable to copy S here, rather than uniquing in a StringSet. Can you add a comment explaining why this won't allocate too many strings?

96

It looks like this could be const MemoryBuffer &, since Buffer isn't modified, and you assume it isn't nullptr. Is there something I'm missing from the other (yet-to-be-upstreamed) derived class?

Also a nit: it seems like the llvm:: qualifier is unnecessary.

138

Should this be "IndexLength"?

More generally, should this really be:

StringRef Index = Key.slice(...);

?

llvm/unittests/Support/AnonymizationTest.cpp

207

The .operator bool() seems funny. Does EXPECT_TRUE(E) not work? If not, I think EXPECT_TRUE(bool(E)) would be clearer than what's currently there.

211

It might be nice to add a comment saying that this is checking for version "1.0".

[JDevlieghere]

Similar functionality (limited to dsymutil) was landed a while ago.

llvm/include/llvm/Support/Anonymization.h

+//===-- Anonymization.h - String anonymization helper -----------*- C++
+//-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides helper classes to perform string anonymization, which is
+// used to hide symbol names in the IR. Because this affects the debug
+// information, the anonymizer supports generating a reversible mapping, when
+// requested, so that for example dsymutil can reverse the transformation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ANONYMIZATION_H
+#define LLVM_SUPPORT_ANONYMIZATION_H
+
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+/// Base class providing basic anonymization capability.
+class Anonymizer {
+  using MapTy = StringMap<StringRef, BumpPtrAllocator &>;
+
+public:
+  Anonymizer() : ForwardMap(64, Alloc), IrreveribleForwardMap(32, Alloc) {}
+
+  Anonymizer(const Anonymizer &) = delete;
+  Anonymizer &operator=(const Anonymizer &) = delete;
+
+  enum { keepPrefix = true };
+
+  /// Anonymize a string.
+  ///
+  /// If \p Reverse is true, the transformation must be reversible.
+  /// If \p KeepPrefix is true, the 'l' or 'L' prefix  are excluded from
+  /// anonymization.
+  StringRef anonymize(StringRef S, bool Reverse = false,
+                      bool KeepPrefix = keepPrefix);
+
+  /// Reverse lookup a string in the map.
+  Expected<StringRef> lookup(StringRef S) const { return lookupImpl(S); }
+
+  /// Write out the reverse map in textural form.
+  ///
+  /// Derived classes may wish to use a different format.
+  void writeReverseMap(raw_ostream &OS) const { writeReverseMapImpl(OS); }
+
+  /// Read back the reverse map from textural form.
+  ///
+  /// Derived classes may wish to use a different format.
+  Error readReverseMap(MemoryBuffer *Buffer) {
+    return readReverseMapImpl(Buffer);
+  }
+
+  BumpPtrAllocator &getAllocator() { return Alloc; }
+
+  /// As StringRef::copy, but will terminate with null.
+  char *copyString(StringRef S) {
+    auto Ret = allocateString(S.size());
+    std::copy(S.begin(), S.end(), Ret);
+    return Ret;
+  }
+
+  /// Look up symbol in the forward map.
+  Expected<StringRef> lookupForwardMap(StringRef Symbol) const;
+
+protected:
+  /// Derived classes will implement this method to return the newly anonymized
+  /// string. Derived classes are free to track internal state, but are not
+  /// required to (e.g. the base class tracks the reverse mapping, forward
+  /// mapping, and provides an allocator).
+  ///
+  /// The base class will only ever call this method once for unique input,
+  /// enforcing an idempotent set of calls under sequential composition.
+  virtual StringRef anonymizeImpl(StringRef S, bool Reverse,
+                                  bool KeepPrefix) = 0;
+
+  virtual Expected<StringRef> lookupImpl(StringRef S) const = 0;
+  virtual void writeReverseMapImpl(raw_ostream &OS) const = 0;
+  virtual Error readReverseMapImpl(MemoryBuffer *Buffer) = 0;
+
+  /// For sub classes, allocate some new memory for a string and ensure the
+  /// memory is terminated with a null.
+  char *allocateString(unsigned Length) {
+    assert(Length > 0 && "no length?");
+    char *P = (char *)Alloc.Allocate(Length + 1, 1);
+    P[Length] = '\0';
+    return P;
+  }
+
+  virtual ~Anonymizer() = default;
+
+private:
+  BumpPtrAllocator Alloc;
+  MapTy ForwardMap;
+  MapTy IrreveribleForwardMap;
+
+  virtual void anchor();
+};
+
+/// Stateful incrementor anonymizer.
+///
+/// Minimal stateful anonymizer, which track the number of anonymized symbols
+/// and appends that number to the end of a prefix. Thus, to get the same
+/// resulting anonymization, this must be fed the inputs in the same order.
+class IncrementAnonymizer : public Anonymizer {
+  using ReverseMapTy = std::vector<StringRef>;
+  using Anonymizer::Anonymizer;
+
+public:
+  IncrementAnonymizer(StringRef Prefix = "__hidden#", StringRef Suffix = "_",
+                      StringRef IRPrefix = "__ir_hidden#")
+      : Prefix(copyString(Prefix)), Suffix(copyString(Suffix)),
+        IRPrefix(IRPrefix) {
+    assert(!Prefix.equals(IRPrefix) &&
+           "Prefix and IRPrefix cannot be the same");
+  }
+
+protected:
+  virtual StringRef anonymizeImpl(StringRef S, bool Reverse,
+                                  bool KeepPrefix) override;
+  virtual Expected<StringRef> lookupImpl(StringRef S) const override;
+  virtual void writeReverseMapImpl(raw_ostream &OS) const override;
+  virtual Error readReverseMapImpl(MemoryBuffer *Buffer) override;
+
+private:
+  StringRef Prefix;
+  StringRef Suffix;
+  StringRef IRPrefix;
+
+  unsigned Num = 0;
+  unsigned IrNum = 0;
+
+  ReverseMapTy ReverseMap;
+
+  /// Extract the number from a key.
+  Expected<unsigned> findIndex(StringRef Key) const;
+
+  virtual void anchor() override;
+};
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_ANONYMIZATION_H

llvm/lib/Support/Anonymization.cpp

+//===-- Anonymization.cpp - String anonymization helper -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides helper classes to perform string anonymization
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/Anonymization.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FormatVariadic.h"
+
+using namespace llvm;
+
+StringRef Anonymizer::anonymize(StringRef S, bool Reverse, bool KeepPrefixfix) {
+  // Return if the string is empty.
+  if (S.empty())
+    return S;
+
+  // See if we've already encountered this value
+  if (Reverse) {
+    if (ForwardMap.count(S))
+      return ForwardMap.lookup(S);
+    auto Res = anonymizeImpl(S, Reverse, KeepPrefixfix);
+    ForwardMap[S] = Res;
+    return Res;
+  }
+
+  if (IrreveribleForwardMap.count(S))
+    return IrreveribleForwardMap.lookup(S);
+  auto Res = anonymizeImpl(S, Reverse, KeepPrefixfix);
+  IrreveribleForwardMap[S] = Res;
+  return Res;
+}
+
+Expected<StringRef> Anonymizer::lookupForwardMap(StringRef Symbol) const {
+  if (ForwardMap.count(Symbol))
+    return ForwardMap.lookup(Symbol);
+
+  return make_error<StringError>(formatv("No entry found for '{0}'", Symbol),
+                                 inconvertibleErrorCode());
+}
+
+void Anonymizer::anchor() {}
+void IncrementAnonymizer::anchor() {}
+
+StringRef IncrementAnonymizer::anonymizeImpl(StringRef S, bool Reverse,
+                                             bool KeepPrefixfix) {
+  SmallString<128> NextVal;
+  raw_svector_ostream OS(NextVal);
+
+  if (Reverse) {
+    // If symbol begins with l or L, keep that prefix
+    if (KeepPrefixfix && (S.startswith("L") || S.startswith("l")))
+      OS << S.substr(0, 1);
+
+    OS << Prefix << Num++ << Suffix;
+  } else {
+    OS << IRPrefix << IrNum++ << Suffix;
+  }
+
+  if (Reverse) {
+    ReverseMap.push_back(copyString(S));
+    assert(Num == ReverseMap.size() && "ReverseMap has wrong size");
+  }
+
+  return copyString(OS.str());
+}
+
+Expected<StringRef> IncrementAnonymizer::lookupImpl(StringRef Str) const {
+  auto Index = findIndex(Str);
+  if (!Index)
+    return Index.takeError();
+
+  if (*Index < ReverseMap.size())
+    return ReverseMap[*Index];
+
+  return make_error<StringError>(formatv("No entry found for '{0}'", Str),
+                                 inconvertibleErrorCode());
+}
+
+void IncrementAnonymizer::writeReverseMapImpl(raw_ostream &OS) const {
+  OS << "BCSymbolMap Version: 2.0\n";
+  for (auto S : ReverseMap) {
+    assert(S != "" && "failed to initialize a member");
+    OS << S << "\n";
+  }
+}
+
+Error IncrementAnonymizer::readReverseMapImpl(llvm::MemoryBuffer *Buffer) {
+  llvm::StringRef Data(Buffer->getBufferStart(), Buffer->getBufferSize());
+  llvm::StringRef LHS;
+  // Check version string first.
+  std::tie(LHS, Data) = Data.split('\n');
+  if (!LHS.startswith("BCSymbolMap Version:")) {
+    // Version string not present, assume version 1.0.
+    ReverseMap.emplace_back(copyString(LHS));
+    ++Num;
+  } else {
+    llvm::StringRef VersionStr;
+    std::tie(LHS, VersionStr) = LHS.split(':');
+    VersionStr = VersionStr.ltrim();
+    if (VersionStr != "1.0" && VersionStr != "2.0")
+      return make_error<StringError>(
+          formatv("Symbol map version '{0}' is not supported.", VersionStr),
+          inconvertibleErrorCode());
+  }
+
+  while (!Data.empty()) {
+    std::tie(LHS, Data) = Data.split('\n');
+    ReverseMap.emplace_back(copyString(LHS));
+    ++Num;
+  }
+
+  return Error::success();
+}
+
+Expected<unsigned> IncrementAnonymizer::findIndex(StringRef Key) const {
+  const size_t PrefixIdx = Key.find(Prefix);
+  if (PrefixIdx == StringRef::npos)
+    return make_error<StringError>(
+        formatv("Invalid key '{0}' does not contain suffix '{1}'", Key, Prefix),
+        inconvertibleErrorCode());
+
+  const size_t SuffixIdx = Key.rfind(Suffix);
+  if (PrefixIdx == StringRef::npos)
+    return make_error<StringError>(
+        formatv("Invalid key '{0}' does not contain suffix '{1}'", Key, Suffix),
+        inconvertibleErrorCode());
+
+  const size_t IndexBegin = PrefixIdx + Prefix.size();
+  const size_t IndexLengt = SuffixIdx - IndexBegin;
+
+  if (IndexBegin + IndexLengt >= Key.size())
+    return make_error<StringError>(formatv("Invalid key '{0}'", Key),
+                                   inconvertibleErrorCode());
+
+  unsigned long long Ret;
+  if (auto Error =
+          getAsUnsignedInteger({Key.data() + IndexBegin, IndexLengt}, 10, Ret))
+    return make_error<StringError>(
+        formatv("Unable to parse index from key '{0}'", Key),
+        inconvertibleErrorCode());
+  return Ret;
+};

llvm/lib/Support/CMakeLists.txt

elseif( CMAKE_HOST_UNIX )
   set(system_libs ${system_libs} ${LLVM_PTHREAD_LIB})
   if( UNIX AND NOT (BEOS OR HAIKU) )
     set(system_libs ${system_libs} m)
   endif()
 endif( MSVC OR MINGW )
 
 add_llvm_library(LLVMSupport
   AMDGPUMetadata.cpp
+  Anonymization.cpp
   APFloat.cpp
   APInt.cpp
   APSInt.cpp
   ARMBuildAttrs.cpp
   ARMAttributeParser.cpp
   ARMWinEH.cpp
   Allocator.cpp
   BinaryStreamError.cpp

llvm/unittests/Support/AnonymizationTest.cpp

+//===---------- llvm/unittest/Support/AnonymizationTest.cpp ---------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/Anonymization.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+static constexpr std::array<const char *, 3> Hidden = {
+    {"__hidden#0_", "__hidden#1_", "__hidden#2_"}};
+static constexpr std::array<const char *, 3> IRHidden = {
+    {"__ir_hidden#0_", "__ir_hidden#1_", "__ir_hidden#2_"}};
+static constexpr std::array<const char *, 3> Symbol = {{"foo", "bar", "baz"}};
+
+TEST(AnonymizationTest, anonymizeSimple) {
+  IncrementAnonymizer Anonymizer;
+  for (unsigned J = 0, E = 2; J < E; ++J) {
+    for (unsigned I = 0, E = std::tuple_size<decltype(Hidden)>::value; I < E;
+         ++I) {
+      EXPECT_EQ(StringRef(IRHidden[I]), Anonymizer.anonymize(Symbol[I]));
+    }
+  }
+}
+
+TEST(AnonymizationTest, anonymizeReverse) {
+  IncrementAnonymizer Anonymizer;
+  for (unsigned J = 0, E = 2; J < E; ++J) {
+    for (unsigned I = 0, E = std::tuple_size<decltype(Hidden)>::value; I < E;
+         ++I) {
+      EXPECT_EQ(StringRef(Hidden[I]), Anonymizer.anonymize(Symbol[I], true));
+    }
+  }
+}
+
+TEST(AnonymizationTest, anonymizeKeepPrefix) {
+  IncrementAnonymizer Anonymizer;
+  for (unsigned J = 0, E = 2; J < E; ++J) {
+    for (unsigned I = 0, E = std::tuple_size<decltype(Hidden)>::value; I < E;
+         ++I) {
+      EXPECT_EQ(StringRef(Hidden[I]),
+                Anonymizer.anonymize(Symbol[I], true, true));
+    }
+  }
+}
+
+TEST(AnonymizationTest, anonymizeKeepPrefixl) {
+  IncrementAnonymizer Anonymizer;
+  for (unsigned J = 0, E = 2; J < E; ++J) {
+    for (unsigned I = 0, E = std::tuple_size<decltype(Hidden)>::value; I < E;
+         ++I) {
+      EXPECT_EQ(
+          (Twine("l") + Hidden[I]).str(),
+          Anonymizer.anonymize((Twine("l") + Symbol[I]).str(), true, true));
+    }
+  }
+}
+
+TEST(AnonymizationTest, anonymizeKeepPrefixL) {
+  IncrementAnonymizer Anonymizer;
+  for (unsigned J = 0, E = 2; J < E; ++J) {
+    for (unsigned I = 0, E = std::tuple_size<decltype(Hidden)>::value; I < E;
+         ++I) {
+      EXPECT_EQ(
+          (Twine("L") + Hidden[I]).str(),
+          Anonymizer.anonymize((Twine("L") + Symbol[I]).str(), true, true));
+    }
+  }
+}
+
+TEST(AnonymizationTest, lookupInvalid) {
+  IncrementAnonymizer Anonymizer;
+  EXPECT_EQ("__ir_hidden#0_", Anonymizer.anonymize("foo"));
+  EXPECT_EQ("__hidden#0_", Anonymizer.anonymize("foo", true));
+  EXPECT_EQ("__hidden#1_", Anonymizer.anonymize("bar", true));
+
+  // We didn't set the 'reverse' flag so we get an __ir__hidden which we cannot
+  // reverse.
+  {
+    auto Foo = Anonymizer.lookup("__ir_hidden#0_");
+    EXPECT_FALSE(Foo.operator bool());
+    llvm::consumeError(Foo.takeError());
+  }
+
+  // Make sure we don't accept broken input.
+  {
+    auto Foo = Anonymizer.lookup("__ir_hidden0_");
+    EXPECT_FALSE(Foo.operator bool());
+    llvm::consumeError(Foo.takeError());
+
+    auto Bar = Anonymizer.lookup("__hidden#1");
+    EXPECT_FALSE(Bar.operator bool());
+    llvm::consumeError(Bar.takeError());
+
+    auto Baz = Anonymizer.lookup("__ir_hidden#2_");
+    EXPECT_FALSE(Baz.operator bool());
+    llvm::consumeError(Baz.takeError());
+  }
+
+  // Make sure we don't accept invalid indices.
+  {
+    auto Foo = Anonymizer.lookup("__hidden#2_");
+    EXPECT_FALSE(Foo.operator bool());
+    llvm::consumeError(Foo.takeError());
+  }
+}
+
+TEST(AnonymizationTest, lookupValid) {
+  IncrementAnonymizer Anonymizer;
+  EXPECT_EQ("__hidden#0_", Anonymizer.anonymize("foo", true));
+  EXPECT_EQ("__hidden#1_", Anonymizer.anonymize("bar", true));
+
+  // This time we did set the reverse flag, so we should be able to find the
+  // original string.
+  {
+    auto Foo = Anonymizer.lookup("__hidden#0_");
+    EXPECT_TRUE(Foo.operator bool());
+    EXPECT_EQ("foo", *Foo);
+
+    auto Bar = Anonymizer.lookup("__hidden#1_");
+    EXPECT_TRUE(Bar.operator bool());
+    EXPECT_EQ("bar", *Bar);
+  }
+}
+
+TEST(AnonymizationTest, customPrefixSuffix) {
+  IncrementAnonymizer Anonymizer("_", "_");
+  EXPECT_EQ("_0_", Anonymizer.anonymize("foo", true));
+  EXPECT_EQ("_1_", Anonymizer.anonymize("bar", true));
+
+  // Ensure we accept input with the same prefix and suffix.
+  {
+    auto Foo = Anonymizer.lookup("_0_");
+    EXPECT_TRUE(Foo.operator bool());
+    EXPECT_EQ("foo", *Foo);
+
+    auto Bar = Anonymizer.lookup("_1_");
+    EXPECT_TRUE(Bar.operator bool());
+    EXPECT_EQ("bar", *Bar);
+  }
+
+  // Ensure we reject missing prefix.
+  {
+    auto Foo = Anonymizer.lookup("0_");
+    EXPECT_FALSE(Foo.operator bool());
+    llvm::consumeError(Foo.takeError());
+  }
+
+  // Ensure we reject missing suffix.
+  {
+    auto Foo = Anonymizer.lookup("_0");
+    EXPECT_FALSE(Foo.operator bool());
+    llvm::consumeError(Foo.takeError());
+  }
+
+  // Ensure we reject missing prefix and suffix.
+  {
+    auto Foo = Anonymizer.lookup("0");
+    EXPECT_FALSE(Foo.operator bool());
+    llvm::consumeError(Foo.takeError());
+  }
+}
+
+TEST(AnonymizationTest, serialization) {
+  IncrementAnonymizer Anonymizer;
+  EXPECT_EQ("__hidden#0_", Anonymizer.anonymize("foo", true));
+  EXPECT_EQ("__hidden#1_", Anonymizer.anonymize("bar", true));
+  EXPECT_EQ("__hidden#2_", Anonymizer.anonymize("baz", true));
+
+  std::string Expected = "BCSymbolMap Version: 2.0\nfoo\nbar\nbaz\n";
+  std::string Serialized;
+
+  llvm::raw_string_ostream OS(Serialized);
+  Anonymizer.writeReverseMap(OS);
+  OS.flush();
+
+  EXPECT_EQ(Expected, Serialized);
+}
+
+TEST(AnonymizationTest, deserialization) {
+  std::string Serialized = "BCSymbolMap Version: 2.0\nfoo\nbar\nbaz\n";
+  std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Serialized);
+
+  IncrementAnonymizer Anonymizer;
+  auto E = Anonymizer.readReverseMap(Buffer.get());
+  EXPECT_FALSE(E.operator bool());
+
+  for (unsigned I = 0, E = std::tuple_size<decltype(Hidden)>::value; I < E;
+       ++I) {
+    auto S = Anonymizer.lookup(Hidden[I]);
+    EXPECT_TRUE(S.operator bool());
+    EXPECT_EQ(StringRef(Symbol[I]), *S);
+  }
+}
+
+TEST(AnonymizationTest, deserializationInvalidVersion) {
+  std::string Serialized = "BCSymbolMap Version: 3.0\nfoo\nbar\nbaz\n";
+  std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Serialized);
+
+  IncrementAnonymizer Anonymizer;
+  auto E = Anonymizer.readReverseMap(Buffer.get());
+  EXPECT_TRUE(E.operator bool());
+  llvm::consumeError(std::move(E));
+}
+
+TEST(AnonymizationTest, deserializationNoVersion) {
+  std::string Serialized = "foo\nbar\nbaz\n";
+  std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Serialized);
+
+  IncrementAnonymizer Anonymizer;
+  auto E = Anonymizer.readReverseMap(Buffer.get());
+  EXPECT_FALSE(E.operator bool());
+
+  for (unsigned I = 0, E = std::tuple_size<decltype(Hidden)>::value; I < E;
+       ++I) {
+    auto S = Anonymizer.lookup(Hidden[I]);
+    EXPECT_TRUE(S.operator bool());
+    EXPECT_EQ(StringRef(Symbol[I]), *S);
+  }
+}

llvm/unittests/Support/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_llvm_unittest(SupportTests
   AlignOfTest.cpp
   AllocatorTest.cpp
+  AnonymizationTest.cpp
   ARMAttributeParser.cpp
   ArrayRecyclerTest.cpp
   BinaryStreamTest.cpp
   BlockFrequencyTest.cpp
   BranchProbabilityTest.cpp
   CachePruningTest.cpp
   CrashRecoveryTest.cpp
   Casting.cpp