Author: Emre Kultursay Date: 2022-03-03T08:48:16-08:00 New Revision: 71e278805a7232826f27be081d036ca3f1c85d65
URL: https://github.com/llvm/llvm-project/commit/71e278805a7232826f27be081d036ca3f1c85d65 DIFF: https://github.com/llvm/llvm-project/commit/71e278805a7232826f27be081d036ca3f1c85d65.diff LOG: [lldb] Fix DataExtractor symbol conflict There are two DataExtractors in scope: one from the llvm namespace and one from the lldb_private namespace. Some Microsoft Visual C++ compilers (I tested with MSVC 14.23 specifically) cannot handle this situation, and generate ambiguous symbol errors. This change fixes this compile error. Differential revision: https://reviews.llvm.org/D120718 Added: Modified: lldb/source/Core/DataFileCache.cpp Removed: ################################################################################ diff --git a/lldb/source/Core/DataFileCache.cpp b/lldb/source/Core/DataFileCache.cpp index 84f787e6184e1..f9b632f34e417 100644 --- a/lldb/source/Core/DataFileCache.cpp +++ b/lldb/source/Core/DataFileCache.cpp @@ -17,17 +17,16 @@ #include "llvm/Support/CachePruning.h" #include "llvm/Support/MemoryBuffer.h" -using namespace llvm; using namespace lldb_private; -DataFileCache::DataFileCache(StringRef path) { +DataFileCache::DataFileCache(llvm::StringRef path) { m_cache_dir.SetPath(path); // Prune the cache based off of the LLDB settings each time we create a cache // object. ModuleListProperties &properties = ModuleList::GetGlobalModuleListProperties(); - CachePruningPolicy policy; + llvm::CachePruningPolicy policy; // 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 diff erent processes don't scan the directory too often. @@ -52,7 +51,7 @@ DataFileCache::DataFileCache(StringRef path) { if (m_take_ownership) m_mem_buff_up = std::move(m); }; - Expected<FileCache> cache_or_err = + 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); @@ -64,7 +63,7 @@ DataFileCache::DataFileCache(StringRef path) { } std::unique_ptr<llvm::MemoryBuffer> -DataFileCache::GetCachedData(StringRef key) { +DataFileCache::GetCachedData(llvm::StringRef key) { std::lock_guard<std::mutex> guard(m_mutex); const unsigned task = 1; @@ -73,13 +72,14 @@ DataFileCache::GetCachedData(StringRef key) { // 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. - Expected<AddStreamFn> add_stream_or_err = m_cache_callback(task, key); + 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) { - AddStreamFn &add_stream = *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 @@ -97,18 +97,20 @@ DataFileCache::GetCachedData(StringRef key) { return std::unique_ptr<llvm::MemoryBuffer>(); } -bool DataFileCache::SetCachedData(StringRef key, llvm::ArrayRef<uint8_t> data) { +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. - Expected<AddStreamFn> add_stream_or_err = m_cache_callback(task, key); + 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) { - AddStreamFn &add_stream = *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 @@ -117,10 +119,10 @@ bool DataFileCache::SetCachedData(StringRef key, llvm::ArrayRef<uint8_t> data) { // provided, but we won't take ownership of the memory buffer as we just // want to write the data. if (add_stream) { - Expected<std::unique_ptr<CachedFileStream>> file_or_err = + llvm::Expected<std::unique_ptr<llvm::CachedFileStream>> file_or_err = add_stream(task); if (file_or_err) { - CachedFileStream *cfs = file_or_err->get(); + llvm::CachedFileStream *cfs = file_or_err->get(); cfs->OS->write((const char *)data.data(), data.size()); return true; } else { @@ -219,7 +221,7 @@ bool CacheSignature::Encode(DataEncoder &encoder) { return true; } -bool CacheSignature::Decode(const DataExtractor &data, +bool CacheSignature::Decode(const lldb_private::DataExtractor &data, lldb::offset_t *offset_ptr) { Clear(); while (uint8_t sig_encoding = data.GetU8(offset_ptr)) { @@ -284,7 +286,7 @@ bool ConstStringTable::Encode(DataEncoder &encoder) { return true; } -bool StringTableReader::Decode(const DataExtractor &data, +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) @@ -296,12 +298,12 @@ bool StringTableReader::Decode(const DataExtractor &data, const char *bytes = (const char *)data.GetData(offset_ptr, length); if (bytes == nullptr) return false; - m_data = StringRef(bytes, length); + m_data = llvm::StringRef(bytes, length); return true; } -StringRef StringTableReader::Get(uint32_t offset) const { +llvm::StringRef StringTableReader::Get(uint32_t offset) const { if (offset >= m_data.size()) - return StringRef(); - return StringRef(m_data.data() + offset); + return llvm::StringRef(); + return llvm::StringRef(m_data.data() + offset); } _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
