}
// Copy the underlying data of the symbol into the owned arena.
-static void own(Symbol &S, DenseSet<StringRef> &Strings,
+static void own(Symbol &S, llvm::UniqueStringSaver &Strings,
BumpPtrAllocator &Arena) {
// Intern replaces V with a reference to the same string owned by the arena.
- auto Intern = [&](StringRef &V) {
- auto R = Strings.insert(V);
- if (R.second) { // New entry added to the table, copy the string.
- *R.first = V.copy(Arena);
- }
- V = *R.first;
- };
+ auto Intern = [&](StringRef &V) { V = Strings.save(V); };
// We need to copy every StringRef field onto the arena.
Intern(S.Name);
auto R = SymbolIndex.try_emplace(S.ID, Symbols.size());
if (R.second) {
Symbols.push_back(S);
- own(Symbols.back(), Strings, Arena);
+ own(Symbols.back(), UniqueStrings, Arena);
} else {
auto &Copy = Symbols[R.first->second] = S;
- own(Copy, Strings, Arena);
+ own(Copy, UniqueStrings, Arena);
}
}
[](const Symbol &L, const Symbol &R) { return L.ID < R.ID; });
// We may have unused strings from overwritten symbols. Build a new arena.
BumpPtrAllocator NewArena;
- DenseSet<StringRef> Strings;
+ llvm::UniqueStringSaver Strings(NewArena);
for (auto &S : Symbols)
own(S, Strings, NewArena);
return SymbolSlab(std::move(NewArena), std::move(Symbols));
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/StringSaver.h"
#include <array>
#include <string>
// The frozen SymbolSlab will use less memory.
class Builder {
public:
+ Builder() : UniqueStrings(Arena) {}
+
// Adds a symbol, overwriting any existing one with the same ID.
// This is a deep copy: underlying strings will be owned by the slab.
void insert(const Symbol &S);
private:
llvm::BumpPtrAllocator Arena;
// Intern table for strings. Contents are on the arena.
- llvm::DenseSet<llvm::StringRef> Strings;
+ llvm::UniqueStringSaver UniqueStrings;
std::vector<Symbol> Symbols;
// Values are indices into Symbols vector.
llvm::DenseMap<SymbolID, size_t> SymbolIndex;