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