LLVM 20.0.0git
CodeGenCoverage.cpp
Go to the documentation of this file.
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
13
14#include "llvm/Support/Endian.h"
17#include "llvm/Support/Mutex.h"
21
22using namespace llvm;
23
25
27 if (RuleCoverage.size() <= RuleID)
28 RuleCoverage.resize(RuleID + 1, false);
29 RuleCoverage[RuleID] = true;
30}
31
33 if (RuleCoverage.size() <= RuleID)
34 return false;
35 return RuleCoverage[RuleID];
36}
37
40 return RuleCoverage.set_bits();
41}
42
43bool 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 =
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
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.
87
88 std::string CoverageFilename = (CoveragePrefix + Pid).str();
89
90 std::error_code EC;
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));
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
static const std::string CoveragePrefix
#define I(x, y, z)
Definition: MD5.cpp:58
Provides a library for accessing information about this process and other processes on the operating ...
void resize(unsigned N, bool t=false)
resize - Grow or shrink the bitvector.
Definition: BitVector.h:341
iterator_range< const_set_bits_iterator > set_bits() const
Definition: BitVector.h:140
size_type size() const
size - Returns the number of bits in this bitvector.
Definition: BitVector.h:159
bool empty() const
empty - Tests whether there are no bits in this bitvector.
Definition: BitVector.h:156
bool isCovered(uint64_t RuleID) const
void setCovered(uint64_t RuleID)
iterator_range< const_covered_iterator > covered() const
bool parse(MemoryBuffer &Buffer, StringRef BackendName)
bool emit(StringRef FilePrefix, StringRef BackendName) const
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:51
const char * getBufferEnd() const
Definition: MemoryBuffer.h:67
const char * getBufferStart() const
Definition: MemoryBuffer.h:66
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
A range adaptor for a pair of iterators.
static Pid getProcessId()
Get the process's identifier.
SmartMutex - A mutex with a compile time constant parameter that indicates whether this mutex should ...
Definition: Mutex.h:28
uint64_t read64(const void *P, endianness E)
Definition: Endian.h:408
@ OF_Append
The file should be opened in append mode.
Definition: FileSystem.h:770
std::lock_guard< SmartMutex< mt_only > > SmartScopedLock
Definition: Mutex.h:69
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:85