LLVM 17.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
29 if (RuleCoverage.size() <= RuleID)
30 RuleCoverage.resize(RuleID + 1, false);
31 RuleCoverage[RuleID] = true;
32}
33
35 if (RuleCoverage.size() <= RuleID)
36 return false;
37 return RuleCoverage[RuleID];
38}
39
42 return RuleCoverage.set_bits();
43}
44
45bool 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
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
79 StringRef BackendName) const {
80 if (!CoveragePrefix.empty() && !RuleCoverage.empty()) {
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 sys::SmartMutex< true > OutputMutex
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:334
iterator_range< const_set_bits_iterator > set_bits() const
Definition: BitVector.h:133
size_type size() const
size - Returns the number of bits in this bitvector.
Definition: BitVector.h:152
bool empty() const
empty - Tests whether there are no bits in this bitvector.
Definition: BitVector.h:149
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
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:164
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:366
@ OF_Append
The file should be opened in append mode.
Definition: FileSystem.h:773
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