forked from OSchip/llvm-project
337 lines
11 KiB
C++
337 lines
11 KiB
C++
//===-- ConstString.cpp -----------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Core/ConstString.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <array>
|
|
#include <mutex>
|
|
|
|
// Other libraries and framework includes
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
#include "llvm/Support/RWMutex.h"
|
|
|
|
// Project includes
|
|
#include "lldb/Core/Stream.h"
|
|
|
|
using namespace lldb_private;
|
|
|
|
class Pool {
|
|
public:
|
|
typedef const char *StringPoolValueType;
|
|
typedef llvm::StringMap<StringPoolValueType, llvm::BumpPtrAllocator>
|
|
StringPool;
|
|
typedef llvm::StringMapEntry<StringPoolValueType> StringPoolEntryType;
|
|
|
|
static StringPoolEntryType &
|
|
GetStringMapEntryFromKeyData(const char *keyData) {
|
|
char *ptr = const_cast<char *>(keyData) - sizeof(StringPoolEntryType);
|
|
return *reinterpret_cast<StringPoolEntryType *>(ptr);
|
|
}
|
|
|
|
size_t GetConstCStringLength(const char *ccstr) const {
|
|
if (ccstr != nullptr) {
|
|
const uint8_t h = hash(llvm::StringRef(ccstr));
|
|
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
|
|
const StringPoolEntryType &entry = GetStringMapEntryFromKeyData(ccstr);
|
|
return entry.getKey().size();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
StringPoolValueType GetMangledCounterpart(const char *ccstr) const {
|
|
if (ccstr != nullptr) {
|
|
const uint8_t h = hash(llvm::StringRef(ccstr));
|
|
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
|
|
return GetStringMapEntryFromKeyData(ccstr).getValue();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool SetMangledCounterparts(const char *key_ccstr, const char *value_ccstr) {
|
|
if (key_ccstr != nullptr && value_ccstr != nullptr) {
|
|
{
|
|
const uint8_t h = hash(llvm::StringRef(key_ccstr));
|
|
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
|
|
GetStringMapEntryFromKeyData(key_ccstr).setValue(value_ccstr);
|
|
}
|
|
{
|
|
const uint8_t h = hash(llvm::StringRef(value_ccstr));
|
|
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
|
|
GetStringMapEntryFromKeyData(value_ccstr).setValue(key_ccstr);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const char *GetConstCString(const char *cstr) {
|
|
if (cstr != nullptr)
|
|
return GetConstCStringWithLength(cstr, strlen(cstr));
|
|
return nullptr;
|
|
}
|
|
|
|
const char *GetConstCStringWithLength(const char *cstr, size_t cstr_len) {
|
|
if (cstr != nullptr)
|
|
return GetConstCStringWithStringRef(llvm::StringRef(cstr, cstr_len));
|
|
return nullptr;
|
|
}
|
|
|
|
const char *GetConstCStringWithStringRef(const llvm::StringRef &string_ref) {
|
|
if (string_ref.data()) {
|
|
const uint8_t h = hash(string_ref);
|
|
|
|
{
|
|
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
|
|
auto it = m_string_pools[h].m_string_map.find(string_ref);
|
|
if (it != m_string_pools[h].m_string_map.end())
|
|
return it->getKeyData();
|
|
}
|
|
|
|
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
|
|
StringPoolEntryType &entry =
|
|
*m_string_pools[h]
|
|
.m_string_map.insert(std::make_pair(string_ref, nullptr))
|
|
.first;
|
|
return entry.getKeyData();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const char *
|
|
GetConstCStringAndSetMangledCounterPart(const char *demangled_cstr,
|
|
const char *mangled_ccstr) {
|
|
if (demangled_cstr != nullptr) {
|
|
const char *demangled_ccstr = nullptr;
|
|
|
|
{
|
|
llvm::StringRef string_ref(demangled_cstr);
|
|
const uint8_t h = hash(string_ref);
|
|
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
|
|
|
|
// Make string pool entry with the mangled counterpart already set
|
|
StringPoolEntryType &entry =
|
|
*m_string_pools[h]
|
|
.m_string_map.insert(std::make_pair(string_ref, mangled_ccstr))
|
|
.first;
|
|
|
|
// Extract the const version of the demangled_cstr
|
|
demangled_ccstr = entry.getKeyData();
|
|
}
|
|
|
|
{
|
|
// Now assign the demangled const string as the counterpart of the
|
|
// mangled const string...
|
|
const uint8_t h = hash(llvm::StringRef(mangled_ccstr));
|
|
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
|
|
GetStringMapEntryFromKeyData(mangled_ccstr).setValue(demangled_ccstr);
|
|
}
|
|
|
|
// Return the constant demangled C string
|
|
return demangled_ccstr;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const char *GetConstTrimmedCStringWithLength(const char *cstr,
|
|
size_t cstr_len) {
|
|
if (cstr != nullptr) {
|
|
const size_t trimmed_len = std::min<size_t>(strlen(cstr), cstr_len);
|
|
return GetConstCStringWithLength(cstr, trimmed_len);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Return the size in bytes that this object and any items in its
|
|
// collection of uniqued strings + data count values takes in
|
|
// memory.
|
|
//------------------------------------------------------------------
|
|
size_t MemorySize() const {
|
|
size_t mem_size = sizeof(Pool);
|
|
for (const auto &pool : m_string_pools) {
|
|
llvm::sys::SmartScopedReader<false> rlock(pool.m_mutex);
|
|
for (const auto &entry : pool.m_string_map)
|
|
mem_size += sizeof(StringPoolEntryType) + entry.getKey().size();
|
|
}
|
|
return mem_size;
|
|
}
|
|
|
|
protected:
|
|
uint8_t hash(const llvm::StringRef &s) const {
|
|
uint32_t h = llvm::HashString(s);
|
|
return ((h >> 24) ^ (h >> 16) ^ (h >> 8) ^ h) & 0xff;
|
|
}
|
|
|
|
struct PoolEntry {
|
|
mutable llvm::sys::SmartRWMutex<false> m_mutex;
|
|
StringPool m_string_map;
|
|
};
|
|
|
|
std::array<PoolEntry, 256> m_string_pools;
|
|
};
|
|
|
|
//----------------------------------------------------------------------
|
|
// Frameworks and dylibs aren't supposed to have global C++
|
|
// initializers so we hide the string pool in a static function so
|
|
// that it will get initialized on the first call to this static
|
|
// function.
|
|
//
|
|
// Note, for now we make the string pool a pointer to the pool, because
|
|
// we can't guarantee that some objects won't get destroyed after the
|
|
// global destructor chain is run, and trying to make sure no destructors
|
|
// touch ConstStrings is difficult. So we leak the pool instead.
|
|
//----------------------------------------------------------------------
|
|
static Pool &StringPool() {
|
|
static std::once_flag g_pool_initialization_flag;
|
|
static Pool *g_string_pool = nullptr;
|
|
|
|
std::call_once(g_pool_initialization_flag,
|
|
[]() { g_string_pool = new Pool(); });
|
|
|
|
return *g_string_pool;
|
|
}
|
|
|
|
ConstString::ConstString(const char *cstr)
|
|
: m_string(StringPool().GetConstCString(cstr)) {}
|
|
|
|
ConstString::ConstString(const char *cstr, size_t cstr_len)
|
|
: m_string(StringPool().GetConstCStringWithLength(cstr, cstr_len)) {}
|
|
|
|
ConstString::ConstString(const llvm::StringRef &s)
|
|
: m_string(StringPool().GetConstCStringWithLength(s.data(), s.size())) {}
|
|
|
|
bool ConstString::operator<(const ConstString &rhs) const {
|
|
if (m_string == rhs.m_string)
|
|
return false;
|
|
|
|
llvm::StringRef lhs_string_ref(m_string,
|
|
StringPool().GetConstCStringLength(m_string));
|
|
llvm::StringRef rhs_string_ref(
|
|
rhs.m_string, StringPool().GetConstCStringLength(rhs.m_string));
|
|
|
|
// If both have valid C strings, then return the comparison
|
|
if (lhs_string_ref.data() && rhs_string_ref.data())
|
|
return lhs_string_ref < rhs_string_ref;
|
|
|
|
// Else one of them was nullptr, so if LHS is nullptr then it is less than
|
|
return lhs_string_ref.data() == nullptr;
|
|
}
|
|
|
|
Stream &lldb_private::operator<<(Stream &s, const ConstString &str) {
|
|
const char *cstr = str.GetCString();
|
|
if (cstr != nullptr)
|
|
s << cstr;
|
|
|
|
return s;
|
|
}
|
|
|
|
size_t ConstString::GetLength() const {
|
|
return StringPool().GetConstCStringLength(m_string);
|
|
}
|
|
|
|
bool ConstString::Equals(const ConstString &lhs, const ConstString &rhs,
|
|
const bool case_sensitive) {
|
|
if (lhs.m_string == rhs.m_string)
|
|
return true;
|
|
|
|
// Since the pointers weren't equal, and identical ConstStrings always have
|
|
// identical pointers,
|
|
// the result must be false for case sensitive equality test.
|
|
if (case_sensitive)
|
|
return false;
|
|
|
|
// perform case insensitive equality test
|
|
llvm::StringRef lhs_string_ref(
|
|
lhs.m_string, StringPool().GetConstCStringLength(lhs.m_string));
|
|
llvm::StringRef rhs_string_ref(
|
|
rhs.m_string, StringPool().GetConstCStringLength(rhs.m_string));
|
|
return lhs_string_ref.equals_lower(rhs_string_ref);
|
|
}
|
|
|
|
int ConstString::Compare(const ConstString &lhs, const ConstString &rhs,
|
|
const bool case_sensitive) {
|
|
// If the iterators are the same, this is the same string
|
|
const char *lhs_cstr = lhs.m_string;
|
|
const char *rhs_cstr = rhs.m_string;
|
|
if (lhs_cstr == rhs_cstr)
|
|
return 0;
|
|
if (lhs_cstr && rhs_cstr) {
|
|
llvm::StringRef lhs_string_ref(
|
|
lhs_cstr, StringPool().GetConstCStringLength(lhs_cstr));
|
|
llvm::StringRef rhs_string_ref(
|
|
rhs_cstr, StringPool().GetConstCStringLength(rhs_cstr));
|
|
|
|
if (case_sensitive) {
|
|
return lhs_string_ref.compare(rhs_string_ref);
|
|
} else {
|
|
return lhs_string_ref.compare_lower(rhs_string_ref);
|
|
}
|
|
}
|
|
|
|
if (lhs_cstr)
|
|
return +1; // LHS isn't nullptr but RHS is
|
|
else
|
|
return -1; // LHS is nullptr but RHS isn't
|
|
}
|
|
|
|
void ConstString::Dump(Stream *s, const char *fail_value) const {
|
|
if (s != nullptr) {
|
|
const char *cstr = AsCString(fail_value);
|
|
if (cstr != nullptr)
|
|
s->PutCString(cstr);
|
|
}
|
|
}
|
|
|
|
void ConstString::DumpDebug(Stream *s) const {
|
|
const char *cstr = GetCString();
|
|
size_t cstr_len = GetLength();
|
|
// Only print the parens if we have a non-nullptr string
|
|
const char *parens = cstr ? "\"" : "";
|
|
s->Printf("%*p: ConstString, string = %s%s%s, length = %" PRIu64,
|
|
static_cast<int>(sizeof(void *) * 2),
|
|
static_cast<const void *>(this), parens, cstr, parens,
|
|
static_cast<uint64_t>(cstr_len));
|
|
}
|
|
|
|
void ConstString::SetCString(const char *cstr) {
|
|
m_string = StringPool().GetConstCString(cstr);
|
|
}
|
|
|
|
void ConstString::SetString(const llvm::StringRef &s) {
|
|
m_string = StringPool().GetConstCStringWithLength(s.data(), s.size());
|
|
}
|
|
|
|
void ConstString::SetCStringWithMangledCounterpart(const char *demangled,
|
|
const ConstString &mangled) {
|
|
m_string = StringPool().GetConstCStringAndSetMangledCounterPart(
|
|
demangled, mangled.m_string);
|
|
}
|
|
|
|
bool ConstString::GetMangledCounterpart(ConstString &counterpart) const {
|
|
counterpart.m_string = StringPool().GetMangledCounterpart(m_string);
|
|
return (bool)counterpart;
|
|
}
|
|
|
|
void ConstString::SetCStringWithLength(const char *cstr, size_t cstr_len) {
|
|
m_string = StringPool().GetConstCStringWithLength(cstr, cstr_len);
|
|
}
|
|
|
|
void ConstString::SetTrimmedCStringWithLength(const char *cstr,
|
|
size_t cstr_len) {
|
|
m_string = StringPool().GetConstTrimmedCStringWithLength(cstr, cstr_len);
|
|
}
|
|
|
|
size_t ConstString::StaticMemorySize() {
|
|
// Get the size of the static string pool
|
|
return StringPool().MemorySize();
|
|
}
|