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