clang  10.0.0svn
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 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 = 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);
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 = outputPath;
124  llvm::raw_fd_ostream infoOut(infoFile, EC, llvm::sys::fs::OF_None);
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(path::filename(origFE->getName()),
146  path::extension(origFE->getName()).drop_front(), fd,
147  tempPath))
148  return report("Could not create file: " + tempPath.str(), Diag);
149 
150  llvm::raw_fd_ostream newOut(fd, /*shouldClose=*/true);
151  llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
152  newOut.write(mem->getBufferStart(), mem->getBufferSize());
153  newOut.close();
154 
155  auto newE = FileMgr->getFile(tempPath);
156  if (newE) {
157  remap(origFE, *newE);
158  infoOut << (*newE)->getName() << '\n';
159  }
160  }
161  }
162 
163  infoOut.close();
164  return false;
165 }
166 
168  StringRef outputDir) {
169  using namespace llvm::sys;
170 
171  for (MappingsTy::iterator
172  I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
173  const FileEntry *origFE = I->first;
174  assert(I->second.is<llvm::MemoryBuffer *>());
175  if (!fs::exists(origFE->getName()))
176  return report(StringRef("File does not exist: ") + origFE->getName(),
177  Diag);
178 
179  std::error_code EC;
180  llvm::raw_fd_ostream Out(origFE->getName(), EC, llvm::sys::fs::OF_None);
181  if (EC)
182  return report(EC.message(), Diag);
183 
184  llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
185  Out.write(mem->getBufferStart(), mem->getBufferSize());
186  Out.close();
187  }
188 
189  clear(outputDir);
190  return false;
191 }
192 
194  for (MappingsTy::const_iterator
195  I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
196  if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
197  PPOpts.addRemappedFile(I->first->getName(), FE->getName());
198  } else {
199  llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
200  PPOpts.addRemappedFile(I->first->getName(), mem);
201  }
202  }
203 
204  PPOpts.RetainRemappedFileBuffers = true;
205 }
206 
207 void FileRemapper::remap(StringRef filePath,
208  std::unique_ptr<llvm::MemoryBuffer> memBuf) {
209  remap(getOriginalFile(filePath), std::move(memBuf));
210 }
211 
212 void FileRemapper::remap(const FileEntry *file,
213  std::unique_ptr<llvm::MemoryBuffer> memBuf) {
214  assert(file);
215  Target &targ = FromToMappings[file];
216  resetTarget(targ);
217  targ = memBuf.release();
218 }
219 
220 void FileRemapper::remap(const FileEntry *file, const FileEntry *newfile) {
221  assert(file && newfile);
222  Target &targ = FromToMappings[file];
223  resetTarget(targ);
224  targ = newfile;
225  ToFromMappings[newfile] = file;
226 }
227 
228 const FileEntry *FileRemapper::getOriginalFile(StringRef filePath) {
229  const FileEntry *file = nullptr;
230  if (auto fileOrErr = FileMgr->getFile(filePath))
231  file = *fileOrErr;
232  // If we are updating a file that overridden an original file,
233  // actually update the original file.
234  llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
235  I = ToFromMappings.find(file);
236  if (I != ToFromMappings.end()) {
237  file = I->second;
238  assert(FromToMappings.find(file) != FromToMappings.end() &&
239  "Original file not in mappings!");
240  }
241  return file;
242 }
243 
244 void FileRemapper::resetTarget(Target &targ) {
245  if (!targ)
246  return;
247 
248  if (llvm::MemoryBuffer *oldmem = targ.dyn_cast<llvm::MemoryBuffer *>()) {
249  delete oldmem;
250  } else {
251  const FileEntry *toFE = targ.get<const FileEntry *>();
252  ToFromMappings.erase(toFE);
253  }
254 }
255 
256 bool FileRemapper::report(const Twine &err, DiagnosticsEngine &Diag) {
258  << err.str();
259  return true;
260 }
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.
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:171
Defines the clang::FileManager interface and associated types.
time_t getModificationTime() const
Definition: FileManager.h:108
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1290
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
void applyMappings(PreprocessorOptions &PPOpts) const
void addRemappedFile(StringRef From, StringRef To)
void remap(StringRef filePath, std::unique_ptr< llvm::MemoryBuffer > memBuf)
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
Defines the Diagnostic-related interfaces.
bool RetainRemappedFileBuffers
Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...
bool flushToFile(StringRef outputPath, DiagnosticsEngine &Diag)
ASTEdit remove(RangeSelector S)
Removes the source selected by S.
Definition: RewriteRule.h:218
bool initFromFile(StringRef filePath, DiagnosticsEngine &Diag, bool ignoreIfFilesChanged)
bool overwriteOriginal(DiagnosticsEngine &Diag, StringRef outputDir=StringRef())
StringRef getName() const
Definition: FileManager.h:102
bool flushToDisk(StringRef outputDir, DiagnosticsEngine &Diag)
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:78
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:776
Dataflow Directional Tag Classes.
Keeps track of options that affect how file operations are performed.
bool initFromDisk(StringRef outputDir, DiagnosticsEngine &Diag, bool ignoreIfFilesChanged)
void clear(StringRef outputDir=StringRef())