This is an archive of the discontinued LLVM Phabricator instance.

	//===- StringPool.h - Intern'd string pool ----------------------- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file declares an interned string pool with separately malloc and
	// reference counted entries. This can reduce the cost of strings by using the
	// same storage for identical strings.
	//
	// To intern a string:
	//
	// StringPool Pool;
	// PooledStringPtr Str = Pool.intern("wakka wakka");
	//
	// To use the value of an interned string, use operator bool and operator*:
	//
	// if (Str)
	// cerr << "the string is" << *Str << "\n";
	//
	// Pooled strings are immutable, but you can change a PooledStringPtr to point
	// to another instance. So that interned strings can eventually be freed,
	// strings in the string pool are reference-counted (automatically).
	//
	//===----------------------------------------------------------------------===//

	#ifndef LLVM_SUPPORT_STRINGPOOL_H
	#define LLVM_SUPPORT_STRINGPOOL_H

	#include "llvm/ADT/StringMap.h"

	namespace llvm {

	class PooledStringPtr;

	/// StringPool - An interned string pool. Use the intern method to add a
	/// string. Strings are removed automatically as PooledStringPtrs are
	/// destroyed.
	class StringPool {
	/// PooledString - This is the value of an entry in the pool's interning
	/// table.
	struct PooledString {
	StringPool *pool = nullptr; ///< So the string can remove itself.
	unsigned refcount = 0; ///< Number of referencing PooledStringPtrs.

	public:
	PooledString() = default;
	};

	friend class PooledStringPtr;
	using Entry = StringMapEntry<PooledString>;
	StringMap<PooledString> internTable;

	public:
	StringPool();
	~StringPool();

	/// intern - Adds a string to the pool and returns a reference-counted
	/// pointer to it. No additional memory is allocated if the string already
	/// exists in the pool.
	PooledStringPtr intern(StringRef string);

	/// empty - Checks whether the pool is empty. Returns true if so.
	bool empty() const { return internTable.empty(); }
	};

	/// PooledStringPtr - A pointer to an interned string. Use operator bool to
	/// test whether the pointer is valid, and operator * to get the string if so.
	/// This is a lightweight value class with storage requirements equivalent to
	/// a single pointer, but it does have reference-counting overhead when
	/// copied.
	class PooledStringPtr {
	using Entry = StringPool::Entry;
	Entry *entry = nullptr;

	public:
	PooledStringPtr() = default;

	explicit PooledStringPtr(Entry *e) : entry(e) {
	if (entry)
	++entry->getValue().refcount;
	}

	PooledStringPtr(const PooledStringPtr &that) : entry(that.entry) {
	if (entry)
	++entry->getValue().refcount;
	}

	PooledStringPtr &operator=(const PooledStringPtr &that) {
	if (entry != that.entry) {
	clear();
	entry = that.entry;
	if (entry)
	++entry->getValue().refcount;
	}
	return *this;
	}

	void clear() {
	if (!entry)
	return;
	if (--entry->getValue().refcount == 0) {
	entry->getValue().pool->internTable.remove(entry);
	MallocAllocator allocator;
	entry->Destroy(allocator);
	}
	entry = nullptr;
	}

	~PooledStringPtr() { clear(); }

	const char *begin() const {
	assert(*this && "Attempt to dereference empty PooledStringPtr!");
	return entry->getKeyData();
	}

	const char *end() const {
	assert(*this && "Attempt to dereference empty PooledStringPtr!");
	return entry->getKeyData() + entry->getKeyLength();
	}

	unsigned size() const {
	assert(*this && "Attempt to dereference empty PooledStringPtr!");
	return entry->getKeyLength();
	}

	const char operator() const { return begin(); }
	explicit operator bool() const { return entry != nullptr; }

	bool operator==(const PooledStringPtr &that) const {
	return entry == that.entry;
	}
	bool operator!=(const PooledStringPtr &that) const {
	return entry != that.entry;
	}
	};

	} // end namespace llvm

	#endif // LLVM_SUPPORT_STRINGPOOL_H

