LLVM  11.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"
18 #include "llvm/Support/Process.h"
21 
22 using namespace llvm;
23 
25 
27 
28 void CodeGenCoverage::setCovered(uint64_t RuleID) {
29  if (RuleCoverage.size() <= RuleID)
30  RuleCoverage.resize(RuleID + 1, 0);
31  RuleCoverage[RuleID] = true;
32 }
33 
34 bool CodeGenCoverage::isCovered(uint64_t RuleID) const {
35  if (RuleCoverage.size() <= RuleID)
36  return false;
37  return RuleCoverage[RuleID];
38 }
39 
42  return RuleCoverage.set_bits();
43 }
44 
45 bool 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 
61  uint64_t RuleID = support::endian::read64(CurPtr, support::native);
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()) {
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;
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 
void resize(unsigned N, bool t=false)
resize - Grow or shrink the bitvector.
Definition: BitVector.h:372
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool empty() const
empty - Tests whether there are no bits in this bitvector.
Definition: BitVector.h:167
SmartMutex - A mutex with a compile time constant parameter that indicates whether this mutex should ...
Definition: Mutex.h:28
static sys::Mutex Lock
static Pid getProcessId()
Get the process&#39;s identifier.
bool parse(MemoryBuffer &Buffer, StringRef BackendName)
bool emit(StringRef FilePrefix, StringRef BackendName) const
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:156
void setCovered(uint64_t RuleID)
static const std::string CoveragePrefix
The file should be opened in append mode.
Definition: FileSystem.h:771
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:52
A range adaptor for a pair of iterators.
std::lock_guard< SmartMutex< mt_only > > SmartScopedLock
Definition: Mutex.h:71
LLVM_NODISCARD bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:190
const char * getBufferEnd() const
Definition: MemoryBuffer.h:68
Provides a library for accessing information about this process and other processes on the operating ...
static sys::SmartMutex< true > OutputMutex
iterator_range< const_covered_iterator > covered() const
#define I(x, y, z)
Definition: MD5.cpp:59
bool isCovered(uint64_t RuleID) const
size_type size() const
size - Returns the number of bits in this bitvector.
Definition: BitVector.h:170
const char * getBufferStart() const
Definition: MemoryBuffer.h:67
const std::string to_string(const T &Value)
Definition: ScopedPrinter.h:61
iterator_range< const_set_bits_iterator > set_bits() const
Definition: BitVector.h:130
uint64_t read64(const void *P, endianness E)
Definition: Endian.h:366
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57