//===-- 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);

}