xref: /freebsd/contrib/llvm-project/llvm/lib/Support/CodeGenCoverage.cpp (revision 56b17de1e8360fe131d425de20b5e75ff3ea897c)
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 CodeGenCoverage::CodeGenCoverage() = default;
25 
26 void CodeGenCoverage::setCovered(uint64_t RuleID) {
27   if (RuleCoverage.size() <= RuleID)
28     RuleCoverage.resize(RuleID + 1, false);
29   RuleCoverage[RuleID] = true;
30 }
31 
32 bool CodeGenCoverage::isCovered(uint64_t RuleID) const {
33   if (RuleCoverage.size() <= RuleID)
34     return false;
35   return RuleCoverage[RuleID];
36 }
37 
38 iterator_range<CodeGenCoverage::const_covered_iterator>
39 CodeGenCoverage::covered() const {
40   return RuleCoverage.set_bits();
41 }
42 
43 bool CodeGenCoverage::parse(MemoryBuffer &Buffer, StringRef BackendName) {
44   const char *CurPtr = Buffer.getBufferStart();
45 
46   while (CurPtr != Buffer.getBufferEnd()) {
47     // Read the backend name from the input.
48     const char *LexedBackendName = CurPtr;
49     while (*CurPtr++ != 0)
50       ;
51     if (CurPtr == Buffer.getBufferEnd())
52       return false; // Data is invalid, expected rule id's to follow.
53 
54     bool IsForThisBackend = BackendName == LexedBackendName;
55     while (CurPtr != Buffer.getBufferEnd()) {
56       if (std::distance(CurPtr, Buffer.getBufferEnd()) < 8)
57         return false; // Data is invalid. Not enough bytes for another rule id.
58 
59       uint64_t RuleID =
60           support::endian::read64(CurPtr, llvm::endianness::native);
61       CurPtr += 8;
62 
63       // ~0ull terminates the rule id list.
64       if (RuleID == ~0ull)
65         break;
66 
67       // Anything else, is recorded or ignored depending on whether it's
68       // intended for the backend we're interested in.
69       if (IsForThisBackend)
70         setCovered(RuleID);
71     }
72   }
73 
74   return true;
75 }
76 
77 bool CodeGenCoverage::emit(StringRef CoveragePrefix,
78                            StringRef BackendName) const {
79   if (!CoveragePrefix.empty() && !RuleCoverage.empty()) {
80     static sys::SmartMutex<true> OutputMutex;
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