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