lldb/source/Target/PathMappingList.cpp

   1 //===-- PathMappingList.cpp -----------------------------------------------===//
   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 <climits>
  10 #include <cstring>
  11 #include <optional>
  12
  13 #include "lldb/Host/FileSystem.h"
  14 #include "lldb/Host/PosixApi.h"
  15 #include "lldb/Target/PathMappingList.h"
  16 #include "lldb/Utility/FileSpec.h"
  17 #include "lldb/Utility/Status.h"
  18 #include "lldb/Utility/Stream.h"
  19 #include "lldb/lldb-private-enumerations.h"
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23
  24 namespace {
  25   // We must normalize our path pairs that we store because if we don't then
  26   // things won't always work. We found a case where if we did:
  27   // (lldb) settings set target.source-map . /tmp
  28   // We would store a path pairs of "." and "/tmp" as raw strings. If the debug
  29   // info contains "./foo/bar.c", the path will get normalized to "foo/bar.c".
  30   // When PathMappingList::RemapPath() is called, it expects the path to start
  31   // with the raw path pair, which doesn't work anymore because the paths have
  32   // been normalized when the debug info was loaded. So we need to store
  33   // nomalized path pairs to ensure things match up.
  34 std::string NormalizePath(llvm::StringRef path) {
  35   // If we use "path" to construct a FileSpec, it will normalize the path for
  36   // us. We then grab the string.
  37   return FileSpec(path).GetPath();
  38 }
  39 }
  40 // PathMappingList constructor
  41 PathMappingList::PathMappingList() : m_pairs() {}
  42
  43 PathMappingList::PathMappingList(ChangedCallback callback, void *callback_baton)
  44     : m_pairs(), m_callback(callback), m_callback_baton(callback_baton) {}
  45
  46 PathMappingList::PathMappingList(const PathMappingList &rhs)
  47     : m_pairs(rhs.m_pairs) {}
  48
  49 const PathMappingList &PathMappingList::operator=(const PathMappingList &rhs) {
  50   if (this != &rhs) {
  51     std::scoped_lock<std::recursive_mutex, std::recursive_mutex> locks(m_mutex, rhs.m_mutex);
  52     m_pairs = rhs.m_pairs;
  53     m_callback = nullptr;
  54     m_callback_baton = nullptr;
  55     m_mod_id = rhs.m_mod_id;
  56   }
  57   return *this;
  58 }
  59
  60 PathMappingList::~PathMappingList() = default;
  61
  62 void PathMappingList::Append(llvm::StringRef path, llvm::StringRef replacement,
  63                              bool notify) {
  64   std::lock_guard<std::recursive_mutex> lock(m_mutex);
  65   ++m_mod_id;
  66   m_pairs.emplace_back(pair(NormalizePath(path), NormalizePath(replacement)));
  67   if (notify && m_callback)
  68     m_callback(*this, m_callback_baton);
  69 }
  70
  71 void PathMappingList::Append(const PathMappingList &rhs, bool notify) {
  72   std::scoped_lock<std::recursive_mutex, std::recursive_mutex> locks(m_mutex, rhs.m_mutex);
  73   ++m_mod_id;
  74   if (!rhs.m_pairs.empty()) {
  75     const_iterator pos, end = rhs.m_pairs.end();
  76     for (pos = rhs.m_pairs.begin(); pos != end; ++pos)
  77       m_pairs.push_back(*pos);
  78     if (notify && m_callback)
  79       m_callback(*this, m_callback_baton);
  80   }
  81 }
  82
  83 bool PathMappingList::AppendUnique(llvm::StringRef path,
  84                                    llvm::StringRef replacement, bool notify) {
  85   auto normalized_path = NormalizePath(path);
  86   auto normalized_replacement = NormalizePath(replacement);
  87   std::lock_guard<std::recursive_mutex> lock(m_mutex);
  88   for (const auto &pair : m_pairs) {
  89     if (pair.first.GetStringRef().equals(normalized_path) &&
  90         pair.second.GetStringRef().equals(normalized_replacement))
  91       return false;
  92   }
  93   Append(path, replacement, notify);
  94   return true;
  95 }
  96
  97 void PathMappingList::Insert(llvm::StringRef path, llvm::StringRef replacement,
  98                              uint32_t index, bool notify) {
  99   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 100   ++m_mod_id;
 101   iterator insert_iter;
 102   if (index >= m_pairs.size())
 103     insert_iter = m_pairs.end();
 104   else
 105     insert_iter = m_pairs.begin() + index;
 106   m_pairs.emplace(insert_iter, pair(NormalizePath(path),
 107                                     NormalizePath(replacement)));
 108   if (notify && m_callback)
 109     m_callback(*this, m_callback_baton);
 110 }
 111
 112 bool PathMappingList::Replace(llvm::StringRef path, llvm::StringRef replacement,
 113                               uint32_t index, bool notify) {
 114   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 115   if (index >= m_pairs.size())
 116     return false;
 117   ++m_mod_id;
 118   m_pairs[index] = pair(NormalizePath(path), NormalizePath(replacement));
 119   if (notify && m_callback)
 120     m_callback(*this, m_callback_baton);
 121   return true;
 122 }
 123
 124 bool PathMappingList::Remove(size_t index, bool notify) {
 125   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 126   if (index >= m_pairs.size())
 127     return false;
 128
 129   ++m_mod_id;
 130   iterator iter = m_pairs.begin() + index;
 131   m_pairs.erase(iter);
 132   if (notify && m_callback)
 133     m_callback(*this, m_callback_baton);
 134   return true;
 135 }
 136
 137 // For clients which do not need the pair index dumped, pass a pair_index >= 0
 138 // to only dump the indicated pair.
 139 void PathMappingList::Dump(Stream *s, int pair_index) {
 140   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 141   unsigned int numPairs = m_pairs.size();
 142
 143   if (pair_index < 0) {
 144     unsigned int index;
 145     for (index = 0; index < numPairs; ++index)
 146       s->Printf("[%d] \"%s\" -> \"%s\"\n", index,
 147                 m_pairs[index].first.GetCString(),
 148                 m_pairs[index].second.GetCString());
 149   } else {
 150     if (static_cast<unsigned int>(pair_index) < numPairs)
 151       s->Printf("%s -> %s", m_pairs[pair_index].first.GetCString(),
 152                 m_pairs[pair_index].second.GetCString());
 153   }
 154 }
 155
 156 llvm::json::Value PathMappingList::ToJSON() {
 157   llvm::json::Array entries;
 158   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 159   for (const auto &pair : m_pairs) {
 160     llvm::json::Array entry{pair.first.GetStringRef().str(),
 161                             pair.second.GetStringRef().str()};
 162     entries.emplace_back(std::move(entry));
 163   }
 164   return entries;
 165 }
 166
 167 void PathMappingList::Clear(bool notify) {
 168   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 169   if (!m_pairs.empty())
 170     ++m_mod_id;
 171   m_pairs.clear();
 172   if (notify && m_callback)
 173     m_callback(*this, m_callback_baton);
 174 }
 175
 176 bool PathMappingList::RemapPath(ConstString path,
 177                                 ConstString &new_path) const {
 178   if (std::optional<FileSpec> remapped = RemapPath(path.GetStringRef())) {
 179     new_path.SetString(remapped->GetPath());
 180     return true;
 181   }
 182   return false;
 183 }
 184
 185 /// Append components to path, applying style.
 186 static void AppendPathComponents(FileSpec &path, llvm::StringRef components,
 187                                  llvm::sys::path::Style style) {
 188   auto component = llvm::sys::path::begin(components, style);
 189   auto e = llvm::sys::path::end(components);
 190   while (component != e &&
 191          llvm::sys::path::is_separator(*component->data(), style))
 192     ++component;
 193   for (; component != e; ++component)
 194     path.AppendPathComponent(*component);
 195 }
 196
 197 std::optional<FileSpec> PathMappingList::RemapPath(llvm::StringRef mapping_path,
 198                                                    bool only_if_exists) const {
 199   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 200   if (m_pairs.empty() || mapping_path.empty())
 201     return {};
 202   LazyBool path_is_relative = eLazyBoolCalculate;
 203
 204   for (const auto &it : m_pairs) {
 205     llvm::StringRef prefix = it.first.GetStringRef();
 206     // We create a copy of mapping_path because StringRef::consume_from
 207     // effectively modifies the instance itself.
 208     llvm::StringRef path = mapping_path;
 209     if (!path.consume_front(prefix)) {
 210       // Relative paths won't have a leading "./" in them unless "." is the
 211       // only thing in the relative path so we need to work around "."
 212       // carefully.
 213       if (prefix != ".")
 214         continue;
 215       // We need to figure out if the "path" argument is relative. If it is,
 216       // then we should remap, else skip this entry.
 217       if (path_is_relative == eLazyBoolCalculate) {
 218         path_is_relative =
 219             FileSpec(path).IsRelative() ? eLazyBoolYes : eLazyBoolNo;
 220       }
 221       if (!path_is_relative)
 222         continue;
 223     }
 224     FileSpec remapped(it.second.GetStringRef());
 225     auto orig_style = FileSpec::GuessPathStyle(prefix).value_or(
 226         llvm::sys::path::Style::native);
 227     AppendPathComponents(remapped, path, orig_style);
 228     if (!only_if_exists || FileSystem::Instance().Exists(remapped))
 229       return remapped;
 230   }
 231   return {};
 232 }
 233
 234 std::optional<llvm::StringRef>
 235 PathMappingList::ReverseRemapPath(const FileSpec &file, FileSpec &fixed) const {
 236   std::string path = file.GetPath();
 237   llvm::StringRef path_ref(path);
 238   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 239   for (const auto &it : m_pairs) {
 240     llvm::StringRef removed_prefix = it.second.GetStringRef();
 241     if (!path_ref.consume_front(it.second.GetStringRef()))
 242       continue;
 243     auto orig_file = it.first.GetStringRef();
 244     auto orig_style = FileSpec::GuessPathStyle(orig_file).value_or(
 245         llvm::sys::path::Style::native);
 246     fixed.SetFile(orig_file, orig_style);
 247     AppendPathComponents(fixed, path_ref, orig_style);
 248     return removed_prefix;
 249   }
 250   return std::nullopt;
 251 }
 252
 253 std::optional<FileSpec>
 254 PathMappingList::FindFile(const FileSpec &orig_spec) const {
 255   // We must normalize the orig_spec again using the host's path style,
 256   // otherwise there will be mismatch between the host and remote platform
 257   // if they use different path styles.
 258   if (auto remapped = RemapPath(NormalizePath(orig_spec.GetPath()),
 259                                 /*only_if_exists=*/true))
 260     return remapped;
 261
 262   return {};
 263 }
 264
 265 bool PathMappingList::Replace(llvm::StringRef path, llvm::StringRef new_path,
 266                               bool notify) {
 267   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 268   uint32_t idx = FindIndexForPath(path);
 269   if (idx < m_pairs.size()) {
 270     ++m_mod_id;
 271     m_pairs[idx].second = ConstString(new_path);
 272     if (notify && m_callback)
 273       m_callback(*this, m_callback_baton);
 274     return true;
 275   }
 276   return false;
 277 }
 278
 279 bool PathMappingList::Remove(ConstString path, bool notify) {
 280   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 281   iterator pos = FindIteratorForPath(path);
 282   if (pos != m_pairs.end()) {
 283     ++m_mod_id;
 284     m_pairs.erase(pos);
 285     if (notify && m_callback)
 286       m_callback(*this, m_callback_baton);
 287     return true;
 288   }
 289   return false;
 290 }
 291
 292 PathMappingList::const_iterator
 293 PathMappingList::FindIteratorForPath(ConstString path) const {
 294   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 295   const_iterator pos;
 296   const_iterator begin = m_pairs.begin();
 297   const_iterator end = m_pairs.end();
 298
 299   for (pos = begin; pos != end; ++pos) {
 300     if (pos->first == path)
 301       break;
 302   }
 303   return pos;
 304 }
 305
 306 PathMappingList::iterator
 307 PathMappingList::FindIteratorForPath(ConstString path) {
 308   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 309   iterator pos;
 310   iterator begin = m_pairs.begin();
 311   iterator end = m_pairs.end();
 312
 313   for (pos = begin; pos != end; ++pos) {
 314     if (pos->first == path)
 315       break;
 316   }
 317   return pos;
 318 }
 319
 320 bool PathMappingList::GetPathsAtIndex(uint32_t idx, ConstString &path,
 321                                       ConstString &new_path) const {
 322   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 323   if (idx < m_pairs.size()) {
 324     path = m_pairs[idx].first;
 325     new_path = m_pairs[idx].second;
 326     return true;
 327   }
 328   return false;
 329 }
 330
 331 uint32_t PathMappingList::FindIndexForPath(llvm::StringRef orig_path) const {
 332   const ConstString path = ConstString(NormalizePath(orig_path));
 333   std::lock_guard<std::recursive_mutex> lock(m_mutex);
 334   const_iterator pos;
 335   const_iterator begin = m_pairs.begin();
 336   const_iterator end = m_pairs.end();
 337
 338   for (pos = begin; pos != end; ++pos) {
 339     if (pos->first == path)
 340       return std::distance(begin, pos);
 341   }
 342   return UINT32_MAX;
 343 }