Home | History | Annotate | Line # | Download | only in Support 
      1 //===- lib/Support/CodeGenCoverage.cpp -------------------------------------==//
      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 /// \file
      9 /// This file implements the CodeGenCoverage class.
     10 //===----------------------------------------------------------------------===//
     11 
     12 #include "llvm/Support/CodeGenCoverage.h"
     13 
     14 #include "llvm/Support/Endian.h"
     15 #include "llvm/Support/FileSystem.h"
     16 #include "llvm/Support/MemoryBuffer.h"
     17 #include "llvm/Support/Mutex.h"
     18 #include "llvm/Support/Process.h"
     19 #include "llvm/Support/ScopedPrinter.h"
     20 #include "llvm/Support/ToolOutputFile.h"
     21 
     22 using namespace llvm;
     23 
     24 static sys::SmartMutex<true> OutputMutex;
     25 
     26 CodeGenCoverage::CodeGenCoverage() {}
     27 
     28 void CodeGenCoverage::setCovered(uint64_t RuleID) {
     29   if (RuleCoverage.size() <= RuleID)
     30     RuleCoverage.resize(RuleID + 1, 0);
     31   RuleCoverage[RuleID] = true;
     32 }
     33 
     34 bool CodeGenCoverage::isCovered(uint64_t RuleID) const {
     35   if (RuleCoverage.size() <= RuleID)
     36     return false;
     37   return RuleCoverage[RuleID];
     38 }
     39 
     40 iterator_range<CodeGenCoverage::const_covered_iterator>
     41 CodeGenCoverage::covered() const {
     42   return RuleCoverage.set_bits();
     43 }
     44 
     45 bool CodeGenCoverage::parse(MemoryBuffer &Buffer, StringRef BackendName) {
     46   const char *CurPtr = Buffer.getBufferStart();
     47 
     48   while (CurPtr != Buffer.getBufferEnd()) {
     49     // Read the backend name from the input.
     50     const char *LexedBackendName = CurPtr;
     51     while (*CurPtr++ != 0)
     52       ;
     53     if (CurPtr == Buffer.getBufferEnd())
     54       return false; // Data is invalid, expected rule id's to follow.
     55 
     56     bool IsForThisBackend = BackendName.equals(LexedBackendName);
     57     while (CurPtr != Buffer.getBufferEnd()) {
     58       if (std::distance(CurPtr, Buffer.getBufferEnd()) < 8)
     59         return false; // Data is invalid. Not enough bytes for another rule id.
     60 
     61       uint64_t RuleID = support::endian::read64(CurPtr, support::native);
     62       CurPtr += 8;
     63 
     64       // ~0ull terminates the rule id list.
     65       if (RuleID == ~0ull)
     66         break;
     67 
     68       // Anything else, is recorded or ignored depending on whether it's
     69       // intended for the backend we're interested in.
     70       if (IsForThisBackend)
     71         setCovered(RuleID);
     72     }
     73   }
     74 
     75   return true;
     76 }
     77 
     78 bool CodeGenCoverage::emit(StringRef CoveragePrefix,
     79                            StringRef BackendName) const {
     80   if (!CoveragePrefix.empty() && !RuleCoverage.empty()) {
     81     sys::SmartScopedLock<true> Lock(OutputMutex);
     82 
     83     // We can handle locking within a process easily enough but we don't want to
     84     // manage it between multiple processes. Use the process ID to ensure no
     85     // more than one process is ever writing to the same file at the same time.
     86     std::string Pid = llvm::to_string(sys::Process::getProcessId());
     87 
     88     std::string CoverageFilename = (CoveragePrefix + Pid).str();
     89 
     90     std::error_code EC;
     91     sys::fs::OpenFlags OpenFlags = sys::fs::OF_Append;
     92     std::unique_ptr<ToolOutputFile> CoverageFile =
     93         std::make_unique<ToolOutputFile>(CoverageFilename, EC, OpenFlags);
     94     if (EC)
     95       return false;
     96 
     97     uint64_t Zero = 0;
     98     uint64_t InvZero = ~0ull;
     99     CoverageFile->os() << BackendName;
    100     CoverageFile->os().write((const char *)&Zero, sizeof(unsigned char));
    101     for (uint64_t I : RuleCoverage.set_bits())
    102       CoverageFile->os().write((const char *)&I, sizeof(uint64_t));
    103     CoverageFile->os().write((const char *)&InvZero, sizeof(uint64_t));
    104 
    105     CoverageFile->keep();
    106   }
    107 
    108   return true;
    109 }
    110 
    111 void CodeGenCoverage::reset() { RuleCoverage.resize(0); }
    112