clang  14.0.0git
FileRemapper.cpp
Go to the documentation of this file.
1 //===--- FileRemapper.cpp - File Remapping Helper -------------------------===//
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 
10 #include "clang/Basic/Diagnostic.h"
13 #include "llvm/Support/FileSystem.h"
14 #include "llvm/Support/MemoryBuffer.h"
15 #include "llvm/Support/Path.h"
16 #include "llvm/Support/raw_ostream.h"
17 #include <fstream>
18 
19 using namespace clang;
20 using namespace arcmt;
21 
23  FileMgr.reset(new FileManager(FileSystemOptions()));
24 }
25 
27  clear();
28 }
29 
30 void FileRemapper::clear(StringRef outputDir) {
31  for (MappingsTy::iterator
32  I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I)
33  resetTarget(I->second);
34  FromToMappings.clear();
35  assert(ToFromMappings.empty());
36  if (!outputDir.empty()) {
37  std::string infoFile = getRemapInfoFile(outputDir);
38  llvm::sys::fs::remove(infoFile);
39  }
40 }
41 
42 std::string FileRemapper::getRemapInfoFile(StringRef outputDir) {
43  assert(!outputDir.empty());
44  SmallString<128> InfoFile = outputDir;
45  llvm::sys::path::append(InfoFile, "remap");
46  return std::string(InfoFile.str());
47 }
48 
50  bool ignoreIfFilesChanged) {
51  std::string infoFile = getRemapInfoFile(outputDir);
52  return initFromFile(infoFile, Diag, ignoreIfFilesChanged);
53 }
54 
56  bool ignoreIfFilesChanged) {
57  assert(FromToMappings.empty() &&
58  "initFromDisk should be called before any remap calls");
59  std::string infoFile = std::string(filePath);
60  if (!llvm::sys::fs::exists(infoFile))
61  return false;
62 
63  std::vector<std::pair<const FileEntry *, const FileEntry *> > pairs;
64 
65  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileBuf =
66  llvm::MemoryBuffer::getFile(infoFile, /*IsText=*/true);
67  if (!fileBuf)
68  return report("Error opening file: " + infoFile, Diag);
69 
71  fileBuf.get()->getBuffer().split(lines, "\n");
72 
73  for (unsigned idx = 0; idx+3 <= lines.size(); idx += 3) {
74  StringRef fromFilename = lines[idx];
75  unsigned long long timeModified;
76  if (lines[idx+1].getAsInteger(10, timeModified))
77  return report("Invalid file data: '" + lines[idx+1] + "' not a number",
78  Diag);
79  StringRef toFilename = lines[idx+2];
80 
81  llvm::ErrorOr<const FileEntry *> origFE = FileMgr->getFile(fromFilename);
82  if (!origFE) {
83  if (ignoreIfFilesChanged)
84  continue;
85  return report("File does not exist: " + fromFilename, Diag);
86  }
87  llvm::ErrorOr<const FileEntry *> newFE = FileMgr->getFile(toFilename);
88  if (!newFE) {
89  if (ignoreIfFilesChanged)
90  continue;
91  return report("File does not exist: " + toFilename, Diag);
92  }
93 
94  if ((uint64_t)(*origFE)->getModificationTime() != timeModified) {
95  if (ignoreIfFilesChanged)
96  continue;
97  return report("File was modified: " + fromFilename, Diag);
98  }
99 
100  pairs.push_back(std::make_pair(*origFE, *newFE));
101  }
102 
103  for (unsigned i = 0, e = pairs.size(); i != e; ++i)
104  remap(pairs[i].first, pairs[i].second);
105 
106  return false;
107 }
108 
109 bool FileRemapper::flushToDisk(StringRef outputDir, DiagnosticsEngine &Diag) {
110  using namespace llvm::sys;
111 
112  if (fs::create_directory(outputDir))
113  return report("Could not create directory: " + outputDir, Diag);
114 
115  std::string infoFile = getRemapInfoFile(outputDir);
116  return flushToFile(infoFile, Diag);
117 }
118 
119 bool FileRemapper::flushToFile(StringRef outputPath, DiagnosticsEngine &Diag) {
120  using namespace llvm::sys;
121 
122  std::error_code EC;
123  std::string infoFile = std::string(outputPath);
124  llvm::raw_fd_ostream infoOut(infoFile, EC, llvm::sys::fs::OF_Text);
125  if (EC)
126  return report(EC.message(), Diag);
127 
128  for (MappingsTy::iterator
129  I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
130 
131  const FileEntry *origFE = I->first;
132  SmallString<200> origPath = StringRef(origFE->getName());
133  fs::make_absolute(origPath);
134  infoOut << origPath << '\n';
135  infoOut << (uint64_t)origFE->getModificationTime() << '\n';
136 
137  if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
138  SmallString<200> newPath = StringRef(FE->getName());
139  fs::make_absolute(newPath);
140  infoOut << newPath << '\n';
141  } else {
142 
143  SmallString<64> tempPath;
144  int fd;
145  if (fs::createTemporaryFile(
146  path::filename(origFE->getName()),
147  path::extension(origFE->getName()).drop_front(), fd, tempPath,
148  llvm::sys::fs::OF_Text))
149  return report("Could not create file: " + tempPath.str(), Diag);
150 
151  llvm::raw_fd_ostream newOut(fd, /*shouldClose=*/true);
152  llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
153  newOut.write(mem->getBufferStart(), mem->getBufferSize());
154  newOut.close();
155 
156  auto newE = FileMgr->getFile(tempPath);
157  if (newE) {
158  remap(origFE, *newE);
159  infoOut << (*newE)->getName() << '\n';
160  }
161  }
162  }
163 
164  infoOut.close();
165  return false;
166 }
167 
169  StringRef outputDir) {
170  using namespace llvm::sys;
171 
172  for (MappingsTy::iterator
173  I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
174  const FileEntry *origFE = I->first;
175  assert(I->second.is<llvm::MemoryBuffer *>());
176  if (!fs::exists(origFE->getName()))
177  return report(StringRef("File does not exist: ") + origFE->getName(),
178  Diag);
179 
180  std::error_code EC;
181  llvm::raw_fd_ostream Out(origFE->getName(), EC, llvm::sys::fs::OF_None);
182  if (EC)
183  return report(EC.message(), Diag);
184 
185  llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
186  Out.write(mem->getBufferStart(), mem->getBufferSize());
187  Out.close();
188  }
189 
190  clear(outputDir);
191  return false;
192 }
193 
195  llvm::function_ref<void(StringRef, StringRef)> CaptureFile,
196  llvm::function_ref<void(StringRef, const llvm::MemoryBufferRef &)>
197  CaptureBuffer) const {
198  for (auto &Mapping : FromToMappings) {
199  if (const FileEntry *FE = Mapping.second.dyn_cast<const FileEntry *>()) {
200  CaptureFile(Mapping.first->getName(), FE->getName());
201  continue;
202  }
203  CaptureBuffer(
204  Mapping.first->getName(),
205  Mapping.second.get<llvm::MemoryBuffer *>()->getMemBufferRef());
206  }
207 }
208 
210  for (MappingsTy::const_iterator
211  I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
212  if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
213  PPOpts.addRemappedFile(I->first->getName(), FE->getName());
214  } else {
215  llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
216  PPOpts.addRemappedFile(I->first->getName(), mem);
217  }
218  }
219 
220  PPOpts.RetainRemappedFileBuffers = true;
221 }
222 
223 void FileRemapper::remap(StringRef filePath,
224  std::unique_ptr<llvm::MemoryBuffer> memBuf) {
225  remap(getOriginalFile(filePath), std::move(memBuf));
226 }
227 
228 void FileRemapper::remap(const FileEntry *file,
229  std::unique_ptr<llvm::MemoryBuffer> memBuf) {
230  assert(file);
231  Target &targ = FromToMappings[file];
232  resetTarget(targ);
233  targ = memBuf.release();
234 }
235 
236 void FileRemapper::remap(const FileEntry *file, const FileEntry *newfile) {
237  assert(file && newfile);
238  Target &targ = FromToMappings[file];
239  resetTarget(targ);
240  targ = newfile;
241  ToFromMappings[newfile] = file;
242 }
243 
244 const FileEntry *FileRemapper::getOriginalFile(StringRef filePath) {
245  const FileEntry *file = nullptr;
246  if (auto fileOrErr = FileMgr->getFile(filePath))
247  file = *fileOrErr;
248  // If we are updating a file that overridden an original file,
249  // actually update the original file.
250  llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
251  I = ToFromMappings.find(file);
252  if (I != ToFromMappings.end()) {
253  file = I->second;
254  assert(FromToMappings.find(file) != FromToMappings.end() &&
255  "Original file not in mappings!");
256  }
257  return file;
258 }
259 
260 void FileRemapper::resetTarget(Target &targ) {
261  if (!targ)
262  return;
263 
264  if (llvm::MemoryBuffer *oldmem = targ.dyn_cast<llvm::MemoryBuffer *>()) {
265  delete oldmem;
266  } else {
267  const FileEntry *toFE = targ.get<const FileEntry *>();
268  ToFromMappings.erase(toFE);
269  }
270 }
271 
272 bool FileRemapper::report(const Twine &err, DiagnosticsEngine &Diag) {
273  Diag.Report(Diag.getCustomDiagID(DiagnosticsEngine::Error, "%0"))
274  << err.str();
275  return true;
276 }
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::PreprocessorOptions
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Definition: PreprocessorOptions.h:64
clang::arcmt::FileRemapper::clear
void clear(StringRef outputDir=StringRef())
Definition: FileRemapper.cpp:30
Diag
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Definition: LiteralSupport.cpp:78
llvm::SmallVector
Definition: LLVM.h:38
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:191
clang::arcmt::FileRemapper::flushToDisk
bool flushToDisk(StringRef outputDir, DiagnosticsEngine &Diag)
Definition: FileRemapper.cpp:109
clang::arcmt::FileRemapper::initFromFile
bool initFromFile(StringRef filePath, DiagnosticsEngine &Diag, bool ignoreIfFilesChanged)
Definition: FileRemapper.cpp:55
clang::FileSystemOptions
Keeps track of options that affect how file operations are performed.
Definition: FileSystemOptions.h:22
clang::arcmt::FileRemapper::forEachMapping
void forEachMapping(llvm::function_ref< void(StringRef, StringRef)> CaptureFile, llvm::function_ref< void(StringRef, const llvm::MemoryBufferRef &)> CaptureBuffer) const
Iterate through all the mappings.
Definition: FileRemapper.cpp:194
clang::arcmt::FileRemapper::initFromDisk
bool initFromDisk(StringRef outputDir, DiagnosticsEngine &Diag, bool ignoreIfFilesChanged)
Definition: FileRemapper.cpp:49
Diagnostic.h
clang::DiagnosticsEngine::Error
@ Error
Definition: Diagnostic.h:199
clang::arcmt::FileRemapper::FileRemapper
FileRemapper()
Definition: FileRemapper.cpp:22
clang::arcmt::FileRemapper::overwriteOriginal
bool overwriteOriginal(DiagnosticsEngine &Diag, StringRef outputDir=StringRef())
Definition: FileRemapper.cpp:168
llvm::SmallString< 128 >
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:331
clang::transformer::remove
ASTEdit remove(RangeSelector S)
Removes the source selected by S.
Definition: RewriteRule.cpp:146
clang::PreprocessorOptions::RetainRemappedFileBuffers
bool RetainRemappedFileBuffers
Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...
Definition: PreprocessorOptions.h:170
clang::arcmt::FileRemapper::applyMappings
void applyMappings(PreprocessorOptions &PPOpts) const
Definition: FileRemapper.cpp:209
FileRemapper.h
clang
Definition: CalledOnceCheck.h:17
clang::FileManager
Implements support for file system lookup, file system caching, and directory search management.
Definition: FileManager.h:53
clang::FileEntry::getModificationTime
time_t getModificationTime() const
Definition: FileEntry.h:372
clang::FileEntry::getName
StringRef getName() const
Definition: FileEntry.h:364
FileManager.h
clang::arcmt::FileRemapper::~FileRemapper
~FileRemapper()
Definition: FileRemapper.cpp:26
clang::PreprocessorOptions::addRemappedFile
void addRemappedFile(StringRef From, StringRef To)
Definition: PreprocessorOptions.h:226
PreprocessorOptions.h
clang::arcmt::FileRemapper::flushToFile
bool flushToFile(StringRef outputPath, DiagnosticsEngine &Diag)
Definition: FileRemapper.cpp:119
clang::arcmt::FileRemapper::remap
void remap(StringRef filePath, std::unique_ptr< llvm::MemoryBuffer > memBuf)
Definition: FileRemapper.cpp:223