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