llvm/lib/Support/CMakeLists.txt

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Lines	add_llvm_component_library(LLVMSupport
Signposts.cpp		Signposts.cpp
SmallPtrSet.cpp		SmallPtrSet.cpp
SmallVector.cpp		SmallVector.cpp
SourceMgr.cpp		SourceMgr.cpp
SpecialCaseList.cpp		SpecialCaseList.cpp
Statistic.cpp		Statistic.cpp
StringExtras.cpp		StringExtras.cpp
StringMap.cpp		StringMap.cpp
StringPool.cpp
StringSaver.cpp		StringSaver.cpp
StringRef.cpp		StringRef.cpp
SymbolRemappingReader.cpp		SymbolRemappingReader.cpp
SystemUtils.cpp		SystemUtils.cpp
TarWriter.cpp		TarWriter.cpp
TargetParser.cpp		TargetParser.cpp
ThreadPool.cpp		ThreadPool.cpp
TimeProfiler.cpp		TimeProfiler.cpp
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/lib/Support/StringPool.cpp

This file was deleted.

	//===-- StringPool.cpp - Intern'd string pool -----------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file implements the StringPool class.
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/Support/StringPool.h"
	using namespace llvm;

	StringPool::StringPool() {}

	StringPool::~StringPool() {
	assert(internTable.empty() && "PooledStringPtr leaked!");
	}

	PooledStringPtr StringPool::intern(StringRef key) {
	auto it = internTable.find(key);
	if (it != internTable.end())
	return PooledStringPtr(&*it);

	MallocAllocator allocator;
	auto *entry = Entry::Create(key, allocator);
	entry->getValue().pool = this;
	internTable.insert(entry);

	return PooledStringPtr(entry);
	}

llvm/unittests/Support/CMakeLists.txt

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines	add_llvm_unittest(SupportTests
ProgramTest.cpp		ProgramTest.cpp
RegexTest.cpp		RegexTest.cpp
ReverseIterationTest.cpp		ReverseIterationTest.cpp
ReplaceFileTest.cpp		ReplaceFileTest.cpp
RISCVAttributeParserTest.cpp		RISCVAttributeParserTest.cpp
ScaledNumberTest.cpp		ScaledNumberTest.cpp
SourceMgrTest.cpp		SourceMgrTest.cpp
SpecialCaseListTest.cpp		SpecialCaseListTest.cpp
StringPool.cpp
SwapByteOrderTest.cpp		SwapByteOrderTest.cpp
SymbolRemappingReaderTest.cpp		SymbolRemappingReaderTest.cpp
TarWriterTest.cpp		TarWriterTest.cpp
TargetParserTest.cpp		TargetParserTest.cpp
TaskQueueTest.cpp		TaskQueueTest.cpp
ThreadLocalTest.cpp		ThreadLocalTest.cpp
ThreadPool.cpp		ThreadPool.cpp
Threading.cpp		Threading.cpp
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/unittests/Support/StringPool.cpp

This file was deleted.

	//===- llvm/unittest/Support/StringPoiil.cpp - StringPool tests -----------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/Support/StringPool.h"
	#include "gtest/gtest.h"

	using namespace llvm;

	namespace {

	TEST(PooledStringPtrTest, OperatorEquals) {
	StringPool pool;
	const PooledStringPtr a = pool.intern("a");
	const PooledStringPtr b = pool.intern("b");
	EXPECT_FALSE(a == b);
	}

	TEST(PooledStringPtrTest, OperatorNotEquals) {
	StringPool pool;
	const PooledStringPtr a = pool.intern("a");
	const PooledStringPtr b = pool.intern("b");
	EXPECT_TRUE(a != b);
	}

	}

This is an archive of the discontinued LLVM Phabricator instance.

Remove the llvm/Support/StringPool.h file and related support now that it has no clients. A plain old StringSet<> is a better replacement.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 258198

llvm/include/llvm/Support/StringPool.h

llvm/lib/Support/CMakeLists.txt

llvm/lib/Support/StringPool.cpp

llvm/unittests/Support/CMakeLists.txt

llvm/unittests/Support/StringPool.cpp

Remove the llvm/Support/StringPool.h file and related support now that it has no clients. A plain old StringSet<> is a better replacement.
ClosedPublic