diff options
Diffstat (limited to 'contrib/llvm-project/lldb/source/Core/DataFileCache.cpp')
| -rw-r--r-- | contrib/llvm-project/lldb/source/Core/DataFileCache.cpp | 322 |
1 files changed, 322 insertions, 0 deletions
diff --git a/contrib/llvm-project/lldb/source/Core/DataFileCache.cpp b/contrib/llvm-project/lldb/source/Core/DataFileCache.cpp new file mode 100644 index 000000000000..a8127efc1df0 --- /dev/null +++ b/contrib/llvm-project/lldb/source/Core/DataFileCache.cpp @@ -0,0 +1,322 @@ +//===-- DataFileCache.cpp -------------------------------------------------===// +// +// 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 "lldb/Core/DataFileCache.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/ModuleList.h" +#include "lldb/Host/FileSystem.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Utility/DataEncoder.h" +#include "lldb/Utility/LLDBLog.h" +#include "lldb/Utility/Log.h" +#include "llvm/Support/CachePruning.h" + +using namespace lldb_private; + + +llvm::CachePruningPolicy DataFileCache::GetLLDBIndexCachePolicy() { + static llvm::CachePruningPolicy policy; + static llvm::once_flag once_flag; + + llvm::call_once(once_flag, []() { + // Prune the cache based off of the LLDB settings each time we create a + // cache object. + ModuleListProperties &properties = + ModuleList::GetGlobalModuleListProperties(); + // Only scan once an hour. If we have lots of debug sessions we don't want + // to scan this directory too often. A timestamp file is written to the + // directory to ensure different processes don't scan the directory too + // often. This setting doesn't mean that a thread will continually scan the + // cache directory within this process. + policy.Interval = std::chrono::hours(1); + // Get the user settings for pruning. + policy.MaxSizeBytes = properties.GetLLDBIndexCacheMaxByteSize(); + policy.MaxSizePercentageOfAvailableSpace = + properties.GetLLDBIndexCacheMaxPercent(); + policy.Expiration = + std::chrono::hours(properties.GetLLDBIndexCacheExpirationDays() * 24); + }); + return policy; +} + +DataFileCache::DataFileCache(llvm::StringRef path, llvm::CachePruningPolicy policy) { + m_cache_dir.SetPath(path); + pruneCache(path, policy); + + // This lambda will get called when the data is gotten from the cache and + // also after the data was set for a given key. We only need to take + // ownership of the data if we are geting the data, so we use the + // m_take_ownership member variable to indicate if we need to take + // ownership. + + auto add_buffer = [this](unsigned task, const llvm::Twine &moduleName, + std::unique_ptr<llvm::MemoryBuffer> m) { + if (m_take_ownership) + m_mem_buff_up = std::move(m); + }; + llvm::Expected<llvm::FileCache> cache_or_err = + llvm::localCache("LLDBModuleCache", "lldb-module", path, add_buffer); + if (cache_or_err) + m_cache_callback = std::move(*cache_or_err); + else { + Log *log = GetLog(LLDBLog::Modules); + LLDB_LOG_ERROR(log, cache_or_err.takeError(), + "failed to create lldb index cache directory: {0}"); + } +} + +std::unique_ptr<llvm::MemoryBuffer> +DataFileCache::GetCachedData(llvm::StringRef key) { + std::lock_guard<std::mutex> guard(m_mutex); + + const unsigned task = 1; + m_take_ownership = true; + // If we call the "m_cache_callback" function and the data is cached, it will + // call the "add_buffer" lambda function from the constructor which will in + // turn take ownership of the member buffer that is passed to the callback and + // put it into a member variable. + llvm::Expected<llvm::AddStreamFn> add_stream_or_err = + m_cache_callback(task, key, ""); + m_take_ownership = false; + // At this point we either already called the "add_buffer" lambda with + // the data or we haven't. We can tell if we got the cached data by checking + // the add_stream function pointer value below. + if (add_stream_or_err) { + llvm::AddStreamFn &add_stream = *add_stream_or_err; + // If the "add_stream" is nullptr, then the data was cached and we already + // called the "add_buffer" lambda. If it is valid, then if we were to call + // the add_stream function it would cause a cache file to get generated + // and we would be expected to fill in the data. In this function we only + // want to check if the data was cached, so we don't want to call + // "add_stream" in this function. + if (!add_stream) + return std::move(m_mem_buff_up); + } else { + Log *log = GetLog(LLDBLog::Modules); + LLDB_LOG_ERROR(log, add_stream_or_err.takeError(), + "failed to get the cache add stream callback for key: {0}"); + } + // Data was not cached. + return std::unique_ptr<llvm::MemoryBuffer>(); +} + +bool DataFileCache::SetCachedData(llvm::StringRef key, + llvm::ArrayRef<uint8_t> data) { + std::lock_guard<std::mutex> guard(m_mutex); + const unsigned task = 2; + // If we call this function and the data is cached, it will call the + // add_buffer lambda function from the constructor which will ignore the + // data. + llvm::Expected<llvm::AddStreamFn> add_stream_or_err = + m_cache_callback(task, key, ""); + // If we reach this code then we either already called the callback with + // the data or we haven't. We can tell if we had the cached data by checking + // the CacheAddStream function pointer value below. + if (add_stream_or_err) { + llvm::AddStreamFn &add_stream = *add_stream_or_err; + // If the "add_stream" is nullptr, then the data was cached. If it is + // valid, then if we call the add_stream function with a task it will + // cause the file to get generated, but we only want to check if the data + // is cached here, so we don't want to call it here. Note that the + // add_buffer will also get called in this case after the data has been + // provided, but we won't take ownership of the memory buffer as we just + // want to write the data. + if (add_stream) { + llvm::Expected<std::unique_ptr<llvm::CachedFileStream>> file_or_err = + add_stream(task, ""); + if (file_or_err) { + llvm::CachedFileStream *cfs = file_or_err->get(); + cfs->OS->write((const char *)data.data(), data.size()); + return true; + } else { + Log *log = GetLog(LLDBLog::Modules); + LLDB_LOG_ERROR(log, file_or_err.takeError(), + "failed to get the cache file stream for key: {0}"); + } + } + } else { + Log *log = GetLog(LLDBLog::Modules); + LLDB_LOG_ERROR(log, add_stream_or_err.takeError(), + "failed to get the cache add stream callback for key: {0}"); + } + return false; +} + +FileSpec DataFileCache::GetCacheFilePath(llvm::StringRef key) { + FileSpec cache_file(m_cache_dir); + std::string filename("llvmcache-"); + filename += key.str(); + cache_file.AppendPathComponent(filename); + return cache_file; +} + +Status DataFileCache::RemoveCacheFile(llvm::StringRef key) { + FileSpec cache_file = GetCacheFilePath(key); + FileSystem &fs = FileSystem::Instance(); + if (!fs.Exists(cache_file)) + return Status(); + return fs.RemoveFile(cache_file); +} + +CacheSignature::CacheSignature(lldb_private::Module *module) { + Clear(); + UUID uuid = module->GetUUID(); + if (uuid.IsValid()) + m_uuid = uuid; + + std::time_t mod_time = 0; + mod_time = llvm::sys::toTimeT(module->GetModificationTime()); + if (mod_time != 0) + m_mod_time = mod_time; + + mod_time = llvm::sys::toTimeT(module->GetObjectModificationTime()); + if (mod_time != 0) + m_obj_mod_time = mod_time; +} + +CacheSignature::CacheSignature(lldb_private::ObjectFile *objfile) { + Clear(); + UUID uuid = objfile->GetUUID(); + if (uuid.IsValid()) + m_uuid = uuid; + + std::time_t mod_time = 0; + // Grab the modification time of the object file's file. It isn't always the + // same as the module's file when you have a executable file as the main + // executable, and you have a object file for a symbol file. + FileSystem &fs = FileSystem::Instance(); + mod_time = llvm::sys::toTimeT(fs.GetModificationTime(objfile->GetFileSpec())); + if (mod_time != 0) + m_mod_time = mod_time; + + mod_time = + llvm::sys::toTimeT(objfile->GetModule()->GetObjectModificationTime()); + if (mod_time != 0) + m_obj_mod_time = mod_time; +} + +enum SignatureEncoding { + eSignatureUUID = 1u, + eSignatureModTime = 2u, + eSignatureObjectModTime = 3u, + eSignatureEnd = 255u, +}; + +bool CacheSignature::Encode(DataEncoder &encoder) const { + if (!IsValid()) + return false; // Invalid signature, return false! + + if (m_uuid) { + llvm::ArrayRef<uint8_t> uuid_bytes = m_uuid->GetBytes(); + encoder.AppendU8(eSignatureUUID); + encoder.AppendU8(uuid_bytes.size()); + encoder.AppendData(uuid_bytes); + } + if (m_mod_time) { + encoder.AppendU8(eSignatureModTime); + encoder.AppendU32(*m_mod_time); + } + if (m_obj_mod_time) { + encoder.AppendU8(eSignatureObjectModTime); + encoder.AppendU32(*m_obj_mod_time); + } + encoder.AppendU8(eSignatureEnd); + return true; +} + +bool CacheSignature::Decode(const lldb_private::DataExtractor &data, + lldb::offset_t *offset_ptr) { + Clear(); + while (uint8_t sig_encoding = data.GetU8(offset_ptr)) { + switch (sig_encoding) { + case eSignatureUUID: { + const uint8_t length = data.GetU8(offset_ptr); + const uint8_t *bytes = (const uint8_t *)data.GetData(offset_ptr, length); + if (bytes != nullptr && length > 0) + m_uuid = UUID(llvm::ArrayRef<uint8_t>(bytes, length)); + } break; + case eSignatureModTime: { + uint32_t mod_time = data.GetU32(offset_ptr); + if (mod_time > 0) + m_mod_time = mod_time; + } break; + case eSignatureObjectModTime: { + uint32_t mod_time = data.GetU32(offset_ptr); + if (mod_time > 0) + m_obj_mod_time = mod_time; + } break; + case eSignatureEnd: + // The definition of is valid changed to only be valid if the UUID is + // valid so make sure that if we attempt to decode an old cache file + // that we will fail to decode the cache file if the signature isn't + // considered valid. + return IsValid(); + default: + break; + } + } + return false; +} + +uint32_t ConstStringTable::Add(ConstString s) { + auto pos = m_string_to_offset.find(s); + if (pos != m_string_to_offset.end()) + return pos->second; + const uint32_t offset = m_next_offset; + m_strings.push_back(s); + m_string_to_offset[s] = offset; + m_next_offset += s.GetLength() + 1; + return offset; +} + +static const llvm::StringRef kStringTableIdentifier("STAB"); + +bool ConstStringTable::Encode(DataEncoder &encoder) { + // Write an 4 character code into the stream. This will help us when decoding + // to make sure we find this identifier when decoding the string table to make + // sure we have the rigth data. It also helps to identify the string table + // when dumping the hex bytes in a cache file. + encoder.AppendData(kStringTableIdentifier); + size_t length_offset = encoder.GetByteSize(); + encoder.AppendU32(0); // Total length of all strings which will be fixed up. + size_t strtab_offset = encoder.GetByteSize(); + encoder.AppendU8(0); // Start the string table with an empty string. + for (auto s: m_strings) { + // Make sure all of the offsets match up with what we handed out! + assert(m_string_to_offset.find(s)->second == + encoder.GetByteSize() - strtab_offset); + // Append the C string into the encoder + encoder.AppendCString(s.GetStringRef()); + } + // Fixup the string table length. + encoder.PutU32(length_offset, encoder.GetByteSize() - strtab_offset); + return true; +} + +bool StringTableReader::Decode(const lldb_private::DataExtractor &data, + lldb::offset_t *offset_ptr) { + llvm::StringRef identifier((const char *)data.GetData(offset_ptr, 4), 4); + if (identifier != kStringTableIdentifier) + return false; + const uint32_t length = data.GetU32(offset_ptr); + // We always have at least one byte for the empty string at offset zero. + if (length == 0) + return false; + const char *bytes = (const char *)data.GetData(offset_ptr, length); + if (bytes == nullptr) + return false; + m_data = llvm::StringRef(bytes, length); + return true; +} + +llvm::StringRef StringTableReader::Get(uint32_t offset) const { + if (offset >= m_data.size()) + return llvm::StringRef(); + return llvm::StringRef(m_data.data() + offset); +} + |