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/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 
     22 FileRemapper::FileRemapper() {
     23   FileMgr.reset(new FileManager(FileSystemOptions()));
     24 }
     25 
     26 FileRemapper::~FileRemapper() {
     27   clear();
     28 }
     29 
     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 
     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 
     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 
    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 
    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 
    200 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 
    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 
    232 void FileRemapper::remap(llvm::StringRef filePath, llvm::MemoryBuffer *memBuf) {
    233   remap(getOriginalFile(filePath), memBuf);
    234 }
    235 
    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 
    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 
    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 
    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 
    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 
    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