Home | History | Annotate | Line # | Download | only in ARCMigrate 
      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 
      9 #include "clang/ARCMigrate/FileRemapper.h"
     10 #include "clang/Basic/Diagnostic.h"
     11 #include "clang/Basic/FileManager.h"
     12 #include "clang/Lex/PreprocessorOptions.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 
     22 FileRemapper::FileRemapper() {
     23   FileMgr.reset(new FileManager(FileSystemOptions()));
     24 }
     25 
     26 FileRemapper::~FileRemapper() {
     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 
     49 bool FileRemapper::initFromDisk(StringRef outputDir, DiagnosticsEngine &Diag,
     50                                 bool ignoreIfFilesChanged) {
     51   std::string infoFile = getRemapInfoFile(outputDir);
     52   return initFromFile(infoFile, Diag, ignoreIfFilesChanged);
     53 }
     54 
     55 bool FileRemapper::initFromFile(StringRef filePath, DiagnosticsEngine &Diag,
     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 
     70   SmallVector<StringRef, 64> lines;
     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 
    168 bool FileRemapper::overwriteOriginal(DiagnosticsEngine &Diag,
    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 
    194 void FileRemapper::forEachMapping(
    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 
    209 void FileRemapper::applyMappings(PreprocessorOptions &PPOpts) const {
    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 }
    277