contrib/llvm-project/lldb/source/Utility/Reproducer.cpp

   1 //===-- Reproducer.cpp ------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Utility/Reproducer.h"
  10 #include "lldb/Utility/LLDBAssert.h"
  11
  12 #include "llvm/Support/FileSystem.h"
  13 #include "llvm/Support/Threading.h"
  14 #include "llvm/Support/raw_ostream.h"
  15
  16 using namespace lldb_private;
  17 using namespace lldb_private::repro;
  18 using namespace llvm;
  19 using namespace llvm::yaml;
  20
  21 Reproducer &Reproducer::Instance() { return *InstanceImpl(); }
  22
  23 llvm::Error Reproducer::Initialize(ReproducerMode mode,
  24                                    llvm::Optional<FileSpec> root) {
  25   lldbassert(!InstanceImpl() && "Already initialized.");
  26   InstanceImpl().emplace();
  27
  28   // The environment can override the capture mode.
  29   if (mode != ReproducerMode::Replay) {
  30     std::string env =
  31         llvm::StringRef(getenv("LLDB_CAPTURE_REPRODUCER")).lower();
  32     if (env == "0" || env == "off")
  33       mode = ReproducerMode::Off;
  34     else if (env == "1" || env == "on")
  35       mode = ReproducerMode::Capture;
  36   }
  37
  38   switch (mode) {
  39   case ReproducerMode::Capture: {
  40     if (!root) {
  41       SmallString<128> repro_dir;
  42       auto ec = sys::fs::createUniqueDirectory("reproducer", repro_dir);
  43       if (ec)
  44         return make_error<StringError>(
  45             "unable to create unique reproducer directory", ec);
  46       root.emplace(repro_dir);
  47     } else {
  48       auto ec = sys::fs::create_directory(root->GetPath());
  49       if (ec)
  50         return make_error<StringError>("unable to create reproducer directory",
  51                                        ec);
  52     }
  53     return Instance().SetCapture(root);
  54   } break;
  55   case ReproducerMode::Replay:
  56     return Instance().SetReplay(root);
  57   case ReproducerMode::Off:
  58     break;
  59   };
  60
  61   return Error::success();
  62 }
  63
  64 bool Reproducer::Initialized() { return InstanceImpl().operator bool(); }
  65
  66 void Reproducer::Terminate() {
  67   lldbassert(InstanceImpl() && "Already terminated.");
  68   InstanceImpl().reset();
  69 }
  70
  71 Optional<Reproducer> &Reproducer::InstanceImpl() {
  72   static Optional<Reproducer> g_reproducer;
  73   return g_reproducer;
  74 }
  75
  76 const Generator *Reproducer::GetGenerator() const {
  77   std::lock_guard<std::mutex> guard(m_mutex);
  78   if (m_generator)
  79     return &(*m_generator);
  80   return nullptr;
  81 }
  82
  83 const Loader *Reproducer::GetLoader() const {
  84   std::lock_guard<std::mutex> guard(m_mutex);
  85   if (m_loader)
  86     return &(*m_loader);
  87   return nullptr;
  88 }
  89
  90 Generator *Reproducer::GetGenerator() {
  91   std::lock_guard<std::mutex> guard(m_mutex);
  92   if (m_generator)
  93     return &(*m_generator);
  94   return nullptr;
  95 }
  96
  97 Loader *Reproducer::GetLoader() {
  98   std::lock_guard<std::mutex> guard(m_mutex);
  99   if (m_loader)
 100     return &(*m_loader);
 101   return nullptr;
 102 }
 103
 104 llvm::Error Reproducer::SetCapture(llvm::Optional<FileSpec> root) {
 105   std::lock_guard<std::mutex> guard(m_mutex);
 106
 107   if (root && m_loader)
 108     return make_error<StringError>(
 109         "cannot generate a reproducer when replay one",
 110         inconvertibleErrorCode());
 111
 112   if (!root) {
 113     m_generator.reset();
 114     return Error::success();
 115   }
 116
 117   m_generator.emplace(*root);
 118   return Error::success();
 119 }
 120
 121 llvm::Error Reproducer::SetReplay(llvm::Optional<FileSpec> root) {
 122   std::lock_guard<std::mutex> guard(m_mutex);
 123
 124   if (root && m_generator)
 125     return make_error<StringError>(
 126         "cannot replay a reproducer when generating one",
 127         inconvertibleErrorCode());
 128
 129   if (!root) {
 130     m_loader.reset();
 131     return Error::success();
 132   }
 133
 134   m_loader.emplace(*root);
 135   if (auto e = m_loader->LoadIndex())
 136     return e;
 137
 138   return Error::success();
 139 }
 140
 141 FileSpec Reproducer::GetReproducerPath() const {
 142   if (auto g = GetGenerator())
 143     return g->GetRoot();
 144   if (auto l = GetLoader())
 145     return l->GetRoot();
 146   return {};
 147 }
 148
 149 static FileSpec MakeAbsolute(FileSpec file_spec) {
 150   SmallString<128> path;
 151   file_spec.GetPath(path, false);
 152   llvm::sys::fs::make_absolute(path);
 153   return FileSpec(path, file_spec.GetPathStyle());
 154 }
 155
 156 Generator::Generator(FileSpec root) : m_root(MakeAbsolute(std::move(root))) {
 157   GetOrCreate<repro::WorkingDirectoryProvider>();
 158 }
 159
 160 Generator::~Generator() {
 161   if (!m_done)
 162     Discard();
 163 }
 164
 165 ProviderBase *Generator::Register(std::unique_ptr<ProviderBase> provider) {
 166   std::lock_guard<std::mutex> lock(m_providers_mutex);
 167   std::pair<const void *, std::unique_ptr<ProviderBase>> key_value(
 168       provider->DynamicClassID(), std::move(provider));
 169   auto e = m_providers.insert(std::move(key_value));
 170   return e.first->getSecond().get();
 171 }
 172
 173 void Generator::Keep() {
 174   assert(!m_done);
 175   m_done = true;
 176
 177   for (auto &provider : m_providers)
 178     provider.second->Keep();
 179
 180   AddProvidersToIndex();
 181 }
 182
 183 void Generator::Discard() {
 184   assert(!m_done);
 185   m_done = true;
 186
 187   for (auto &provider : m_providers)
 188     provider.second->Discard();
 189
 190   llvm::sys::fs::remove_directories(m_root.GetPath());
 191 }
 192
 193 const FileSpec &Generator::GetRoot() const { return m_root; }
 194
 195 void Generator::AddProvidersToIndex() {
 196   FileSpec index = m_root;
 197   index.AppendPathComponent("index.yaml");
 198
 199   std::error_code EC;
 200   auto strm = std::make_unique<raw_fd_ostream>(index.GetPath(), EC,
 201                                                sys::fs::OpenFlags::OF_None);
 202   yaml::Output yout(*strm);
 203
 204   std::vector<std::string> files;
 205   files.reserve(m_providers.size());
 206   for (auto &provider : m_providers) {
 207     files.emplace_back(provider.second->GetFile());
 208   }
 209
 210   yout << files;
 211 }
 212
 213 Loader::Loader(FileSpec root)
 214     : m_root(MakeAbsolute(std::move(root))), m_loaded(false) {}
 215
 216 llvm::Error Loader::LoadIndex() {
 217   if (m_loaded)
 218     return llvm::Error::success();
 219
 220   FileSpec index = m_root.CopyByAppendingPathComponent("index.yaml");
 221
 222   auto error_or_file = MemoryBuffer::getFile(index.GetPath());
 223   if (auto err = error_or_file.getError())
 224     return make_error<StringError>("unable to load reproducer index", err);
 225
 226   yaml::Input yin((*error_or_file)->getBuffer());
 227   yin >> m_files;
 228   if (auto err = yin.error())
 229     return make_error<StringError>("unable to read reproducer index", err);
 230
 231   // Sort files to speed up search.
 232   llvm::sort(m_files);
 233
 234   // Remember that we've loaded the index.
 235   m_loaded = true;
 236
 237   return llvm::Error::success();
 238 }
 239
 240 bool Loader::HasFile(StringRef file) {
 241   assert(m_loaded);
 242   auto it = std::lower_bound(m_files.begin(), m_files.end(), file.str());
 243   return (it != m_files.end()) && (*it == file);
 244 }
 245
 246 llvm::Expected<std::unique_ptr<DataRecorder>>
 247 DataRecorder::Create(const FileSpec &filename) {
 248   std::error_code ec;
 249   auto recorder = std::make_unique<DataRecorder>(std::move(filename), ec);
 250   if (ec)
 251     return llvm::errorCodeToError(ec);
 252   return std::move(recorder);
 253 }
 254
 255 DataRecorder *CommandProvider::GetNewDataRecorder() {
 256   std::size_t i = m_data_recorders.size() + 1;
 257   std::string filename = (llvm::Twine(Info::name) + llvm::Twine("-") +
 258                           llvm::Twine(i) + llvm::Twine(".yaml"))
 259                              .str();
 260   auto recorder_or_error =
 261       DataRecorder::Create(GetRoot().CopyByAppendingPathComponent(filename));
 262   if (!recorder_or_error) {
 263     llvm::consumeError(recorder_or_error.takeError());
 264     return nullptr;
 265   }
 266
 267   m_data_recorders.push_back(std::move(*recorder_or_error));
 268   return m_data_recorders.back().get();
 269 }
 270
 271 void CommandProvider::Keep() {
 272   std::vector<std::string> files;
 273   for (auto &recorder : m_data_recorders) {
 274     recorder->Stop();
 275     files.push_back(recorder->GetFilename().GetPath());
 276   }
 277
 278   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
 279   std::error_code ec;
 280   llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
 281   if (ec)
 282     return;
 283   yaml::Output yout(os);
 284   yout << files;
 285 }
 286
 287 void CommandProvider::Discard() { m_data_recorders.clear(); }
 288
 289 void VersionProvider::Keep() {
 290   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
 291   std::error_code ec;
 292   llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
 293   if (ec)
 294     return;
 295   os << m_version << "\n";
 296 }
 297
 298 void WorkingDirectoryProvider::Keep() {
 299   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
 300   std::error_code ec;
 301   llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
 302   if (ec)
 303     return;
 304   os << m_cwd << "\n";
 305 }
 306
 307 void ProviderBase::anchor() {}
 308 char CommandProvider::ID = 0;
 309 char FileProvider::ID = 0;
 310 char ProviderBase::ID = 0;
 311 char VersionProvider::ID = 0;
 312 char WorkingDirectoryProvider::ID = 0;
 313 const char *CommandProvider::Info::file = "command-interpreter.yaml";
 314 const char *CommandProvider::Info::name = "command-interpreter";
 315 const char *FileProvider::Info::file = "files.yaml";
 316 const char *FileProvider::Info::name = "files";
 317 const char *VersionProvider::Info::file = "version.txt";
 318 const char *VersionProvider::Info::name = "version";
 319 const char *WorkingDirectoryProvider::Info::file = "cwd.txt";
 320 const char *WorkingDirectoryProvider::Info::name = "cwd";