1 //===--- FileRemapper.cpp - File Remapping Helper -------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "clang/ARCMigrate/FileRemapper.h"
11 #include "clang/Frontend/CompilerInvocation.h"
12 #include "clang/Basic/FileManager.h"
13 #include "llvm/Support/MemoryBuffer.h"
14 #include "llvm/Support/Path.h"
15 #include "llvm/Support/FileSystem.h"
16 #include "llvm/Support/raw_ostream.h"
17 #include <fstream>
18
19 using namespace clang;
20 using namespace arcmt;
21
FileRemapper()22 FileRemapper::FileRemapper() {
23 FileMgr.reset(new FileManager(FileSystemOptions()));
24 }
25
~FileRemapper()26 FileRemapper::~FileRemapper() {
27 clear();
28 }
29
clear(llvm::StringRef outputDir)30 void FileRemapper::clear(llvm::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 bool existed;
39 llvm::sys::fs::remove(infoFile, existed);
40 }
41 }
42
getRemapInfoFile(llvm::StringRef outputDir)43 std::string FileRemapper::getRemapInfoFile(llvm::StringRef outputDir) {
44 assert(!outputDir.empty());
45 llvm::sys::Path dir(outputDir);
46 llvm::sys::Path infoFile = dir;
47 infoFile.appendComponent("remap");
48 return infoFile.str();
49 }
50
initFromDisk(llvm::StringRef outputDir,Diagnostic & Diag,bool ignoreIfFilesChanged)51 bool FileRemapper::initFromDisk(llvm::StringRef outputDir, Diagnostic &Diag,
52 bool ignoreIfFilesChanged) {
53 assert(FromToMappings.empty() &&
54 "initFromDisk should be called before any remap calls");
55 std::string infoFile = getRemapInfoFile(outputDir);
56 bool fileExists = false;
57 llvm::sys::fs::exists(infoFile, fileExists);
58 if (!fileExists)
59 return false;
60
61 std::vector<std::pair<const FileEntry *, const FileEntry *> > pairs;
62
63 std::ifstream fin(infoFile.c_str());
64 if (!fin.good())
65 return report(std::string("Error opening file: ") + infoFile, Diag);
66
67 while (true) {
68 std::string fromFilename, toFilename;
69 uint64_t timeModified;
70
71 fin >> fromFilename >> timeModified >> toFilename;
72 if (fin.eof())
73 break;
74 if (!fin.good())
75 return report(std::string("Error in format of file: ") + infoFile, Diag);
76
77 const FileEntry *origFE = FileMgr->getFile(fromFilename);
78 if (!origFE) {
79 if (ignoreIfFilesChanged)
80 continue;
81 return report(std::string("File does not exist: ") + fromFilename, Diag);
82 }
83 const FileEntry *newFE = FileMgr->getFile(toFilename);
84 if (!newFE) {
85 if (ignoreIfFilesChanged)
86 continue;
87 return report(std::string("File does not exist: ") + toFilename, Diag);
88 }
89
90 if ((uint64_t)origFE->getModificationTime() != timeModified) {
91 if (ignoreIfFilesChanged)
92 continue;
93 return report(std::string("File was modified: ") + fromFilename, Diag);
94 }
95
96 pairs.push_back(std::make_pair(origFE, newFE));
97 }
98
99 for (unsigned i = 0, e = pairs.size(); i != e; ++i)
100 remap(pairs[i].first, pairs[i].second);
101
102 return false;
103 }
104
flushToDisk(llvm::StringRef outputDir,Diagnostic & Diag)105 bool FileRemapper::flushToDisk(llvm::StringRef outputDir, Diagnostic &Diag) {
106 using namespace llvm::sys;
107
108 bool existed;
109 if (fs::create_directory(outputDir, existed) != llvm::errc::success)
110 return report(std::string("Could not create directory: ") + outputDir.str(),
111 Diag);
112
113 std::string errMsg;
114 std::string infoFile = getRemapInfoFile(outputDir);
115 llvm::raw_fd_ostream infoOut(infoFile.c_str(), errMsg,
116 llvm::raw_fd_ostream::F_Binary);
117 if (!errMsg.empty())
118 return report(errMsg, Diag);
119
120 for (MappingsTy::iterator
121 I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
122
123 const FileEntry *origFE = I->first;
124 llvm::SmallString<200> origPath = llvm::StringRef(origFE->getName());
125 fs::make_absolute(origPath);
126 infoOut << origPath << '\n';
127 infoOut << (uint64_t)origFE->getModificationTime() << '\n';
128
129 if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
130 llvm::SmallString<200> newPath = llvm::StringRef(FE->getName());
131 fs::make_absolute(newPath);
132 infoOut << newPath << '\n';
133 } else {
134
135 llvm::SmallString<64> tempPath;
136 tempPath = path::filename(origFE->getName());
137 tempPath += "-%%%%%%%%";
138 tempPath += path::extension(origFE->getName());
139 int fd;
140 if (fs::unique_file(tempPath.str(), fd, tempPath) != llvm::errc::success)
141 return report(std::string("Could not create file: ") + tempPath.c_str(),
142 Diag);
143
144 llvm::raw_fd_ostream newOut(fd, /*shouldClose=*/true);
145 llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
146 newOut.write(mem->getBufferStart(), mem->getBufferSize());
147 newOut.close();
148
149 const FileEntry *newE = FileMgr->getFile(tempPath);
150 remap(origFE, newE);
151 infoOut << newE->getName() << '\n';
152 }
153 }
154
155 infoOut.close();
156 return false;
157 }
158
overwriteOriginal(Diagnostic & Diag,llvm::StringRef outputDir)159 bool FileRemapper::overwriteOriginal(Diagnostic &Diag,
160 llvm::StringRef outputDir) {
161 using namespace llvm::sys;
162
163 for (MappingsTy::iterator
164 I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
165 const FileEntry *origFE = I->first;
166 if (const FileEntry *newFE = I->second.dyn_cast<const FileEntry *>()) {
167 if (fs::copy_file(newFE->getName(), origFE->getName(),
168 fs::copy_option::overwrite_if_exists) != llvm::errc::success) {
169 std::string err = "Could not copy file '";
170 llvm::raw_string_ostream os(err);
171 os << "Could not copy file '" << newFE->getName() << "' to file '"
172 << origFE->getName() << "'";
173 os.flush();
174 return report(err, Diag);
175 }
176 } else {
177
178 bool fileExists = false;
179 fs::exists(origFE->getName(), fileExists);
180 if (!fileExists)
181 return report(std::string("File does not exist: ") + origFE->getName(),
182 Diag);
183
184 std::string errMsg;
185 llvm::raw_fd_ostream Out(origFE->getName(), errMsg,
186 llvm::raw_fd_ostream::F_Binary);
187 if (!errMsg.empty())
188 return report(errMsg, Diag);
189
190 llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
191 Out.write(mem->getBufferStart(), mem->getBufferSize());
192 Out.close();
193 }
194 }
195
196 clear(outputDir);
197 return false;
198 }
199
applyMappings(CompilerInvocation & CI) const200 void FileRemapper::applyMappings(CompilerInvocation &CI) const {
201 PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
202 for (MappingsTy::const_iterator
203 I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
204 if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
205 PPOpts.addRemappedFile(I->first->getName(), FE->getName());
206 } else {
207 llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
208 PPOpts.addRemappedFile(I->first->getName(), mem);
209 }
210 }
211
212 PPOpts.RetainRemappedFileBuffers = true;
213 }
214
transferMappingsAndClear(CompilerInvocation & CI)215 void FileRemapper::transferMappingsAndClear(CompilerInvocation &CI) {
216 PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
217 for (MappingsTy::iterator
218 I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
219 if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
220 PPOpts.addRemappedFile(I->first->getName(), FE->getName());
221 } else {
222 llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
223 PPOpts.addRemappedFile(I->first->getName(), mem);
224 }
225 I->second = Target();
226 }
227
228 PPOpts.RetainRemappedFileBuffers = false;
229 clear();
230 }
231
remap(llvm::StringRef filePath,llvm::MemoryBuffer * memBuf)232 void FileRemapper::remap(llvm::StringRef filePath, llvm::MemoryBuffer *memBuf) {
233 remap(getOriginalFile(filePath), memBuf);
234 }
235
remap(llvm::StringRef filePath,llvm::StringRef newPath)236 void FileRemapper::remap(llvm::StringRef filePath, llvm::StringRef newPath) {
237 const FileEntry *file = getOriginalFile(filePath);
238 const FileEntry *newfile = FileMgr->getFile(newPath);
239 remap(file, newfile);
240 }
241
remap(const FileEntry * file,llvm::MemoryBuffer * memBuf)242 void FileRemapper::remap(const FileEntry *file, llvm::MemoryBuffer *memBuf) {
243 assert(file);
244 Target &targ = FromToMappings[file];
245 resetTarget(targ);
246 targ = memBuf;
247 }
248
remap(const FileEntry * file,const FileEntry * newfile)249 void FileRemapper::remap(const FileEntry *file, const FileEntry *newfile) {
250 assert(file && newfile);
251 Target &targ = FromToMappings[file];
252 resetTarget(targ);
253 targ = newfile;
254 ToFromMappings[newfile] = file;
255 }
256
getOriginalFile(llvm::StringRef filePath)257 const FileEntry *FileRemapper::getOriginalFile(llvm::StringRef filePath) {
258 const FileEntry *file = FileMgr->getFile(filePath);
259 // If we are updating a file that overriden an original file,
260 // actually update the original file.
261 llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
262 I = ToFromMappings.find(file);
263 if (I != ToFromMappings.end()) {
264 file = I->second;
265 assert(FromToMappings.find(file) != FromToMappings.end() &&
266 "Original file not in mappings!");
267 }
268 return file;
269 }
270
resetTarget(Target & targ)271 void FileRemapper::resetTarget(Target &targ) {
272 if (!targ)
273 return;
274
275 if (llvm::MemoryBuffer *oldmem = targ.dyn_cast<llvm::MemoryBuffer *>()) {
276 delete oldmem;
277 } else {
278 const FileEntry *toFE = targ.get<const FileEntry *>();
279 llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
280 I = ToFromMappings.find(toFE);
281 if (I != ToFromMappings.end())
282 ToFromMappings.erase(I);
283 }
284 }
285
report(const std::string & err,Diagnostic & Diag)286 bool FileRemapper::report(const std::string &err, Diagnostic &Diag) {
287 unsigned ID = Diag.getDiagnosticIDs()->getCustomDiagID(DiagnosticIDs::Error,
288 err);
289 Diag.Report(ID);
290 return true;
291 }
292